289223c5af639b5f103f52052e690b62ba9c70ed
[libav.git] / ffmpeg.c
1 /*
2 * FFmpeg main
3 * Copyright (c) 2000-2003 Fabrice Bellard
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19 #define HAVE_AV_CONFIG_H
20 #include <limits.h>
21 #include "avformat.h"
22 #include "framehook.h"
23
24 #ifndef CONFIG_WIN32
25 #include <unistd.h>
26 #include <fcntl.h>
27 #include <sys/ioctl.h>
28 #include <sys/time.h>
29 #include <termios.h>
30 #include <sys/resource.h>
31 #include <signal.h>
32 #endif
33 #ifdef CONFIG_OS2
34 #include <sys/types.h>
35 #include <sys/select.h>
36 #include <stdlib.h>
37 #endif
38 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
39 #include <time.h>
40
41 #include "cmdutils.h"
42
43 #if !defined(INFINITY) && defined(HUGE_VAL)
44 #define INFINITY HUGE_VAL
45 #endif
46
47 /* select an input stream for an output stream */
48 typedef struct AVStreamMap {
49 int file_index;
50 int stream_index;
51 } AVStreamMap;
52
53 extern const OptionDef options[];
54
55 static void show_help(void);
56 static void show_license(void);
57
58 #define MAX_FILES 20
59
60 static AVFormatContext *input_files[MAX_FILES];
61 static int nb_input_files = 0;
62
63 static AVFormatContext *output_files[MAX_FILES];
64 static int nb_output_files = 0;
65
66 static AVStreamMap stream_maps[MAX_FILES];
67 static int nb_stream_maps;
68
69 static AVInputFormat *file_iformat;
70 static AVOutputFormat *file_oformat;
71 static AVImageFormat *image_format;
72 static int frame_width = 160;
73 static int frame_height = 128;
74 static float frame_aspect_ratio = 0;
75 static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
76 static int frame_padtop = 0;
77 static int frame_padbottom = 0;
78 static int frame_padleft = 0;
79 static int frame_padright = 0;
80 static int padcolor[3] = {16,128,128}; /* default to black */
81 static int frame_topBand = 0;
82 static int frame_bottomBand = 0;
83 static int frame_leftBand = 0;
84 static int frame_rightBand = 0;
85 static int frame_rate = 25;
86 static int frame_rate_base = 1;
87 static int video_bit_rate = 200*1000;
88 static int video_bit_rate_tolerance = 4000*1000;
89 static float video_qscale = 0;
90 static int video_qmin = 2;
91 static int video_qmax = 31;
92 static int video_lmin = 2*FF_QP2LAMBDA;
93 static int video_lmax = 31*FF_QP2LAMBDA;
94 static int video_mb_qmin = 2;
95 static int video_mb_qmax = 31;
96 static int video_qdiff = 3;
97 static float video_qblur = 0.5;
98 static float video_qcomp = 0.5;
99 static uint16_t *intra_matrix = NULL;
100 static uint16_t *inter_matrix = NULL;
101 #if 0 //experimental, (can be removed)
102 static float video_rc_qsquish=1.0;
103 static float video_rc_qmod_amp=0;
104 static int video_rc_qmod_freq=0;
105 #endif
106 static char *video_rc_override_string=NULL;
107 static char *video_rc_eq="tex^qComp";
108 static int video_rc_buffer_size=0;
109 static float video_rc_buffer_aggressivity=1.0;
110 static int video_rc_max_rate=0;
111 static int video_rc_min_rate=0;
112 static float video_rc_initial_cplx=0;
113 static float video_b_qfactor = 1.25;
114 static float video_b_qoffset = 1.25;
115 static float video_i_qfactor = -0.8;
116 static float video_i_qoffset = 0.0;
117 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
118 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
119 static int me_method = ME_EPZS;
120 static int video_disable = 0;
121 static int video_codec_id = CODEC_ID_NONE;
122 static int same_quality = 0;
123 static int b_frames = 0;
124 static int mb_decision = FF_MB_DECISION_SIMPLE;
125 static int ildct_cmp = FF_CMP_VSAD;
126 static int mb_cmp = FF_CMP_SAD;
127 static int sub_cmp = FF_CMP_SAD;
128 static int cmp = FF_CMP_SAD;
129 static int pre_cmp = FF_CMP_SAD;
130 static int pre_me = 0;
131 static float lumi_mask = 0;
132 static float dark_mask = 0;
133 static float scplx_mask = 0;
134 static float tcplx_mask = 0;
135 static float p_mask = 0;
136 static int use_4mv = 0;
137 static int use_obmc = 0;
138 static int use_loop = 0;
139 static int use_aic = 0;
140 static int use_aiv = 0;
141 static int use_umv = 0;
142 static int use_ss = 0;
143 static int use_alt_scan = 0;
144 static int use_trell = 0;
145 static int use_scan_offset = 0;
146 static int use_qpel = 0;
147 static int qns = 0;
148 static int closed_gop = 0;
149 static int do_deinterlace = 0;
150 static int do_interlace_dct = 0;
151 static int do_interlace_me = 0;
152 static int workaround_bugs = FF_BUG_AUTODETECT;
153 static int error_resilience = 2;
154 static int error_concealment = 3;
155 static int dct_algo = 0;
156 static int idct_algo = 0;
157 static int use_part = 0;
158 static int packet_size = 0;
159 static int error_rate = 0;
160 static int strict = 0;
161 static int top_field_first = -1;
162 static int noise_reduction = 0;
163 static int sc_threshold = 0;
164 static int debug = 0;
165 static int debug_mv = 0;
166 static int me_threshold = 0;
167 static int mb_threshold = 0;
168 static int intra_dc_precision = 0;
169 static int coder = 0;
170 static int context = 0;
171 static int predictor = 0;
172 extern int loop_input; /* currently a hack */
173
174 static int gop_size = 12;
175 static int intra_only = 0;
176 static int audio_sample_rate = 44100;
177 static int audio_bit_rate = 64000;
178 static int audio_disable = 0;
179 static int audio_channels = 1;
180 static int audio_codec_id = CODEC_ID_NONE;
181
182 static int64_t recording_time = 0;
183 static int64_t start_time = 0;
184 static int64_t rec_timestamp = 0;
185 static int file_overwrite = 0;
186 static char *str_title = NULL;
187 static char *str_author = NULL;
188 static char *str_copyright = NULL;
189 static char *str_comment = NULL;
190 static int do_benchmark = 0;
191 static int do_hex_dump = 0;
192 static int do_pkt_dump = 0;
193 static int do_psnr = 0;
194 static int do_vstats = 0;
195 static int do_pass = 0;
196 static int bitexact = 0;
197 static char *pass_logfilename = NULL;
198 static int audio_stream_copy = 0;
199 static int video_stream_copy = 0;
200 static int sync_method= 1;
201
202 static int rate_emu = 0;
203
204 static char *video_grab_format = "video4linux";
205 static char *video_device = NULL;
206 static int video_channel = 0;
207 static char *video_standard = "ntsc";
208
209 static char *audio_grab_format = "audio_device";
210 static char *audio_device = NULL;
211
212 static int using_stdin = 0;
213 static int using_vhook = 0;
214 static int verbose = 1;
215 static int thread_count= 1;
216 static int q_pressed = 0;
217 static int me_range = 0;
218 static int64_t video_size = 0;
219 static int64_t audio_size = 0;
220 static int64_t extra_size = 0;
221
222 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
223
224 typedef struct AVOutputStream {
225 int file_index; /* file index */
226 int index; /* stream index in the output file */
227 int source_index; /* AVInputStream index */
228 AVStream *st; /* stream in the output file */
229 int encoding_needed; /* true if encoding needed for this stream */
230 int frame_number;
231 /* input pts and corresponding output pts
232 for A/V sync */
233 double sync_ipts;
234 double sync_ipts_offset;
235 int64_t sync_opts;
236 /* video only */
237 int video_resample; /* video_resample and video_crop are mutually exclusive */
238 AVFrame pict_tmp; /* temporary image for resampling */
239 ImgReSampleContext *img_resample_ctx; /* for image resampling */
240
241 int video_crop; /* video_resample and video_crop are mutually exclusive */
242 int topBand; /* cropping area sizes */
243 int leftBand;
244
245 int video_pad; /* video_resample and video_pad are mutually exclusive */
246 int padtop; /* padding area sizes */
247 int padbottom;
248 int padleft;
249 int padright;
250
251 /* audio only */
252 int audio_resample;
253 ReSampleContext *resample; /* for audio resampling */
254 FifoBuffer fifo; /* for compression: one audio fifo per codec */
255 FILE *logfile;
256 } AVOutputStream;
257
258 typedef struct AVInputStream {
259 int file_index;
260 int index;
261 AVStream *st;
262 int discard; /* true if stream data should be discarded */
263 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
264 int64_t sample_index; /* current sample */
265
266 int64_t start; /* time when read started */
267 unsigned long frame; /* current frame */
268 int64_t next_pts; /* synthetic pts for cases where pkt.pts
269 is not defined */
270 int64_t pts; /* current pts */
271 } AVInputStream;
272
273 typedef struct AVInputFile {
274 int eof_reached; /* true if eof reached */
275 int ist_index; /* index of first stream in ist_table */
276 int buffer_size; /* current total buffer size */
277 int buffer_size_max; /* buffer size at which we consider we can stop
278 buffering */
279 int nb_streams; /* nb streams we are aware of */
280 } AVInputFile;
281
282 #ifndef CONFIG_WIN32
283
284 /* init terminal so that we can grab keys */
285 static struct termios oldtty;
286
287 static void term_exit(void)
288 {
289 tcsetattr (0, TCSANOW, &oldtty);
290 }
291
292 static volatile sig_atomic_t received_sigterm = 0;
293
294 static void
295 sigterm_handler(int sig)
296 {
297 received_sigterm = sig;
298 term_exit();
299 }
300
301 static void term_init(void)
302 {
303 struct termios tty;
304
305 tcgetattr (0, &tty);
306 oldtty = tty;
307
308 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
309 |INLCR|IGNCR|ICRNL|IXON);
310 tty.c_oflag |= OPOST;
311 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
312 tty.c_cflag &= ~(CSIZE|PARENB);
313 tty.c_cflag |= CS8;
314 tty.c_cc[VMIN] = 1;
315 tty.c_cc[VTIME] = 0;
316
317 tcsetattr (0, TCSANOW, &tty);
318
319 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
320 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
321 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
322 /*
323 register a function to be called at normal program termination
324 */
325 atexit(term_exit);
326 #ifdef CONFIG_BEOS_NETSERVER
327 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
328 #endif
329 }
330
331 /* read a key without blocking */
332 static int read_key(void)
333 {
334 int n = 1;
335 unsigned char ch;
336 #ifndef CONFIG_BEOS_NETSERVER
337 struct timeval tv;
338 fd_set rfds;
339
340 FD_ZERO(&rfds);
341 FD_SET(0, &rfds);
342 tv.tv_sec = 0;
343 tv.tv_usec = 0;
344 n = select(1, &rfds, NULL, NULL, &tv);
345 #endif
346 if (n > 0) {
347 n = read(0, &ch, 1);
348 if (n == 1)
349 return ch;
350
351 return n;
352 }
353 return -1;
354 }
355
356 static int decode_interrupt_cb(void)
357 {
358 return q_pressed || (q_pressed = read_key() == 'q');
359 }
360
361 #else
362
363 static volatile int received_sigterm = 0;
364
365 /* no interactive support */
366 static void term_exit(void)
367 {
368 }
369
370 static void term_init(void)
371 {
372 }
373
374 static int read_key(void)
375 {
376 return 0;
377 }
378
379 #endif
380
381 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
382 {
383 int i, err;
384 AVFormatContext *ic;
385
386 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
387 if (err < 0)
388 return err;
389 /* copy stream format */
390 s->nb_streams = ic->nb_streams;
391 for(i=0;i<ic->nb_streams;i++) {
392 AVStream *st;
393
394 st = av_mallocz(sizeof(AVStream));
395 memcpy(st, ic->streams[i], sizeof(AVStream));
396 s->streams[i] = st;
397 }
398
399 av_close_input_file(ic);
400 return 0;
401 }
402
403 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
404
405 static void do_audio_out(AVFormatContext *s,
406 AVOutputStream *ost,
407 AVInputStream *ist,
408 unsigned char *buf, int size)
409 {
410 uint8_t *buftmp;
411 static uint8_t *audio_buf = NULL;
412 static uint8_t *audio_out = NULL;
413 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
414
415 int size_out, frame_bytes, ret;
416 AVCodecContext *enc;
417
418 /* SC: dynamic allocation of buffers */
419 if (!audio_buf)
420 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
421 if (!audio_out)
422 audio_out = av_malloc(audio_out_size);
423 if (!audio_buf || !audio_out)
424 return; /* Should signal an error ! */
425
426
427 enc = &ost->st->codec;
428
429 if (ost->audio_resample) {
430 buftmp = audio_buf;
431 size_out = audio_resample(ost->resample,
432 (short *)buftmp, (short *)buf,
433 size / (ist->st->codec.channels * 2));
434 size_out = size_out * enc->channels * 2;
435 } else {
436 buftmp = buf;
437 size_out = size;
438 }
439
440 /* now encode as many frames as possible */
441 if (enc->frame_size > 1) {
442 /* output resampled raw samples */
443 fifo_write(&ost->fifo, buftmp, size_out,
444 &ost->fifo.wptr);
445
446 frame_bytes = enc->frame_size * 2 * enc->channels;
447
448 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
449 &ost->fifo.rptr) == 0) {
450 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
451 (short *)audio_buf);
452 audio_size += ret;
453 av_write_frame(s, ost->index, audio_out, ret);
454 }
455 } else {
456 /* output a pcm frame */
457 /* XXX: change encoding codec API to avoid this ? */
458 switch(enc->codec->id) {
459 case CODEC_ID_PCM_S16LE:
460 case CODEC_ID_PCM_S16BE:
461 case CODEC_ID_PCM_U16LE:
462 case CODEC_ID_PCM_U16BE:
463 break;
464 default:
465 size_out = size_out >> 1;
466 break;
467 }
468 ret = avcodec_encode_audio(enc, audio_out, size_out,
469 (short *)buftmp);
470 audio_size += ret;
471 av_write_frame(s, ost->index, audio_out, ret);
472 }
473 }
474
475 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
476 {
477 AVCodecContext *dec;
478 AVPicture *picture2;
479 AVPicture picture_tmp;
480 uint8_t *buf = 0;
481
482 dec = &ist->st->codec;
483
484 /* deinterlace : must be done before any resize */
485 if (do_deinterlace || using_vhook) {
486 int size;
487
488 /* create temporary picture */
489 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
490 buf = av_malloc(size);
491 if (!buf)
492 return;
493
494 picture2 = &picture_tmp;
495 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
496
497 if (do_deinterlace){
498 if(avpicture_deinterlace(picture2, picture,
499 dec->pix_fmt, dec->width, dec->height) < 0) {
500 /* if error, do not deinterlace */
501 av_free(buf);
502 buf = NULL;
503 picture2 = picture;
504 }
505 } else {
506 if (img_convert(picture2, dec->pix_fmt, picture,
507 dec->pix_fmt, dec->width, dec->height) < 0) {
508 /* if error, do not copy */
509 av_free(buf);
510 buf = NULL;
511 picture2 = picture;
512 }
513 }
514 } else {
515 picture2 = picture;
516 }
517
518 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
519
520 if (picture != picture2)
521 *picture = *picture2;
522 *bufp = buf;
523 }
524
525 /* we begin to correct av delay at this threshold */
526 #define AV_DELAY_MAX 0.100
527
528
529 /* Expects img to be yuv420 */
530 static void fill_pad_region(AVPicture* img, int height, int width,
531 int padtop, int padbottom, int padleft, int padright, int *color) {
532
533 int i, y, shift;
534 uint8_t *optr;
535
536 for (i = 0; i < 3; i++) {
537 shift = (i == 0) ? 0 : 1;
538
539 if (padtop || padleft) {
540 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
541 padleft) >> shift));
542 }
543
544 if (padleft || padright) {
545 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
546 (img->linesize[i] - (padright >> shift));
547
548 for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
549 memset(optr, color[i], (padleft + padright) >> shift);
550 optr += img->linesize[i];
551 }
552 }
553
554 if (padbottom) {
555 optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
556 memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
557 }
558 }
559 }
560
561
562 static void do_video_out(AVFormatContext *s,
563 AVOutputStream *ost,
564 AVInputStream *ist,
565 AVFrame *in_picture,
566 int *frame_size, AVOutputStream *audio_sync)
567 {
568 int nb_frames, i, ret;
569 AVFrame *final_picture, *formatted_picture;
570 AVFrame picture_format_temp, picture_crop_temp;
571 static uint8_t *video_buffer= NULL;
572 uint8_t *buf = NULL, *buf1 = NULL;
573 AVCodecContext *enc, *dec;
574 enum PixelFormat target_pixfmt;
575
576 #define VIDEO_BUFFER_SIZE (1024*1024)
577
578 avcodec_get_frame_defaults(&picture_format_temp);
579 avcodec_get_frame_defaults(&picture_crop_temp);
580
581 enc = &ost->st->codec;
582 dec = &ist->st->codec;
583
584 /* by default, we output a single frame */
585 nb_frames = 1;
586
587 *frame_size = 0;
588
589 /* NOTE: the A/V sync is always done by considering the audio is
590 the master clock. It is suffisant for transcoding or playing,
591 but not for the general case */
592 if(sync_method){
593 if (audio_sync) {
594 /* compute the A-V delay and duplicate/remove frames if needed */
595 double adelta, vdelta, av_delay;
596
597 adelta = audio_sync->sync_ipts - ((double)audio_sync->sync_opts *
598 audio_sync->st->time_base.num / audio_sync->st->time_base.den);
599
600 vdelta = ost->sync_ipts - ((double)ost->sync_opts *
601 ost->st->time_base.num / ost->st->time_base.den);
602
603 av_delay = adelta - vdelta;
604 if (av_delay < -AV_DELAY_MAX)
605 nb_frames = 2;
606 else if (av_delay > AV_DELAY_MAX)
607 nb_frames = 0;
608 // printf("adelta=%f vdelta=%f delay=%f nb=%d (A)\n", adelta, vdelta, av_delay, nb_frames);
609 } else {
610 double vdelta;
611
612 vdelta = (double)(ost->st->pts.val) * ost->st->time_base.num / ost->st->time_base.den - (ost->sync_ipts - ost->sync_ipts_offset);
613 if (vdelta < 100 && vdelta > -100 && ost->sync_ipts_offset) {
614 if (vdelta < -AV_DELAY_MAX)
615 nb_frames = 2;
616 else if (vdelta > AV_DELAY_MAX)
617 nb_frames = 0;
618 } else {
619 ost->sync_ipts_offset -= vdelta;
620 if (!ost->sync_ipts_offset)
621 ost->sync_ipts_offset = 0.000001; /* one microsecond */
622 }
623 // printf("delay=%f nb=%d (V)\n",vdelta, nb_frames);
624 }
625 }
626
627 #if defined(AVSYNC_DEBUG)
628 {
629 static char *action[] = { "drop frame", "copy frame", "dup frame" };
630 if (audio_sync && verbose >=0) {
631 fprintf(stderr, "Input APTS %12.6f, output APTS %12.6f, ",
632 (double) audio_sync->sync_ipts,
633 (double) audio_sync->st->pts.val * st->time_base.num / st->time_base.den);
634 fprintf(stderr, "Input VPTS %12.6f, output VPTS %12.6f: %s\n",
635 (double) ost->sync_ipts,
636 (double) ost->st->pts.val * st->time_base.num / st->time_base.den,
637 action[nb_frames]);
638 }
639 }
640 #endif
641
642 if (nb_frames <= 0)
643 return;
644
645 if (!video_buffer)
646 video_buffer = av_malloc(VIDEO_BUFFER_SIZE);
647 if (!video_buffer)
648 return;
649
650 /* convert pixel format if needed */
651 target_pixfmt = ost->video_resample || ost->video_pad
652 ? PIX_FMT_YUV420P : enc->pix_fmt;
653 if (dec->pix_fmt != target_pixfmt) {
654 int size;
655
656 /* create temporary picture */
657 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
658 buf = av_malloc(size);
659 if (!buf)
660 return;
661 formatted_picture = &picture_format_temp;
662 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
663
664 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
665 (AVPicture *)in_picture, dec->pix_fmt,
666 dec->width, dec->height) < 0) {
667
668 if (verbose >= 0)
669 fprintf(stderr, "pixel format conversion not handled\n");
670
671 goto the_end;
672 }
673 } else {
674 formatted_picture = in_picture;
675 }
676
677 /* XXX: resampling could be done before raw format conversion in
678 some cases to go faster */
679 /* XXX: only works for YUV420P */
680 if (ost->video_resample) {
681 final_picture = &ost->pict_tmp;
682 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
683
684 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
685 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
686 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
687 padcolor);
688 }
689
690 if (enc->pix_fmt != PIX_FMT_YUV420P) {
691 int size;
692
693 av_free(buf);
694 /* create temporary picture */
695 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
696 buf = av_malloc(size);
697 if (!buf)
698 return;
699 final_picture = &picture_format_temp;
700 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
701
702 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
703 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
704 enc->width, enc->height) < 0) {
705
706 if (verbose >= 0)
707 fprintf(stderr, "pixel format conversion not handled\n");
708
709 goto the_end;
710 }
711 }
712 } else if (ost->video_crop) {
713 picture_crop_temp.data[0] = formatted_picture->data[0] +
714 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
715
716 picture_crop_temp.data[1] = formatted_picture->data[1] +
717 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
718 (ost->leftBand >> 1);
719
720 picture_crop_temp.data[2] = formatted_picture->data[2] +
721 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
722 (ost->leftBand >> 1);
723
724 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
725 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
726 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
727 final_picture = &picture_crop_temp;
728 } else if (ost->video_pad) {
729 final_picture = &ost->pict_tmp;
730
731 for (i = 0; i < 3; i++) {
732 uint8_t *optr, *iptr;
733 int shift = (i == 0) ? 0 : 1;
734 int y, yheight;
735
736 /* set offset to start writing image into */
737 optr = final_picture->data[i] + (((final_picture->linesize[i] *
738 ost->padtop) + ost->padleft) >> shift);
739 iptr = formatted_picture->data[i];
740
741 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
742 for (y = 0; y < yheight; y++) {
743 /* copy unpadded image row into padded image row */
744 memcpy(optr, iptr, formatted_picture->linesize[i]);
745 optr += final_picture->linesize[i];
746 iptr += formatted_picture->linesize[i];
747 }
748 }
749
750 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
751 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
752 padcolor);
753
754 if (enc->pix_fmt != PIX_FMT_YUV420P) {
755 int size;
756
757 av_free(buf);
758 /* create temporary picture */
759 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
760 buf = av_malloc(size);
761 if (!buf)
762 return;
763 final_picture = &picture_format_temp;
764 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
765
766 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
767 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
768 enc->width, enc->height) < 0) {
769
770 if (verbose >= 0)
771 fprintf(stderr, "pixel format conversion not handled\n");
772
773 goto the_end;
774 }
775 }
776 } else {
777 final_picture = formatted_picture;
778 }
779 /* duplicates frame if needed */
780 /* XXX: pb because no interleaving */
781 for(i=0;i<nb_frames;i++) {
782 if (s->oformat->flags & AVFMT_RAWPICTURE) {
783 /* raw pictures are written as AVPicture structure to
784 avoid any copies. We support temorarily the older
785 method. */
786 AVFrame* old_frame = enc->coded_frame;
787 enc->coded_frame = dec->coded_frame;
788 av_write_frame(s, ost->index,
789 (uint8_t *)final_picture, sizeof(AVPicture));
790 enc->coded_frame = old_frame;
791 } else {
792 AVFrame big_picture;
793
794 big_picture= *final_picture;
795 /* better than nothing: use input picture interlaced
796 settings */
797 big_picture.interlaced_frame = in_picture->interlaced_frame;
798 if(do_interlace_me || do_interlace_dct){
799 if(top_field_first == -1)
800 big_picture.top_field_first = in_picture->top_field_first;
801 else
802 big_picture.top_field_first = 1;
803 }
804
805 /* handles sameq here. This is not correct because it may
806 not be a global option */
807 if (same_quality) {
808 big_picture.quality = ist->st->quality;
809 }else
810 big_picture.quality = ost->st->quality;
811 if(!me_threshold)
812 big_picture.pict_type = 0;
813 big_picture.pts = AV_NOPTS_VALUE; //FIXME
814 ret = avcodec_encode_video(enc,
815 video_buffer, VIDEO_BUFFER_SIZE,
816 &big_picture);
817 //enc->frame_number = enc->real_pict_num;
818 av_write_frame(s, ost->index, video_buffer, ret);
819 *frame_size = ret;
820 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
821 // enc->frame_number-1, enc->real_pict_num, ret,
822 // enc->pict_type);
823 /* if two pass, output log */
824 if (ost->logfile && enc->stats_out) {
825 fprintf(ost->logfile, "%s", enc->stats_out);
826 }
827 }
828 ost->frame_number++;
829 }
830 the_end:
831 av_free(buf);
832 av_free(buf1);
833 }
834
835 static double psnr(double d){
836 if(d==0) return INFINITY;
837 return -10.0*log(d)/log(10.0);
838 }
839
840 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
841 int frame_size)
842 {
843 static FILE *fvstats=NULL;
844 char filename[40];
845 time_t today2;
846 struct tm *today;
847 AVCodecContext *enc;
848 int frame_number;
849 int64_t ti;
850 double ti1, bitrate, avg_bitrate;
851
852 if (!fvstats) {
853 today2 = time(NULL);
854 today = localtime(&today2);
855 sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
856 today->tm_min,
857 today->tm_sec);
858 fvstats = fopen(filename,"w");
859 if (!fvstats) {
860 perror("fopen");
861 exit(1);
862 }
863 }
864
865 ti = MAXINT64;
866 enc = &ost->st->codec;
867 if (enc->codec_type == CODEC_TYPE_VIDEO) {
868 frame_number = ost->frame_number;
869 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
870 if (enc->flags&CODEC_FLAG_PSNR)
871 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
872
873 fprintf(fvstats,"f_size= %6d ", frame_size);
874 /* compute pts value */
875 ti1 = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
876 if (ti1 < 0.01)
877 ti1 = 0.01;
878
879 bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
880 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
881 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
882 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
883 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
884 }
885 }
886
887 static void print_report(AVFormatContext **output_files,
888 AVOutputStream **ost_table, int nb_ostreams,
889 int is_last_report)
890 {
891 char buf[1024];
892 AVOutputStream *ost;
893 AVFormatContext *oc, *os;
894 int64_t total_size;
895 AVCodecContext *enc;
896 int frame_number, vid, i;
897 double bitrate, ti1, pts;
898 static int64_t last_time = -1;
899
900 if (!is_last_report) {
901 int64_t cur_time;
902 /* display the report every 0.5 seconds */
903 cur_time = av_gettime();
904 if (last_time == -1) {
905 last_time = cur_time;
906 return;
907 }
908 if ((cur_time - last_time) < 500000)
909 return;
910 last_time = cur_time;
911 }
912
913
914 oc = output_files[0];
915
916 total_size = url_ftell(&oc->pb);
917
918 buf[0] = '\0';
919 ti1 = 1e10;
920 vid = 0;
921 for(i=0;i<nb_ostreams;i++) {
922 ost = ost_table[i];
923 os = output_files[ost->file_index];
924 enc = &ost->st->codec;
925 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
926 sprintf(buf + strlen(buf), "q=%2.1f ",
927 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
928 }
929 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
930 frame_number = ost->frame_number;
931 sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
932 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
933 if(is_last_report)
934 sprintf(buf + strlen(buf), "L");
935 if (enc->flags&CODEC_FLAG_PSNR){
936 int j;
937 double error, error_sum=0;
938 double scale, scale_sum=0;
939 char type[3]= {'Y','U','V'};
940 sprintf(buf + strlen(buf), "PSNR=");
941 for(j=0; j<3; j++){
942 if(is_last_report){
943 error= enc->error[j];
944 scale= enc->width*enc->height*255.0*255.0*frame_number;
945 }else{
946 error= enc->coded_frame->error[j];
947 scale= enc->width*enc->height*255.0*255.0;
948 }
949 if(j) scale/=4;
950 error_sum += error;
951 scale_sum += scale;
952 sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
953 }
954 sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
955 }
956 vid = 1;
957 }
958 /* compute min output value */
959 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
960 if ((pts < ti1) && (pts > 0))
961 ti1 = pts;
962 }
963 if (ti1 < 0.01)
964 ti1 = 0.01;
965
966 if (verbose || is_last_report) {
967 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
968
969 sprintf(buf + strlen(buf),
970 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
971 (double)total_size / 1024, ti1, bitrate);
972
973 if (verbose >= 0)
974 fprintf(stderr, "%s \r", buf);
975
976 fflush(stderr);
977 }
978
979 if (is_last_report && verbose >= 0){
980 int64_t raw= audio_size + video_size + extra_size;
981 fprintf(stderr, "\n");
982 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
983 video_size/1024.0,
984 audio_size/1024.0,
985 extra_size/1024.0,
986 100.0*(total_size - raw)/raw
987 );
988 }
989 }
990
991 /* pkt = NULL means EOF (needed to flush decoder buffers) */
992 static int output_packet(AVInputStream *ist, int ist_index,
993 AVOutputStream **ost_table, int nb_ostreams,
994 const AVPacket *pkt)
995 {
996 AVFormatContext *os;
997 AVOutputStream *ost;
998 uint8_t *ptr;
999 int len, ret, i;
1000 uint8_t *data_buf;
1001 int data_size, got_picture;
1002 AVFrame picture;
1003 short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
1004 void *buffer_to_free;
1005
1006 if (pkt && pkt->pts != AV_NOPTS_VALUE) {
1007 ist->next_pts = ist->pts = pkt->pts;
1008 } else {
1009 ist->pts = ist->next_pts;
1010 }
1011
1012 if (pkt == NULL) {
1013 /* EOF handling */
1014 ptr = NULL;
1015 len = 0;
1016 goto handle_eof;
1017 }
1018
1019 len = pkt->size;
1020 ptr = pkt->data;
1021 while (len > 0) {
1022 handle_eof:
1023 /* decode the packet if needed */
1024 data_buf = NULL; /* fail safe */
1025 data_size = 0;
1026 if (ist->decoding_needed) {
1027 switch(ist->st->codec.codec_type) {
1028 case CODEC_TYPE_AUDIO:
1029 /* XXX: could avoid copy if PCM 16 bits with same
1030 endianness as CPU */
1031 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1032 ptr, len);
1033 if (ret < 0)
1034 goto fail_decode;
1035 ptr += ret;
1036 len -= ret;
1037 /* Some bug in mpeg audio decoder gives */
1038 /* data_size < 0, it seems they are overflows */
1039 if (data_size <= 0) {
1040 /* no audio frame */
1041 continue;
1042 }
1043 data_buf = (uint8_t *)samples;
1044 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1045 (ist->st->codec.sample_rate * ist->st->codec.channels);
1046 break;
1047 case CODEC_TYPE_VIDEO:
1048 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1049 /* XXX: allocate picture correctly */
1050 avcodec_get_frame_defaults(&picture);
1051
1052 ret = avcodec_decode_video(&ist->st->codec,
1053 &picture, &got_picture, ptr, len);
1054 ist->st->quality= picture.quality;
1055 if (ret < 0)
1056 goto fail_decode;
1057 if (!got_picture) {
1058 /* no picture yet */
1059 goto discard_packet;
1060 }
1061 if (ist->st->codec.frame_rate_base != 0) {
1062 ist->next_pts += ((int64_t)AV_TIME_BASE *
1063 ist->st->codec.frame_rate_base) /
1064 ist->st->codec.frame_rate;
1065 }
1066 len = 0;
1067 break;
1068 default:
1069 goto fail_decode;
1070 }
1071 } else {
1072 data_buf = ptr;
1073 data_size = len;
1074 ret = len;
1075 len = 0;
1076 }
1077
1078 buffer_to_free = NULL;
1079 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1080 pre_process_video_frame(ist, (AVPicture *)&picture,
1081 &buffer_to_free);
1082 }
1083
1084 /* frame rate emulation */
1085 if (ist->st->codec.rate_emu) {
1086 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1087 int64_t now = av_gettime() - ist->start;
1088 if (pts > now)
1089 usleep(pts - now);
1090
1091 ist->frame++;
1092 }
1093
1094 #if 0
1095 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1096 is the one of the next displayed one */
1097 /* XXX: add mpeg4 too ? */
1098 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1099 if (ist->st->codec.pict_type != B_TYPE) {
1100 int64_t tmp;
1101 tmp = ist->last_ip_pts;
1102 ist->last_ip_pts = ist->frac_pts.val;
1103 ist->frac_pts.val = tmp;
1104 }
1105 }
1106 #endif
1107 /* if output time reached then transcode raw format,
1108 encode packets and output them */
1109 if (start_time == 0 || ist->pts >= start_time)
1110 for(i=0;i<nb_ostreams;i++) {
1111 int frame_size;
1112
1113 ost = ost_table[i];
1114 if (ost->source_index == ist_index) {
1115 os = output_files[ost->file_index];
1116
1117 #if 0
1118 printf("%d: got pts=%0.3f %0.3f\n", i,
1119 (double)pkt->pts / AV_TIME_BASE,
1120 ((double)ist->pts / AV_TIME_BASE) -
1121 ((double)ost->st->pts.val * ost->time_base.num / ost->time_base.den));
1122 #endif
1123 /* set the input output pts pairs */
1124 ost->sync_ipts = (double)ist->pts / AV_TIME_BASE;
1125 /* XXX: take into account the various fifos,
1126 in particular for audio */
1127 ost->sync_opts = ost->st->pts.val;
1128 //printf("ipts=%lld sync_ipts=%f sync_opts=%lld pts.val=%lld pkt->pts=%lld\n", ist->pts, ost->sync_ipts, ost->sync_opts, ost->st->pts.val, pkt->pts);
1129
1130 if (ost->encoding_needed) {
1131 switch(ost->st->codec.codec_type) {
1132 case CODEC_TYPE_AUDIO:
1133 do_audio_out(os, ost, ist, data_buf, data_size);
1134 break;
1135 case CODEC_TYPE_VIDEO:
1136 /* find an audio stream for synchro */
1137 {
1138 int i;
1139 AVOutputStream *audio_sync, *ost1;
1140 audio_sync = NULL;
1141 for(i=0;i<nb_ostreams;i++) {
1142 ost1 = ost_table[i];
1143 if (ost1->file_index == ost->file_index &&
1144 ost1->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1145 audio_sync = ost1;
1146 break;
1147 }
1148 }
1149
1150 do_video_out(os, ost, ist, &picture, &frame_size, audio_sync);
1151 video_size += frame_size;
1152 if (do_vstats && frame_size)
1153 do_video_stats(os, ost, frame_size);
1154 }
1155 break;
1156 default:
1157 av_abort();
1158 }
1159 } else {
1160 AVFrame avframe;
1161
1162 /* no reencoding needed : output the packet directly */
1163 /* force the input stream PTS */
1164
1165 avcodec_get_frame_defaults(&avframe);
1166 ost->st->codec.coded_frame= &avframe;
1167 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1168 ost->st->pts.val= av_rescale(ist->pts, ost->st->time_base.den, ost->st->time_base.num*AV_TIME_BASE);
1169
1170 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1171 audio_size += data_size;
1172 else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1173 video_size += data_size;
1174
1175 av_write_frame(os, ost->index, data_buf, data_size);
1176 ost->st->codec.frame_number++;
1177 ost->frame_number++;
1178 }
1179 }
1180 }
1181 av_free(buffer_to_free);
1182 }
1183 discard_packet:
1184 return 0;
1185 fail_decode:
1186 return -1;
1187 }
1188
1189
1190 /*
1191 * The following code is the main loop of the file converter
1192 */
1193 static int av_encode(AVFormatContext **output_files,
1194 int nb_output_files,
1195 AVFormatContext **input_files,
1196 int nb_input_files,
1197 AVStreamMap *stream_maps, int nb_stream_maps)
1198 {
1199 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1200 AVFormatContext *is, *os;
1201 AVCodecContext *codec, *icodec;
1202 AVOutputStream *ost, **ost_table = NULL;
1203 AVInputStream *ist, **ist_table = NULL;
1204 AVInputFile *file_table;
1205 AVFormatContext *stream_no_data;
1206 int key;
1207
1208 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1209 if (!file_table)
1210 goto fail;
1211
1212 /* input stream init */
1213 j = 0;
1214 for(i=0;i<nb_input_files;i++) {
1215 is = input_files[i];
1216 file_table[i].ist_index = j;
1217 file_table[i].nb_streams = is->nb_streams;
1218 j += is->nb_streams;
1219 }
1220 nb_istreams = j;
1221
1222 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1223 if (!ist_table)
1224 goto fail;
1225
1226 for(i=0;i<nb_istreams;i++) {
1227 ist = av_mallocz(sizeof(AVInputStream));
1228 if (!ist)
1229 goto fail;
1230 ist_table[i] = ist;
1231 }
1232 j = 0;
1233 for(i=0;i<nb_input_files;i++) {
1234 is = input_files[i];
1235 for(k=0;k<is->nb_streams;k++) {
1236 ist = ist_table[j++];
1237 ist->st = is->streams[k];
1238 ist->file_index = i;
1239 ist->index = k;
1240 ist->discard = 1; /* the stream is discarded by default
1241 (changed later) */
1242
1243 if (ist->st->codec.rate_emu) {
1244 ist->start = av_gettime();
1245 ist->frame = 0;
1246 }
1247 }
1248 }
1249
1250 /* output stream init */
1251 nb_ostreams = 0;
1252 for(i=0;i<nb_output_files;i++) {
1253 os = output_files[i];
1254 nb_ostreams += os->nb_streams;
1255 }
1256 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1257 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1258 exit(1);
1259 }
1260
1261 /* Sanity check the mapping args -- do the input files & streams exist? */
1262 for(i=0;i<nb_stream_maps;i++) {
1263 int fi = stream_maps[i].file_index;
1264 int si = stream_maps[i].stream_index;
1265
1266 if (fi < 0 || fi > nb_input_files - 1 ||
1267 si < 0 || si > file_table[fi].nb_streams - 1) {
1268 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1269 exit(1);
1270 }
1271 }
1272
1273 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1274 if (!ost_table)
1275 goto fail;
1276 for(i=0;i<nb_ostreams;i++) {
1277 ost = av_mallocz(sizeof(AVOutputStream));
1278 if (!ost)
1279 goto fail;
1280 ost_table[i] = ost;
1281 }
1282
1283 n = 0;
1284 for(k=0;k<nb_output_files;k++) {
1285 os = output_files[k];
1286 for(i=0;i<os->nb_streams;i++) {
1287 int found;
1288 ost = ost_table[n++];
1289 ost->file_index = k;
1290 ost->index = i;
1291 ost->st = os->streams[i];
1292 if (nb_stream_maps > 0) {
1293 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1294 stream_maps[n-1].stream_index;
1295
1296 /* Sanity check that the stream types match */
1297 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1298 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1299 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1300 ost->file_index, ost->index);
1301 exit(1);
1302 }
1303
1304 } else {
1305 /* get corresponding input stream index : we select the first one with the right type */
1306 found = 0;
1307 for(j=0;j<nb_istreams;j++) {
1308 ist = ist_table[j];
1309 if (ist->discard &&
1310 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1311 ost->source_index = j;
1312 found = 1;
1313 }
1314 }
1315
1316 if (!found) {
1317 /* try again and reuse existing stream */
1318 for(j=0;j<nb_istreams;j++) {
1319 ist = ist_table[j];
1320 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1321 ost->source_index = j;
1322 found = 1;
1323 }
1324 }
1325 if (!found) {
1326 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1327 ost->file_index, ost->index);
1328 exit(1);
1329 }
1330 }
1331 }
1332 ist = ist_table[ost->source_index];
1333 ist->discard = 0;
1334 }
1335 }
1336
1337 /* for each output stream, we compute the right encoding parameters */
1338 for(i=0;i<nb_ostreams;i++) {
1339 ost = ost_table[i];
1340 ist = ist_table[ost->source_index];
1341
1342 codec = &ost->st->codec;
1343 icodec = &ist->st->codec;
1344
1345 if (ost->st->stream_copy) {
1346 /* if stream_copy is selected, no need to decode or encode */
1347 codec->codec_id = icodec->codec_id;
1348 codec->codec_type = icodec->codec_type;
1349 codec->codec_tag = icodec->codec_tag;
1350 codec->bit_rate = icodec->bit_rate;
1351 switch(codec->codec_type) {
1352 case CODEC_TYPE_AUDIO:
1353 codec->sample_rate = icodec->sample_rate;
1354 codec->channels = icodec->channels;
1355 codec->frame_size = icodec->frame_size;
1356 break;
1357 case CODEC_TYPE_VIDEO:
1358 codec->frame_rate = icodec->frame_rate;
1359 codec->frame_rate_base = icodec->frame_rate_base;
1360 codec->width = icodec->width;
1361 codec->height = icodec->height;
1362 break;
1363 default:
1364 av_abort();
1365 }
1366 } else {
1367 switch(codec->codec_type) {
1368 case CODEC_TYPE_AUDIO:
1369 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1370 goto fail;
1371
1372 if (codec->channels == icodec->channels &&
1373 codec->sample_rate == icodec->sample_rate) {
1374 ost->audio_resample = 0;
1375 } else {
1376 if (codec->channels != icodec->channels &&
1377 icodec->codec_id == CODEC_ID_AC3) {
1378 /* Special case for 5:1 AC3 input */
1379 /* and mono or stereo output */
1380 /* Request specific number of channels */
1381 icodec->channels = codec->channels;
1382 if (codec->sample_rate == icodec->sample_rate)
1383 ost->audio_resample = 0;
1384 else {
1385 ost->audio_resample = 1;
1386 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1387 codec->sample_rate,
1388 icodec->sample_rate);
1389 if(!ost->resample)
1390 {
1391 printf("Can't resample. Aborting.\n");
1392 av_abort();
1393 }
1394 }
1395 /* Request specific number of channels */
1396 icodec->channels = codec->channels;
1397 } else {
1398 ost->audio_resample = 1;
1399 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1400 codec->sample_rate,
1401 icodec->sample_rate);
1402 if(!ost->resample)
1403 {
1404 printf("Can't resample. Aborting.\n");
1405 av_abort();
1406 }
1407 }
1408 }
1409 ist->decoding_needed = 1;
1410 ost->encoding_needed = 1;
1411 break;
1412 case CODEC_TYPE_VIDEO:
1413 if (codec->width == icodec->width &&
1414 codec->height == icodec->height &&
1415 frame_topBand == 0 &&
1416 frame_bottomBand == 0 &&
1417 frame_leftBand == 0 &&
1418 frame_rightBand == 0 &&
1419 frame_padtop == 0 &&
1420 frame_padbottom == 0 &&
1421 frame_padleft == 0 &&
1422 frame_padright == 0)
1423 {
1424 ost->video_resample = 0;
1425 ost->video_crop = 0;
1426 ost->video_pad = 0;
1427 } else if ((codec->width == icodec->width -
1428 (frame_leftBand + frame_rightBand)) &&
1429 (codec->height == icodec->height -
1430 (frame_topBand + frame_bottomBand)))
1431 {
1432 ost->video_resample = 0;
1433 ost->video_crop = 1;
1434 ost->topBand = frame_topBand;
1435 ost->leftBand = frame_leftBand;
1436 } else if ((codec->width == icodec->width +
1437 (frame_padleft + frame_padright)) &&
1438 (codec->height == icodec->height +
1439 (frame_padtop + frame_padbottom))) {
1440 ost->video_resample = 0;
1441 ost->video_crop = 0;
1442 ost->video_pad = 1;
1443 ost->padtop = frame_padtop;
1444 ost->padleft = frame_padleft;
1445 ost->padbottom = frame_padbottom;
1446 ost->padright = frame_padright;
1447 avcodec_get_frame_defaults(&ost->pict_tmp);
1448 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1449 codec->width, codec->height ) )
1450 goto fail;
1451 } else {
1452 ost->video_resample = 1;
1453 ost->video_crop = 0; // cropping is handled as part of resample
1454 avcodec_get_frame_defaults(&ost->pict_tmp);
1455 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1456 codec->width, codec->height ) )
1457 goto fail;
1458
1459 ost->img_resample_ctx = img_resample_full_init(
1460 ost->st->codec.width, ost->st->codec.height,
1461 ist->st->codec.width, ist->st->codec.height,
1462 frame_topBand, frame_bottomBand,
1463 frame_leftBand, frame_rightBand,
1464 frame_padtop, frame_padbottom,
1465 frame_padleft, frame_padright);
1466
1467 ost->padtop = frame_padtop;
1468 ost->padleft = frame_padleft;
1469 ost->padbottom = frame_padbottom;
1470 ost->padright = frame_padright;
1471
1472 }
1473 ost->encoding_needed = 1;
1474 ist->decoding_needed = 1;
1475 break;
1476 default:
1477 av_abort();
1478 }
1479 /* two pass mode */
1480 if (ost->encoding_needed &&
1481 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1482 char logfilename[1024];
1483 FILE *f;
1484 int size;
1485 char *logbuffer;
1486
1487 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1488 pass_logfilename ?
1489 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1490 if (codec->flags & CODEC_FLAG_PASS1) {
1491 f = fopen(logfilename, "w");
1492 if (!f) {
1493 perror(logfilename);
1494 exit(1);
1495 }
1496 ost->logfile = f;
1497 } else {
1498 /* read the log file */
1499 f = fopen(logfilename, "r");
1500 if (!f) {
1501 perror(logfilename);
1502 exit(1);
1503 }
1504 fseek(f, 0, SEEK_END);
1505 size = ftell(f);
1506 fseek(f, 0, SEEK_SET);
1507 logbuffer = av_malloc(size + 1);
1508 if (!logbuffer) {
1509 fprintf(stderr, "Could not allocate log buffer\n");
1510 exit(1);
1511 }
1512 size = fread(logbuffer, 1, size, f);
1513 fclose(f);
1514 logbuffer[size] = '\0';
1515 codec->stats_in = logbuffer;
1516 }
1517 }
1518 }
1519 }
1520
1521 /* dump the file output parameters - cannot be done before in case
1522 of stream copy */
1523 for(i=0;i<nb_output_files;i++) {
1524 dump_format(output_files[i], i, output_files[i]->filename, 1);
1525 }
1526
1527 /* dump the stream mapping */
1528 if (verbose >= 0) {
1529 fprintf(stderr, "Stream mapping:\n");
1530 for(i=0;i<nb_ostreams;i++) {
1531 ost = ost_table[i];
1532 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1533 ist_table[ost->source_index]->file_index,
1534 ist_table[ost->source_index]->index,
1535 ost->file_index,
1536 ost->index);
1537 }
1538 }
1539
1540 /* open each encoder */
1541 for(i=0;i<nb_ostreams;i++) {
1542 ost = ost_table[i];
1543 if (ost->encoding_needed) {
1544 AVCodec *codec;
1545 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1546 if (!codec) {
1547 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1548 ost->file_index, ost->index);
1549 exit(1);
1550 }
1551 if (avcodec_open(&ost->st->codec, codec) < 0) {
1552 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1553 ost->file_index, ost->index);
1554 exit(1);
1555 }
1556 extra_size += ost->st->codec.extradata_size;
1557 }
1558 }
1559
1560 /* open each decoder */
1561 for(i=0;i<nb_istreams;i++) {
1562 ist = ist_table[i];
1563 if (ist->decoding_needed) {
1564 AVCodec *codec;
1565 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1566 if (!codec) {
1567 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1568 ist->st->codec.codec_id, ist->file_index, ist->index);
1569 exit(1);
1570 }
1571 if (avcodec_open(&ist->st->codec, codec) < 0) {
1572 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1573 ist->file_index, ist->index);
1574 exit(1);
1575 }
1576 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1577 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1578 }
1579 }
1580
1581 /* init pts */
1582 for(i=0;i<nb_istreams;i++) {
1583 ist = ist_table[i];
1584 is = input_files[ist->file_index];
1585 ist->pts = 0;
1586 ist->next_pts = 0;
1587 }
1588
1589 /* compute buffer size max (should use a complete heuristic) */
1590 for(i=0;i<nb_input_files;i++) {
1591 file_table[i].buffer_size_max = 2048;
1592 }
1593
1594 /* open files and write file headers */
1595 for(i=0;i<nb_output_files;i++) {
1596 os = output_files[i];
1597 if (av_write_header(os) < 0) {
1598 fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
1599 ret = -EINVAL;
1600 goto fail;
1601 }
1602 }
1603
1604 #ifndef CONFIG_WIN32
1605 if ( !using_stdin && verbose >= 0) {
1606 fprintf(stderr, "Press [q] to stop encoding\n");
1607 url_set_interrupt_cb(decode_interrupt_cb);
1608 }
1609 #endif
1610 term_init();
1611
1612 stream_no_data = 0;
1613 key = -1;
1614
1615 for(; received_sigterm == 0;) {
1616 int file_index, ist_index;
1617 AVPacket pkt;
1618 double pts_min;
1619
1620 redo:
1621 /* if 'q' pressed, exits */
1622 if (!using_stdin) {
1623 if (q_pressed)
1624 break;
1625 /* read_key() returns 0 on EOF */
1626 key = read_key();
1627 if (key == 'q')
1628 break;
1629 }
1630
1631 /* select the stream that we must read now by looking at the
1632 smallest output pts */
1633 file_index = -1;
1634 pts_min = 1e10;
1635 for(i=0;i<nb_ostreams;i++) {
1636 double pts;
1637 ost = ost_table[i];
1638 os = output_files[ost->file_index];
1639 ist = ist_table[ost->source_index];
1640 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1641 if (!file_table[ist->file_index].eof_reached &&
1642 pts < pts_min) {
1643 pts_min = pts;
1644 file_index = ist->file_index;
1645 }
1646 }
1647 /* if none, if is finished */
1648 if (file_index < 0) {
1649 break;
1650 }
1651
1652 /* finish if recording time exhausted */
1653 if (recording_time > 0 && pts_min >= (recording_time / 1000000.0))
1654 break;
1655
1656 /* read a frame from it and output it in the fifo */
1657 is = input_files[file_index];
1658 if (av_read_frame(is, &pkt) < 0) {
1659 file_table[file_index].eof_reached = 1;
1660 continue;
1661 }
1662
1663 if (!pkt.size) {
1664 stream_no_data = is;
1665 } else {
1666 stream_no_data = 0;
1667 }
1668 if (do_pkt_dump) {
1669 av_pkt_dump(stdout, &pkt, do_hex_dump);
1670 }
1671 /* the following test is needed in case new streams appear
1672 dynamically in stream : we ignore them */
1673 if (pkt.stream_index >= file_table[file_index].nb_streams)
1674 goto discard_packet;
1675 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1676 ist = ist_table[ist_index];
1677 if (ist->discard)
1678 goto discard_packet;
1679
1680 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1681 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1682
1683 if (verbose >= 0)
1684 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1685 ist->file_index, ist->index);
1686
1687 av_free_packet(&pkt);
1688 goto redo;
1689 }
1690
1691 discard_packet:
1692 av_free_packet(&pkt);
1693
1694 /* dump report by using the output first video and audio streams */
1695 print_report(output_files, ost_table, nb_ostreams, 0);
1696 }
1697
1698 /* at the end of stream, we must flush the decoder buffers */
1699 for(i=0;i<nb_istreams;i++) {
1700 ist = ist_table[i];
1701 if (ist->decoding_needed) {
1702 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1703 }
1704 }
1705
1706 term_exit();
1707
1708 /* write the trailer if needed and close file */
1709 for(i=0;i<nb_output_files;i++) {
1710 os = output_files[i];
1711 av_write_trailer(os);
1712 }
1713
1714 /* dump report by using the first video and audio streams */
1715 print_report(output_files, ost_table, nb_ostreams, 1);
1716
1717 /* close each encoder */
1718 for(i=0;i<nb_ostreams;i++) {
1719 ost = ost_table[i];
1720 if (ost->encoding_needed) {
1721 av_freep(&ost->st->codec.stats_in);
1722 avcodec_close(&ost->st->codec);
1723 }
1724 }
1725
1726 /* close each decoder */
1727 for(i=0;i<nb_istreams;i++) {
1728 ist = ist_table[i];
1729 if (ist->decoding_needed) {
1730 avcodec_close(&ist->st->codec);
1731 }
1732 }
1733
1734 /* finished ! */
1735
1736 ret = 0;
1737 fail1:
1738 av_free(file_table);
1739
1740 if (ist_table) {
1741 for(i=0;i<nb_istreams;i++) {
1742 ist = ist_table[i];
1743 av_free(ist);
1744 }
1745 av_free(ist_table);
1746 }
1747 if (ost_table) {
1748 for(i=0;i<nb_ostreams;i++) {
1749 ost = ost_table[i];
1750 if (ost) {
1751 if (ost->logfile) {
1752 fclose(ost->logfile);
1753 ost->logfile = NULL;
1754 }
1755 fifo_free(&ost->fifo); /* works even if fifo is not
1756 initialized but set to zero */
1757 av_free(ost->pict_tmp.data[0]);
1758 if (ost->video_resample)
1759 img_resample_close(ost->img_resample_ctx);
1760 if (ost->audio_resample)
1761 audio_resample_close(ost->resample);
1762 av_free(ost);
1763 }
1764 }
1765 av_free(ost_table);
1766 }
1767 return ret;
1768 fail:
1769 ret = -ENOMEM;
1770 goto fail1;
1771 }
1772
1773 #if 0
1774 int file_read(const char *filename)
1775 {
1776 URLContext *h;
1777 unsigned char buffer[1024];
1778 int len, i;
1779
1780 if (url_open(&h, filename, O_RDONLY) < 0) {
1781 printf("could not open '%s'\n", filename);
1782 return -1;
1783 }
1784 for(;;) {
1785 len = url_read(h, buffer, sizeof(buffer));
1786 if (len <= 0)
1787 break;
1788 for(i=0;i<len;i++) putchar(buffer[i]);
1789 }
1790 url_close(h);
1791 return 0;
1792 }
1793 #endif
1794
1795 static void opt_image_format(const char *arg)
1796 {
1797 AVImageFormat *f;
1798
1799 for(f = first_image_format; f != NULL; f = f->next) {
1800 if (!strcmp(arg, f->name))
1801 break;
1802 }
1803 if (!f) {
1804 fprintf(stderr, "Unknown image format: '%s'\n", arg);
1805 exit(1);
1806 }
1807 image_format = f;
1808 }
1809
1810 static void opt_format(const char *arg)
1811 {
1812 /* compatibility stuff for pgmyuv */
1813 if (!strcmp(arg, "pgmyuv")) {
1814 opt_image_format(arg);
1815 arg = "image";
1816 }
1817
1818 file_iformat = av_find_input_format(arg);
1819 file_oformat = guess_format(arg, NULL, NULL);
1820 if (!file_iformat && !file_oformat) {
1821 fprintf(stderr, "Unknown input or output format: %s\n", arg);
1822 exit(1);
1823 }
1824 }
1825
1826 static void opt_video_bitrate(const char *arg)
1827 {
1828 video_bit_rate = atoi(arg) * 1000;
1829 }
1830
1831 static void opt_video_bitrate_tolerance(const char *arg)
1832 {
1833 video_bit_rate_tolerance = atoi(arg) * 1000;
1834 }
1835
1836 static void opt_video_bitrate_max(const char *arg)
1837 {
1838 video_rc_max_rate = atoi(arg) * 1000;
1839 }
1840
1841 static void opt_video_bitrate_min(const char *arg)
1842 {
1843 video_rc_min_rate = atoi(arg) * 1000;
1844 }
1845
1846 static void opt_video_buffer_size(const char *arg)
1847 {
1848 video_rc_buffer_size = atoi(arg) * 8*1024;
1849 }
1850
1851 static void opt_video_rc_eq(char *arg)
1852 {
1853 video_rc_eq = arg;
1854 }
1855
1856 static void opt_video_rc_override_string(char *arg)
1857 {
1858 video_rc_override_string = arg;
1859 }
1860
1861
1862 static void opt_workaround_bugs(const char *arg)
1863 {
1864 workaround_bugs = atoi(arg);
1865 }
1866
1867 static void opt_dct_algo(const char *arg)
1868 {
1869 dct_algo = atoi(arg);
1870 }
1871
1872 static void opt_idct_algo(const char *arg)
1873 {
1874 idct_algo = atoi(arg);
1875 }
1876
1877 static void opt_me_threshold(const char *arg)
1878 {
1879 me_threshold = atoi(arg);
1880 }
1881
1882 static void opt_mb_threshold(const char *arg)
1883 {
1884 mb_threshold = atoi(arg);
1885 }
1886
1887 static void opt_error_resilience(const char *arg)
1888 {
1889 error_resilience = atoi(arg);
1890 }
1891
1892 static void opt_error_concealment(const char *arg)
1893 {
1894 error_concealment = atoi(arg);
1895 }
1896
1897 static void opt_debug(const char *arg)
1898 {
1899 debug = atoi(arg);
1900 }
1901
1902 static void opt_vismv(const char *arg)
1903 {
1904 debug_mv = atoi(arg);
1905 }
1906
1907 static void opt_verbose(const char *arg)
1908 {
1909 verbose = atoi(arg);
1910 av_log_set_level(atoi(arg));
1911 }
1912
1913 static void opt_sync_method(const char *arg)
1914 {
1915 sync_method = atoi(arg);
1916 }
1917
1918 static void opt_frame_rate(const char *arg)
1919 {
1920 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
1921 fprintf(stderr, "Incorrect frame rate\n");
1922 exit(1);
1923 }
1924 }
1925
1926 static void opt_frame_crop_top(const char *arg)
1927 {
1928 frame_topBand = atoi(arg);
1929 if (frame_topBand < 0) {
1930 fprintf(stderr, "Incorrect top crop size\n");
1931 exit(1);
1932 }
1933 if ((frame_topBand % 2) != 0) {
1934 fprintf(stderr, "Top crop size must be a multiple of 2\n");
1935 exit(1);
1936 }
1937 if ((frame_topBand) >= frame_height){
1938 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1939 exit(1);
1940 }
1941 frame_height -= frame_topBand;
1942 }
1943
1944 static void opt_frame_crop_bottom(const char *arg)
1945 {
1946 frame_bottomBand = atoi(arg);
1947 if (frame_bottomBand < 0) {
1948 fprintf(stderr, "Incorrect bottom crop size\n");
1949 exit(1);
1950 }
1951 if ((frame_bottomBand % 2) != 0) {
1952 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
1953 exit(1);
1954 }
1955 if ((frame_bottomBand) >= frame_height){
1956 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1957 exit(1);
1958 }
1959 frame_height -= frame_bottomBand;
1960 }
1961
1962 static void opt_frame_crop_left(const char *arg)
1963 {
1964 frame_leftBand = atoi(arg);
1965 if (frame_leftBand < 0) {
1966 fprintf(stderr, "Incorrect left crop size\n");
1967 exit(1);
1968 }
1969 if ((frame_leftBand % 2) != 0) {
1970 fprintf(stderr, "Left crop size must be a multiple of 2\n");
1971 exit(1);
1972 }
1973 if ((frame_leftBand) >= frame_width){
1974 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1975 exit(1);
1976 }
1977 frame_width -= frame_leftBand;
1978 }
1979
1980 static void opt_frame_crop_right(const char *arg)
1981 {
1982 frame_rightBand = atoi(arg);
1983 if (frame_rightBand < 0) {
1984 fprintf(stderr, "Incorrect right crop size\n");
1985 exit(1);
1986 }
1987 if ((frame_rightBand % 2) != 0) {
1988 fprintf(stderr, "Right crop size must be a multiple of 2\n");
1989 exit(1);
1990 }
1991 if ((frame_rightBand) >= frame_width){
1992 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1993 exit(1);
1994 }
1995 frame_width -= frame_rightBand;
1996 }
1997
1998 static void opt_frame_size(const char *arg)
1999 {
2000 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2001 fprintf(stderr, "Incorrect frame size\n");
2002 exit(1);
2003 }
2004 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2005 fprintf(stderr, "Frame size must be a multiple of 2\n");
2006 exit(1);
2007 }
2008 }
2009
2010
2011 #define SCALEBITS 10
2012 #define ONE_HALF (1 << (SCALEBITS - 1))
2013 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2014
2015 #define RGB_TO_Y(r, g, b) \
2016 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2017 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2018
2019 #define RGB_TO_U(r1, g1, b1, shift)\
2020 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2021 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2022
2023 #define RGB_TO_V(r1, g1, b1, shift)\
2024 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2025 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2026
2027 static void opt_pad_color(const char *arg) {
2028 /* Input is expected to be six hex digits similar to
2029 how colors are expressed in html tags (but without the #) */
2030 int rgb = strtol(arg, NULL, 16);
2031 int r,g,b;
2032
2033 r = (rgb >> 16);
2034 g = ((rgb >> 8) & 255);
2035 b = (rgb & 255);
2036
2037 padcolor[0] = RGB_TO_Y(r,g,b);
2038 padcolor[1] = RGB_TO_U(r,g,b,0);
2039 padcolor[2] = RGB_TO_V(r,g,b,0);
2040 }
2041
2042 static void opt_frame_pad_top(const char *arg)
2043 {
2044 frame_padtop = atoi(arg);
2045 if (frame_padtop < 0) {
2046 fprintf(stderr, "Incorrect top pad size\n");
2047 exit(1);
2048 }
2049 if ((frame_padtop % 2) != 0) {
2050 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2051 exit(1);
2052 }
2053 }
2054
2055 static void opt_frame_pad_bottom(const char *arg)
2056 {
2057 frame_padbottom = atoi(arg);
2058 if (frame_padbottom < 0) {
2059 fprintf(stderr, "Incorrect bottom pad size\n");
2060 exit(1);
2061 }
2062 if ((frame_padbottom % 2) != 0) {
2063 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2064 exit(1);
2065 }
2066 }
2067
2068
2069 static void opt_frame_pad_left(const char *arg)
2070 {
2071 frame_padleft = atoi(arg);
2072 if (frame_padleft < 0) {
2073 fprintf(stderr, "Incorrect left pad size\n");
2074 exit(1);
2075 }
2076 if ((frame_padleft % 2) != 0) {
2077 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2078 exit(1);
2079 }
2080 }
2081
2082
2083 static void opt_frame_pad_right(const char *arg)
2084 {
2085 frame_padright = atoi(arg);
2086 if (frame_padright < 0) {
2087 fprintf(stderr, "Incorrect right pad size\n");
2088 exit(1);
2089 }
2090 if ((frame_padright % 2) != 0) {
2091 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2092 exit(1);
2093 }
2094 }
2095
2096
2097 static void opt_frame_pix_fmt(const char *arg)
2098 {
2099 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2100 }
2101
2102 static void opt_frame_aspect_ratio(const char *arg)
2103 {
2104 int x = 0, y = 0;
2105 double ar = 0;
2106 const char *p;
2107
2108 p = strchr(arg, ':');
2109 if (p) {
2110 x = strtol(arg, (char **)&arg, 10);
2111 if (arg == p)
2112 y = strtol(arg+1, (char **)&arg, 10);
2113 if (x > 0 && y > 0)
2114 ar = (double)x / (double)y;
2115 } else
2116 ar = strtod(arg, (char **)&arg);
2117
2118 if (!ar) {
2119 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2120 exit(1);
2121 }
2122 frame_aspect_ratio = ar;
2123 }
2124
2125 static void opt_gop_size(const char *arg)
2126 {
2127 gop_size = atoi(arg);
2128 }
2129
2130 static void opt_b_frames(const char *arg)
2131 {
2132 b_frames = atoi(arg);
2133 if (b_frames > FF_MAX_B_FRAMES) {
2134 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2135 exit(1);
2136 } else if (b_frames < 1) {
2137 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2138 exit(1);
2139 }
2140 }
2141
2142 static void opt_mb_decision(const char *arg)
2143 {
2144 mb_decision = atoi(arg);
2145 }
2146
2147 static void opt_mb_cmp(const char *arg)
2148 {
2149 mb_cmp = atoi(arg);
2150 }
2151
2152 static void opt_ildct_cmp(const char *arg)
2153 {
2154 ildct_cmp = atoi(arg);
2155 }
2156
2157 static void opt_sub_cmp(const char *arg)
2158 {
2159 sub_cmp = atoi(arg);
2160 }
2161
2162 static void opt_cmp(const char *arg)
2163 {
2164 cmp = atoi(arg);
2165 }
2166
2167 static void opt_pre_cmp(const char *arg)
2168 {
2169 pre_cmp = atoi(arg);
2170 }
2171
2172 static void opt_pre_me(const char *arg)
2173 {
2174 pre_me = atoi(arg);
2175 }
2176
2177 static void opt_lumi_mask(const char *arg)
2178 {
2179 lumi_mask = atof(arg);
2180 }
2181
2182 static void opt_dark_mask(const char *arg)
2183 {
2184 dark_mask = atof(arg);
2185 }
2186
2187 static void opt_scplx_mask(const char *arg)
2188 {
2189 scplx_mask = atof(arg);
2190 }
2191
2192 static void opt_tcplx_mask(const char *arg)
2193 {
2194 tcplx_mask = atof(arg);
2195 }
2196
2197 static void opt_p_mask(const char *arg)
2198 {
2199 p_mask = atof(arg);
2200 }
2201
2202 static void opt_qscale(const char *arg)
2203 {
2204 video_qscale = atof(arg);
2205 if (video_qscale < 0.01 ||
2206 video_qscale > 255) {
2207 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2208 exit(1);
2209 }
2210 }
2211
2212 static void opt_lmax(const char *arg)
2213 {
2214 video_lmax = atof(arg)*FF_QP2LAMBDA;
2215 }
2216
2217 static void opt_lmin(const char *arg)
2218 {
2219 video_lmin = atof(arg)*FF_QP2LAMBDA;
2220 }
2221
2222 static void opt_qmin(const char *arg)
2223 {
2224 video_qmin = atoi(arg);
2225 if (video_qmin < 0 ||
2226 video_qmin > 31) {
2227 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2228 exit(1);
2229 }
2230 }
2231
2232 static void opt_qmax(const char *arg)
2233 {
2234 video_qmax = atoi(arg);
2235 if (video_qmax < 0 ||
2236 video_qmax > 31) {
2237 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2238 exit(1);
2239 }
2240 }
2241
2242 static void opt_mb_qmin(const char *arg)
2243 {
2244 video_mb_qmin = atoi(arg);
2245 if (video_mb_qmin < 0 ||
2246 video_mb_qmin > 31) {
2247 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2248 exit(1);
2249 }
2250 }
2251
2252 static void opt_mb_qmax(const char *arg)
2253 {
2254 video_mb_qmax = atoi(arg);
2255 if (video_mb_qmax < 0 ||
2256 video_mb_qmax > 31) {
2257 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2258 exit(1);
2259 }
2260 }
2261
2262 static void opt_qdiff(const char *arg)
2263 {
2264 video_qdiff = atoi(arg);
2265 if (video_qdiff < 0 ||
2266 video_qdiff > 31) {
2267 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2268 exit(1);
2269 }
2270 }
2271
2272 static void opt_qblur(const char *arg)
2273 {
2274 video_qblur = atof(arg);
2275 }
2276
2277 static void opt_qcomp(const char *arg)
2278 {
2279 video_qcomp = atof(arg);
2280 }
2281
2282 static void opt_rc_initial_cplx(const char *arg)
2283 {
2284 video_rc_initial_cplx = atof(arg);
2285 }
2286 static void opt_b_qfactor(const char *arg)
2287 {
2288 video_b_qfactor = atof(arg);
2289 }
2290 static void opt_i_qfactor(const char *arg)
2291 {
2292 video_i_qfactor = atof(arg);
2293 }
2294 static void opt_b_qoffset(const char *arg)
2295 {
2296 video_b_qoffset = atof(arg);
2297 }
2298 static void opt_i_qoffset(const char *arg)
2299 {
2300 video_i_qoffset = atof(arg);
2301 }
2302
2303 static void opt_ibias(const char *arg)
2304 {
2305 video_intra_quant_bias = atoi(arg);
2306 }
2307 static void opt_pbias(const char *arg)
2308 {
2309 video_inter_quant_bias = atoi(arg);
2310 }
2311
2312 static void opt_packet_size(const char *arg)
2313 {
2314 packet_size= atoi(arg);
2315 }
2316
2317 static void opt_error_rate(const char *arg)
2318 {
2319 error_rate= atoi(arg);
2320 }
2321
2322 static void opt_strict(const char *arg)
2323 {
2324 strict= atoi(arg);
2325 }
2326
2327 static void opt_top_field_first(const char *arg)
2328 {
2329 top_field_first= atoi(arg);
2330 }
2331
2332 static void opt_noise_reduction(const char *arg)
2333 {
2334 noise_reduction= atoi(arg);
2335 }
2336
2337 static void opt_qns(const char *arg)
2338 {
2339 qns= atoi(arg);
2340 }
2341
2342 static void opt_sc_threshold(const char *arg)
2343 {
2344 sc_threshold= atoi(arg);
2345 }
2346
2347 static void opt_me_range(const char *arg)
2348 {
2349 me_range = atoi(arg);
2350 }
2351
2352 static void opt_thread_count(const char *arg)
2353 {
2354 thread_count= atoi(arg);
2355 #if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2356 if (verbose >= 0)
2357 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2358 #endif
2359 }
2360
2361 static void opt_audio_bitrate(const char *arg)
2362 {
2363 audio_bit_rate = atoi(arg) * 1000;
2364 }
2365
2366 static void opt_audio_rate(const char *arg)
2367 {
2368 audio_sample_rate = atoi(arg);
2369 }
2370
2371 static void opt_audio_channels(const char *arg)
2372 {
2373 audio_channels = atoi(arg);
2374 }
2375
2376 static void opt_video_device(const char *arg)
2377 {
2378 video_device = av_strdup(arg);
2379 }
2380
2381 static void opt_video_channel(const char *arg)
2382 {
2383 video_channel = strtol(arg, NULL, 0);
2384 }
2385
2386 static void opt_video_standard(const char *arg)
2387 {
2388 video_standard = av_strdup(arg);
2389 }
2390
2391 static void opt_audio_device(const char *arg)
2392 {
2393 audio_device = av_strdup(arg);
2394 }
2395
2396 static void opt_dv1394(const char *arg)
2397 {
2398 video_grab_format = "dv1394";
2399 audio_grab_format = NULL;
2400 }
2401
2402 static void opt_audio_codec(const char *arg)
2403 {
2404 AVCodec *p;
2405
2406 if (!strcmp(arg, "copy")) {
2407 audio_stream_copy = 1;
2408 } else {
2409 p = first_avcodec;
2410 while (p) {
2411 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2412 break;
2413 p = p->next;
2414 }
2415 if (p == NULL) {
2416 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2417 exit(1);
2418 } else {
2419 audio_codec_id = p->id;
2420 }
2421 }
2422 }
2423
2424 static void add_frame_hooker(const char *arg)
2425 {
2426 int argc = 0;
2427 char *argv[64];
2428 int i;
2429 char *args = av_strdup(arg);
2430
2431 using_vhook = 1;
2432
2433 argv[0] = strtok(args, " ");
2434 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2435 }
2436
2437 i = frame_hook_add(argc, argv);
2438
2439 if (i != 0) {
2440 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2441 exit(1);
2442 }
2443 }
2444
2445 const char *motion_str[] = {
2446 "zero",
2447 "full",
2448 "log",
2449 "phods",
2450 "epzs",
2451 "x1",
2452 NULL,
2453 };
2454
2455 static void opt_motion_estimation(const char *arg)
2456 {
2457 const char **p;
2458 p = motion_str;
2459 for(;;) {
2460 if (!*p) {
2461 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2462 exit(1);
2463 }
2464 if (!strcmp(*p, arg))
2465 break;
2466 p++;
2467 }
2468 me_method = (p - motion_str) + 1;
2469 }
2470
2471 static void opt_video_codec(const char *arg)
2472 {
2473 AVCodec *p;
2474
2475 if (!strcmp(arg, "copy")) {
2476 video_stream_copy = 1;
2477 } else {
2478 p = first_avcodec;
2479 while (p) {
2480 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2481 break;
2482 p = p->next;
2483 }
2484 if (p == NULL) {
2485 fprintf(stderr, "Unknown video codec '%s'\n", arg);
2486 exit(1);
2487 } else {
2488 video_codec_id = p->id;
2489 }
2490 }
2491 }
2492
2493 static void opt_map(const char *arg)
2494 {
2495 AVStreamMap *m;
2496 const char *p;
2497
2498 p = arg;
2499 m = &stream_maps[nb_stream_maps++];
2500
2501 m->file_index = strtol(arg, (char **)&p, 0);
2502 if (*p)
2503 p++;
2504
2505 m->stream_index = strtol(p, (char **)&p, 0);
2506 }
2507
2508 static void opt_recording_time(const char *arg)
2509 {
2510 recording_time = parse_date(arg, 1);
2511 }
2512
2513 static void opt_start_time(const char *arg)
2514 {
2515 start_time = parse_date(arg, 1);
2516 }
2517
2518 static void opt_rec_timestamp(const char *arg)
2519 {
2520 rec_timestamp = parse_date(arg, 0) / 1000000;
2521 }
2522
2523 static void opt_input_file(const char *filename)
2524 {
2525 AVFormatContext *ic;
2526 AVFormatParameters params, *ap = &params;
2527 int err, i, ret, rfps, rfps_base;
2528
2529 if (!strcmp(filename, "-"))
2530 filename = "pipe:";
2531
2532 using_stdin |= !strcmp(filename, "pipe:" ) ||
2533 !strcmp( filename, "/dev/stdin" );
2534
2535 /* get default parameters from command line */
2536 memset(ap, 0, sizeof(*ap));
2537 ap->sample_rate = audio_sample_rate;
2538 ap->channels = audio_channels;
2539 ap->frame_rate = frame_rate;
2540 ap->frame_rate_base = frame_rate_base;
2541 ap->width = frame_width + frame_padleft + frame_padright;
2542 ap->height = frame_height + frame_padtop + frame_padbottom;
2543 ap->image_format = image_format;
2544 ap->pix_fmt = frame_pix_fmt;
2545
2546 /* open the input file with generic libav function */
2547 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2548 if (err < 0) {
2549 print_error(filename, err);
2550 exit(1);
2551 }
2552
2553 /* If not enough info to get the stream parameters, we decode the
2554 first frames to get it. (used in mpeg case for example) */
2555 ret = av_find_stream_info(ic);
2556 if (ret < 0 && verbose >= 0) {
2557 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2558 exit(1);
2559 }
2560
2561 /* if seeking requested, we execute it */
2562 if (start_time != 0) {
2563 int64_t timestamp;
2564
2565 timestamp = start_time;
2566 /* add the stream start time */
2567 if (ic->start_time != AV_NOPTS_VALUE)
2568 timestamp += ic->start_time;
2569 ret = av_seek_frame(ic, -1, timestamp);
2570 if (ret < 0) {
2571 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2572 filename, (double)timestamp / AV_TIME_BASE);
2573 }
2574 /* reset seek info */
2575 start_time = 0;
2576 }
2577
2578 /* update the current parameters so that they match the one of the input stream */
2579 for(i=0;i<ic->nb_streams;i++) {
2580 AVCodecContext *enc = &ic->streams[i]->codec;
2581 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2582 if(thread_count>1)
2583 avcodec_thread_init(enc, thread_count);
2584 #endif
2585 enc->thread_count= thread_count;
2586 switch(enc->codec_type) {
2587 case CODEC_TYPE_AUDIO:
2588 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2589 audio_channels = enc->channels;
2590 audio_sample_rate = enc->sample_rate;
2591 break;
2592 case CODEC_TYPE_VIDEO:
2593 frame_height = enc->height;
2594 frame_width = enc->width;
2595 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2596 frame_pix_fmt = enc->pix_fmt;
2597 rfps = ic->streams[i]->r_frame_rate;
2598 rfps_base = ic->streams[i]->r_frame_rate_base;
2599 enc->workaround_bugs = workaround_bugs;
2600 enc->error_resilience = error_resilience;
2601 enc->error_concealment = error_concealment;
2602 enc->idct_algo = idct_algo;
2603 enc->debug = debug;
2604 enc->debug_mv = debug_mv;
2605 if(bitexact)
2606 enc->flags|= CODEC_FLAG_BITEXACT;
2607 if(me_threshold)
2608 enc->debug |= FF_DEBUG_MV;
2609
2610 assert(enc->frame_rate_base == rfps_base); // should be true for now
2611 if (enc->frame_rate != rfps) {
2612
2613 if (verbose >= 0)
2614 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2615 i, (float)enc->frame_rate / enc->frame_rate_base,
2616
2617 (float)rfps / rfps_base);
2618 }
2619 /* update the current frame rate to match the stream frame rate */
2620 frame_rate = rfps;
2621 frame_rate_base = rfps_base;
2622
2623 enc->rate_emu = rate_emu;
2624 break;
2625 case CODEC_TYPE_DATA:
2626 break;
2627 default:
2628 av_abort();
2629 }
2630 }
2631
2632 input_files[nb_input_files] = ic;
2633 /* dump the file content */
2634 if (verbose >= 0)
2635 dump_format(ic, nb_input_files, filename, 0);
2636
2637 nb_input_files++;
2638 file_iformat = NULL;
2639 file_oformat = NULL;
2640 image_format = NULL;
2641
2642 rate_emu = 0;
2643 }
2644
2645 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2646 {
2647 int has_video, has_audio, i, j;
2648 AVFormatContext *ic;
2649
2650 has_video = 0;
2651 has_audio = 0;
2652 for(j=0;j<nb_input_files;j++) {
2653 ic = input_files[j];
2654 for(i=0;i<ic->nb_streams;i++) {
2655 AVCodecContext *enc = &ic->streams[i]->codec;
2656 switch(enc->codec_type) {
2657 case CODEC_TYPE_AUDIO:
2658 has_audio = 1;
2659 break;
2660 case CODEC_TYPE_VIDEO:
2661 has_video = 1;
2662 break;
2663 case CODEC_TYPE_DATA:
2664 break;
2665 default:
2666 av_abort();
2667 }
2668 }
2669 }
2670 *has_video_ptr = has_video;
2671 *has_audio_ptr = has_audio;
2672 }
2673
2674 static void opt_output_file(const char *filename)
2675 {
2676 AVStream *st;
2677 AVFormatContext *oc;
2678 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2679 int codec_id;
2680 AVFormatParameters params, *ap = &params;
2681
2682 if (!strcmp(filename, "-"))
2683 filename = "pipe:";
2684
2685 oc = av_alloc_format_context();
2686
2687 if (!file_oformat) {
2688 file_oformat = guess_format(NULL, filename, NULL);
2689 if (!file_oformat) {
2690 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2691 filename);
2692 exit(1);
2693 }
2694 }
2695
2696 oc->oformat = file_oformat;
2697
2698 if (!strcmp(file_oformat->name, "ffm") &&
2699 strstart(filename, "http:", NULL)) {
2700 /* special case for files sent to ffserver: we get the stream
2701 parameters from ffserver */
2702 if (read_ffserver_streams(oc, filename) < 0) {
2703 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2704 exit(1);
2705 }
2706 } else {
2707 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2708 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2709
2710 /* disable if no corresponding type found and at least one
2711 input file */
2712 if (nb_input_files > 0) {
2713 check_audio_video_inputs(&input_has_video, &input_has_audio);
2714 if (!input_has_video)
2715 use_video = 0;
2716 if (!input_has_audio)
2717 use_audio = 0;
2718 }
2719
2720 /* manual disable */
2721 if (audio_disable) {
2722 use_audio = 0;
2723 }
2724 if (video_disable) {
2725 use_video = 0;
2726 }
2727
2728 nb_streams = 0;
2729 if (use_video) {
2730 AVCodecContext *video_enc;
2731
2732 st = av_new_stream(oc, nb_streams++);
2733 if (!st) {
2734 fprintf(stderr, "Could not alloc stream\n");
2735 exit(1);
2736 }
2737 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2738 if(thread_count>1)
2739 avcodec_thread_init(&st->codec, thread_count);
2740 #endif
2741
2742 video_enc = &st->codec;
2743
2744 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2745 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2746 if (video_stream_copy) {
2747 st->stream_copy = 1;
2748 video_enc->codec_type = CODEC_TYPE_VIDEO;
2749 } else {
2750 char *p;
2751 int i;
2752 AVCodec *codec;
2753
2754 codec_id = file_oformat->video_codec;
2755 if (video_codec_id != CODEC_ID_NONE)
2756 codec_id = video_codec_id;
2757
2758 video_enc->codec_id = codec_id;
2759 codec = avcodec_find_encoder(codec_id);
2760
2761 video_enc->bit_rate = video_bit_rate;
2762 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2763 video_enc->frame_rate = frame_rate;
2764 video_enc->frame_rate_base = frame_rate_base;
2765 if(codec && codec->supported_framerates){
2766 const AVRational *p= codec->supported_framerates;
2767 AVRational req= (AVRational){frame_rate, frame_rate_base};
2768 const AVRational *best=NULL;
2769 AVRational best_error= (AVRational){INT_MAX, 1};
2770 for(; p->den!=0; p++){
2771 AVRational error= av_sub_q(req, *p);
2772 if(error.num <0) error.num *= -1;
2773 if(av_cmp_q(error, best_error) < 0){
2774 best_error= error;
2775 best= p;
2776 }
2777 }
2778 video_enc->frame_rate = best->num;
2779 video_enc->frame_rate_base= best->den;
2780 }
2781
2782 video_enc->width = frame_width + frame_padright + frame_padleft;
2783 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2784 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2785 video_enc->pix_fmt = frame_pix_fmt;
2786
2787 if(codec && codec->pix_fmts){
2788 const enum PixelFormat *p= codec->pix_fmts;
2789 for(; *p!=-1; p++){
2790 if(*p == video_enc->pix_fmt)
2791 break;
2792 }
2793 if(*p == -1)
2794 video_enc->pix_fmt = codec->pix_fmts[0];
2795 }
2796
2797 if (!intra_only)
2798 video_enc->gop_size = gop_size;
2799 else
2800 video_enc->gop_size = 0;
2801 if (video_qscale || same_quality) {
2802 video_enc->flags |= CODEC_FLAG_QSCALE;
2803 st->quality = FF_QP2LAMBDA * video_qscale;
2804 }
2805
2806 if(intra_matrix)
2807 video_enc->intra_matrix = intra_matrix;
2808 if(inter_matrix)
2809 video_enc->inter_matrix = inter_matrix;
2810
2811 if(bitexact)
2812 video_enc->flags |= CODEC_FLAG_BITEXACT;
2813
2814 video_enc->mb_decision = mb_decision;
2815 video_enc->mb_cmp = mb_cmp;
2816 video_enc->ildct_cmp = ildct_cmp;
2817 video_enc->me_sub_cmp = sub_cmp;
2818 video_enc->me_cmp = cmp;
2819 video_enc->me_pre_cmp = pre_cmp;
2820 video_enc->pre_me = pre_me;
2821 video_enc->lumi_masking = lumi_mask;
2822 video_enc->dark_masking = dark_mask;
2823 video_enc->spatial_cplx_masking = scplx_mask;
2824 video_enc->temporal_cplx_masking = tcplx_mask;
2825 video_enc->p_masking = p_mask;
2826 video_enc->quantizer_noise_shaping= qns;
2827
2828 if (use_umv) {
2829 video_enc->flags |= CODEC_FLAG_H263P_UMV;
2830 }
2831 if (use_ss) {
2832 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
2833 }
2834 if (use_aic) {
2835 video_enc->flags |= CODEC_FLAG_H263P_AIC;
2836 }
2837 if (use_aiv) {
2838 video_enc->flags |= CODEC_FLAG_H263P_AIV;
2839 }
2840 if (use_4mv) {
2841 video_enc->flags |= CODEC_FLAG_4MV;
2842 }
2843 if (use_obmc) {
2844 video_enc->flags |= CODEC_FLAG_OBMC;
2845 }
2846 if (use_loop) {
2847 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
2848 }
2849
2850 if(use_part) {
2851 video_enc->flags |= CODEC_FLAG_PART;
2852 }
2853 if (use_alt_scan) {
2854 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
2855 }
2856 if (use_trell) {
2857 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
2858 }
2859 if (use_scan_offset) {
2860 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
2861 }
2862 if (closed_gop) {
2863 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
2864 }
2865 if (use_qpel) {
2866 video_enc->flags |= CODEC_FLAG_QPEL;
2867 }
2868 if (b_frames) {
2869 video_enc->max_b_frames = b_frames;
2870 video_enc->b_frame_strategy = 0;
2871 video_enc->b_quant_factor = 2.0;
2872 }
2873 if (do_interlace_dct) {
2874 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
2875 }
2876 if (do_interlace_me) {
2877 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
2878 }
2879 video_enc->qmin = video_qmin;
2880 video_enc->qmax = video_qmax;
2881 video_enc->lmin = video_lmin;
2882 video_enc->lmax = video_lmax;
2883 video_enc->mb_qmin = video_mb_qmin;
2884 video_enc->mb_qmax = video_mb_qmax;
2885 video_enc->max_qdiff = video_qdiff;
2886 video_enc->qblur = video_qblur;
2887 video_enc->qcompress = video_qcomp;
2888 video_enc->rc_eq = video_rc_eq;
2889 video_enc->debug = debug;
2890 video_enc->debug_mv = debug_mv;
2891 video_enc->thread_count = thread_count;
2892 p= video_rc_override_string;
2893 for(i=0; p; i++){
2894 int start, end, q;
2895 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2896 if(e!=3){
2897 fprintf(stderr, "error parsing rc_override\n");
2898 exit(1);
2899 }
2900 video_enc->rc_override=
2901 av_realloc(video_enc->rc_override,
2902 sizeof(RcOverride)*(i+1));
2903 video_enc->rc_override[i].start_frame= start;
2904 video_enc->rc_override[i].end_frame = end;
2905 if(q>0){
2906 video_enc->rc_override[i].qscale= q;
2907 video_enc->rc_override[i].quality_factor= 1.0;
2908 }
2909 else{
2910 video_enc->rc_override[i].qscale= 0;
2911 video_enc->rc_override[i].quality_factor= -q/100.0;
2912 }
2913 p= strchr(p, '/');
2914 if(p) p++;
2915 }
2916 video_enc->rc_override_count=i;
2917
2918 video_enc->rc_max_rate = video_rc_max_rate;
2919 video_enc->rc_min_rate = video_rc_min_rate;
2920 video_enc->rc_buffer_size = video_rc_buffer_size;
2921 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
2922 video_enc->rc_initial_cplx= video_rc_initial_cplx;
2923 video_enc->i_quant_factor = video_i_qfactor;
2924 video_enc->b_quant_factor = video_b_qfactor;
2925 video_enc->i_quant_offset = video_i_qoffset;
2926 video_enc->b_quant_offset = video_b_qoffset;
2927 video_enc->intra_quant_bias = video_intra_quant_bias;
2928 video_enc->inter_quant_bias = video_inter_quant_bias;
2929 video_enc->dct_algo = dct_algo;
2930 video_enc->idct_algo = idct_algo;
2931 video_enc->me_threshold= me_threshold;
2932 video_enc->mb_threshold= mb_threshold;
2933 video_enc->intra_dc_precision= intra_dc_precision;
2934 video_enc->strict_std_compliance = strict;
2935 video_enc->error_rate = error_rate;
2936 video_enc->noise_reduction= noise_reduction;
2937 video_enc->scenechange_threshold= sc_threshold;
2938 video_enc->me_range = me_range;
2939 video_enc->coder_type= coder;
2940 video_enc->context_model= context;
2941 video_enc->prediction_method= predictor;
2942
2943 if(packet_size){
2944 video_enc->rtp_mode= 1;
2945 video_enc->rtp_payload_size= packet_size;
2946 }
2947
2948 if (do_psnr)
2949 video_enc->flags|= CODEC_FLAG_PSNR;
2950
2951 video_enc->me_method = me_method;
2952
2953 /* two pass mode */
2954 if (do_pass) {
2955 if (do_pass == 1) {
2956 video_enc->flags |= CODEC_FLAG_PASS1;
2957 } else {
2958 video_enc->flags |= CODEC_FLAG_PASS2;
2959 }
2960 }
2961 }
2962 }
2963
2964 if (use_audio) {
2965 AVCodecContext *audio_enc;
2966
2967 st = av_new_stream(oc, nb_streams++);
2968 if (!st) {
2969 fprintf(stderr, "Could not alloc stream\n");
2970 exit(1);
2971 }
2972 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2973 if(thread_count>1)
2974 avcodec_thread_init(&st->codec, thread_count);
2975 #endif
2976
2977 audio_enc = &st->codec;
2978 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2979
2980 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2981 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2982 if (audio_stream_copy) {
2983 st->stream_copy = 1;
2984 } else {
2985 codec_id = file_oformat->audio_codec;
2986 if (audio_codec_id != CODEC_ID_NONE)
2987 codec_id = audio_codec_id;
2988 audio_enc->codec_id = codec_id;
2989
2990 audio_enc->bit_rate = audio_bit_rate;
2991 audio_enc->sample_rate = audio_sample_rate;
2992 audio_enc->strict_std_compliance = strict;
2993 audio_enc->thread_count = thread_count;
2994 /* For audio codecs other than AC3 we limit */
2995 /* the number of coded channels to stereo */
2996 if (audio_channels > 2 && codec_id != CODEC_ID_AC3) {
2997 audio_enc->channels = 2;
2998 } else
2999 audio_enc->channels = audio_channels;
3000 }
3001 }
3002
3003 oc->nb_streams = nb_streams;
3004
3005 if (!nb_streams) {
3006 fprintf(stderr, "No audio or video streams available\n");
3007 exit(1);
3008 }
3009
3010 oc->timestamp = rec_timestamp;
3011
3012 if (str_title)
3013 pstrcpy(oc->title, sizeof(oc->title), str_title);
3014 if (str_author)
3015 pstrcpy(oc->author, sizeof(oc->author), str_author);
3016 if (str_copyright)
3017 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3018 if (str_comment)
3019 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3020 }
3021
3022 output_files[nb_output_files++] = oc;
3023
3024 strcpy(oc->filename, filename);
3025
3026 /* check filename in case of an image number is expected */
3027 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3028 if (filename_number_test(oc->filename) < 0) {
3029 print_error(oc->filename, AVERROR_NUMEXPECTED);
3030 exit(1);
3031 }
3032 }
3033
3034 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3035 /* test if it already exists to avoid loosing precious files */
3036 if (!file_overwrite &&
3037 (strchr(filename, ':') == NULL ||
3038 strstart(filename, "file:", NULL))) {
3039 if (url_exist(filename)) {
3040 int c;
3041
3042 if ( !using_stdin ) {
3043 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3044 fflush(stderr);
3045 c = getchar();
3046 if (toupper(c) != 'Y') {
3047 fprintf(stderr, "Not overwriting - exiting\n");
3048 exit(1);
3049 }
3050 }
3051 else {
3052 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3053 exit(1);
3054 }
3055 }
3056 }
3057
3058 /* open the file */
3059 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3060 fprintf(stderr, "Could not open '%s'\n", filename);
3061 exit(1);
3062 }
3063 }
3064
3065 memset(ap, 0, sizeof(*ap));
3066 ap->image_format = image_format;
3067 if (av_set_parameters(oc, ap) < 0) {
3068 fprintf(stderr, "%s: Invalid encoding parameters\n",
3069 oc->filename);
3070 exit(1);
3071 }
3072
3073 /* reset some options */
3074 file_oformat = NULL;
3075 file_iformat = NULL;
3076 image_format = NULL;
3077 audio_disable = 0;
3078 video_disable = 0;
3079 audio_codec_id = CODEC_ID_NONE;
3080 video_codec_id = CODEC_ID_NONE;
3081 audio_stream_copy = 0;
3082 video_stream_copy = 0;
3083 }
3084
3085 /* prepare dummy protocols for grab */
3086 static void prepare_grab(void)
3087 {
3088 int has_video, has_audio, i, j;
3089 AVFormatContext *oc;
3090 AVFormatContext *ic;
3091 AVFormatParameters vp1, *vp = &vp1;
3092 AVFormatParameters ap1, *ap = &ap1;
3093
3094 /* see if audio/video inputs are needed */
3095 has_video = 0;
3096 has_audio = 0;
3097 memset(ap, 0, sizeof(*ap));
3098 memset(vp, 0, sizeof(*vp));
3099 for(j=0;j<nb_output_files;j++) {
3100 oc = output_files[j];
3101 for(i=0;i<oc->nb_streams;i++) {
3102 AVCodecContext *enc = &oc->streams[i]->codec;
3103 switch(enc->codec_type) {
3104 case CODEC_TYPE_AUDIO:
3105 if (enc->sample_rate > ap->sample_rate)
3106 ap->sample_rate = enc->sample_rate;
3107 if (enc->channels > ap->channels)
3108 ap->channels = enc->channels;
3109 has_audio = 1;
3110 break;
3111 case CODEC_TYPE_VIDEO:
3112 if (enc->width > vp->width)
3113 vp->width = enc->width;
3114 if (enc->height > vp->height)
3115 vp->height = enc->height;
3116
3117 assert(enc->frame_rate_base == DEFAULT_FRAME_RATE_BASE);
3118 if (enc->frame_rate > vp->frame_rate){
3119 vp->frame_rate = enc->frame_rate;
3120 vp->frame_rate_base = enc->frame_rate_base;
3121 }
3122 has_video = 1;
3123 break;
3124 default:
3125 av_abort();
3126 }
3127 }
3128 }
3129
3130 if (has_video == 0 && has_audio == 0) {
3131 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3132 exit(1);
3133 }
3134
3135 if (has_video) {
3136 AVInputFormat *fmt1;
3137 fmt1 = av_find_input_format(video_grab_format);
3138 vp->device = video_device;
3139 vp->channel = video_channel;
3140 vp->standard = video_standard;
3141 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3142 fprintf(stderr, "Could not find video grab device\n");
3143 exit(1);
3144 }
3145 /* If not enough info to get the stream parameters, we decode the
3146 first frames to get it. */
3147 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3148 fprintf(stderr, "Could not find video grab parameters\n");
3149 exit(1);
3150 }
3151 /* by now video grab has one stream */
3152 ic->streams[0]->r_frame_rate = vp->frame_rate;
3153 ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3154 input_files[nb_input_files] = ic;
3155
3156 if (verbose >= 0)
3157 dump_format(ic, nb_input_files, "", 0);
3158
3159 nb_input_files++;
3160 }
3161 if (has_audio && audio_grab_format) {
3162 AVInputFormat *fmt1;
3163 fmt1 = av_find_input_format(audio_grab_format);
3164 ap->device = audio_device;
3165 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3166 fprintf(stderr, "Could not find audio grab device\n");
3167 exit(1);
3168 }
3169 input_files[nb_input_files] = ic;
3170
3171 if (verbose >= 0)
3172 dump_format(ic, nb_input_files, "", 0);
3173
3174 nb_input_files++;
3175 }
3176 }
3177
3178 /* same option as mencoder */
3179 static void opt_pass(const char *pass_str)
3180 {
3181 int pass;
3182 pass = atoi(pass_str);
3183 if (pass != 1 && pass != 2) {
3184 fprintf(stderr, "pass number can be only 1 or 2\n");
3185 exit(1);
3186 }
3187 do_pass = pass;
3188 }
3189
3190 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3191 static int64_t getutime(void)
3192 {
3193 return av_gettime();
3194 }
3195 #else
3196 static int64_t getutime(void)
3197 {
3198 struct rusage rusage;
3199
3200 getrusage(RUSAGE_SELF, &rusage);
3201 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3202 }
3203 #endif
3204
3205 extern int ffm_nopts;
3206
3207 static void opt_bitexact(void)
3208 {
3209 bitexact=1;
3210 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3211 ffm_nopts = 1;
3212 }
3213
3214 static void show_formats(void)
3215 {
3216 AVInputFormat *ifmt;
3217 AVOutputFormat *ofmt;
3218 AVImageFormat *image_fmt;
3219 URLProtocol *up;
3220 AVCodec *p, *p2;
3221 const char **pp, *last_name;
3222
3223 printf("File formats:\n");
3224 last_name= "000";
3225 for(;;){
3226 int decode=0;
3227 int encode=0;
3228 const char *name=NULL;
3229
3230 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3231 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3232 strcmp(ofmt->name, last_name)>0){
3233 name= ofmt->name;
3234 encode=1;
3235 }
3236 }
3237 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3238 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3239 strcmp(ifmt->name, last_name)>0){
3240 name= ifmt->name;
3241 encode=0;
3242 }
3243 if(name && strcmp(ifmt->name, name)==0)
3244 decode=1;
3245 }
3246 if(name==NULL)
3247 break;
3248 last_name= name;
3249
3250 printf(
3251 " %s%s %s\n",
3252 decode ? "D":" ",
3253 encode ? "E":" ",
3254 name);
3255 }
3256 printf("\n");
3257
3258 printf("Image formats:\n");
3259 for(image_fmt = first_image_format; image_fmt != NULL;
3260 image_fmt = image_fmt->next) {
3261 printf(
3262 " %s%s %s\n",
3263 image_fmt->img_read ? "D":" ",
3264 image_fmt->img_write ? "E":" ",
3265 image_fmt->name);
3266 }
3267 printf("\n");
3268
3269 printf("Codecs:\n");
3270 last_name= "000";
3271 for(;;){
3272 int decode=0;
3273 int encode=0;
3274 int cap=0;
3275
3276 p2=NULL;
3277 for(p = first_avcodec; p != NULL; p = p->next) {
3278 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3279 strcmp(p->name, last_name)>0){
3280 p2= p;
3281 decode= encode= cap=0;
3282 }
3283 if(p2 && strcmp(p->name, p2->name)==0){
3284 if(p->decode) decode=1;
3285 if(p->encode) encode=1;
3286 cap |= p->capabilities;
3287 }
3288 }
3289 if(p2==NULL)
3290 break;
3291 last_name= p2->name;
3292
3293 printf(
3294 " %s%s%s%s%s%s %s",
3295 decode ? "D": (/*p2->decoder ? "d":*/" "),
3296 encode ? "E":" ",
3297 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3298 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3299 cap & CODEC_CAP_DR1 ? "D":" ",
3300 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3301 p2->name);
3302 /* if(p2->decoder && decode==0)
3303 printf(" use %s for decoding", p2->decoder->name);*/
3304 printf("\n");
3305 }
3306 printf("\n");
3307
3308 printf("Supported file protocols:\n");
3309 for(up = first_protocol; up != NULL; up = up->next)
3310 printf(" %s:", up->name);
3311 printf("\n");
3312
3313 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3314 printf("Motion estimation methods:\n");
3315 pp = motion_str;
3316 while (*pp) {
3317 printf(" %s", *pp);
3318 if ((pp - motion_str + 1) == ME_ZERO)
3319 printf("(fastest)");
3320 else if ((pp - motion_str + 1) == ME_FULL)
3321 printf("(slowest)");
3322 else if ((pp - motion_str + 1) == ME_EPZS)
3323 printf("(default)");
3324 pp++;
3325 }
3326 printf("\n\n");
3327 printf(
3328 "Note, the names of encoders and decoders dont always match, so there are\n"
3329 "several cases where the above table shows encoder only or decoder only entries\n"
3330 "even though both encoding and decoding are supported for example, the h263\n"
3331 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3332 "worse\n");
3333 exit(1);
3334 }
3335
3336 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3337 {
3338 int i;
3339 const char *p = str;
3340 for(i = 0;; i++) {
3341 dest[i] = atoi(p);
3342 if(i == 63)
3343 break;
3344 p = strchr(p, ',');
3345 if(!p) {
3346 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3347 exit(1);
3348 }
3349 p++;
3350 }
3351 }
3352
3353 void opt_inter_matrix(const char *arg)
3354 {
3355 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3356 parse_matrix_coeffs(inter_matrix, arg);
3357 }
3358
3359 void opt_intra_matrix(const char *arg)
3360 {
3361 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3362 parse_matrix_coeffs(intra_matrix, arg);
3363 }
3364
3365 static void opt_target(const char *arg)
3366 {
3367 int norm = -1;
3368
3369 if(!strncmp(arg, "pal-", 4)) {
3370 norm = 0;
3371 arg += 4;
3372 } else if(!strncmp(arg, "ntsc-", 5)) {
3373 norm = 1;
3374 arg += 5;
3375 } else {
3376 int fr;
3377 /* Calculate FR via float to avoid int overflow */
3378 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3379 if(fr == 25000) {
3380 norm = 0;
3381 } else if((fr == 29970) || (fr == 23976)) {
3382 norm = 1;
3383 } else {
3384 /* Try to determine PAL/NTSC by peeking in the input files */
3385 if(nb_input_files) {
3386 int i, j;
3387 for(j = 0; j < nb_input_files; j++) {
3388 for(i = 0; i < input_files[j]->nb_streams; i++) {
3389 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3390 if(c->codec_type != CODEC_TYPE_VIDEO)
3391 continue;
3392 fr = c->frame_rate * 1000 / c->frame_rate_base;
3393 if(fr == 25000) {
3394 norm = 0;
3395 break;
3396 } else if((fr == 29970) || (fr == 23976)) {
3397 norm = 1;
3398 break;
3399 }
3400 }
3401 if(norm >= 0)
3402 break;
3403 }
3404 }
3405 }
3406 if(verbose && norm >= 0)
3407 printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3408 }
3409
3410 if(norm < 0) {
3411 fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3412 fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3413 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3414 exit(1);
3415 }
3416
3417 if(!strcmp(arg, "vcd")) {
3418
3419 opt_video_codec("mpeg1video");
3420 opt_audio_codec("mp2");
3421 opt_format("vcd");
3422
3423 opt_frame_size(norm ? "352x240" : "352x288");
3424
3425 video_bit_rate = 1150000;
3426 video_rc_max_rate = 1150000;
3427 video_rc_min_rate = 1150000;
3428 video_rc_buffer_size = 40*1024*8;
3429
3430 audio_bit_rate = 224000;
3431 audio_sample_rate = 44100;
3432
3433 } else if(!strcmp(arg, "svcd")) {
3434
3435 opt_video_codec("mpeg2video");
3436 opt_audio_codec("mp2");
3437 opt_format("svcd");
3438
3439 opt_frame_size(norm ? "480x480" : "480x576");
3440 opt_gop_size(norm ? "18" : "15");
3441
3442 video_bit_rate = 2040000;
3443 video_rc_max_rate = 2516000;
3444 video_rc_min_rate = 0; //1145000;
3445 video_rc_buffer_size = 224*1024*8;
3446 use_scan_offset = 1;
3447
3448 audio_bit_rate = 224000;
3449 audio_sample_rate = 44100;
3450
3451 } else if(!strcmp(arg, "dvd")) {
3452
3453 opt_video_codec("mpeg2video");
3454 opt_audio_codec("ac3");
3455 opt_format("vob");
3456
3457 opt_frame_size(norm ? "720x480" : "720x576");
3458 opt_gop_size(norm ? "18" : "15");
3459
3460 video_bit_rate = 6000000;
3461 video_rc_max_rate = 9000000;
3462 video_rc_min_rate = 0; //1500000;
3463 video_rc_buffer_size = 224*1024*8;
3464
3465 audio_bit_rate = 448000;
3466 audio_sample_rate = 48000;
3467
3468 } else {
3469 fprintf(stderr, "Unknown target: %s\n", arg);
3470 exit(1);
3471 }
3472 }
3473
3474 static void show_version(void)
3475 {
3476 printf("ffmpeg " FFMPEG_VERSION "\n"
3477 "libavcodec %d\n"
3478 "libavformat %d\n",
3479 avcodec_build(), LIBAVFORMAT_BUILD);
3480 exit(1);
3481 }
3482
3483 const OptionDef options[] = {
3484 /* main options */
3485 { "L", 0, {(void*)show_license}, "show license" },
3486 { "h", 0, {(void*)show_help}, "show help" },
3487 { "version", 0, {(void*)show_version}, "show version" },
3488 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3489 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3490 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3491 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3492 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3493 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3494 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3495 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3496 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3497 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3498 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3499 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3500 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3501 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3502 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3503 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3504 "add timings for benchmarking" },
3505 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3506 "dump each input packet" },
3507 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3508 "when dumping packets, also dump the payload" },
3509 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3510 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3511 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3512 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3513 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\" or \"dvd\")", "type" },
3514 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3515 { "sync", HAS_ARG | OPT_EXPERT, {(void*)opt_sync_method}, "sync method", "" },
3516
3517 /* video options */
3518 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3519 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3520 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3521 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3522 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3523 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3524 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3525 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3526 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3527 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3528 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3529 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3530 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3531 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3532 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3533 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3534 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3535 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3536 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3537 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3538 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3539 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3540 { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3541 { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3542 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3543 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3544 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3545 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3546 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3547 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3548 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3549 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3550 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3551 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3552 // { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3553 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3554 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3555 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3556 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3557 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3558 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kByte)", "size" },
3559 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3560 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3561 "method" },
3562 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
3563 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
3564 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3565 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3566 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
3567 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
3568 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3569 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3570 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3571 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3572 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3573 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3574 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3575 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3576 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3577 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3578 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3579 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3580 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "teporal complexity masking", "" },
3581 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3582 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3583 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3584 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3585 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3586 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3587 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3588 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3589 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3590 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3591 "use same video quality as source (implies VBR)" },
3592 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3593 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3594 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3595 "deinterlace pictures" },
3596 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
3597 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3598 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
3599 "force interlaced me support in encoder (MPEG2/MPEG4)" },
3600 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3601 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3602 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3603 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3604 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3605 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3606 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3607 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3608 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3609 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3610 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3611 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3612 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3613 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3614 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3615 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3616 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3617 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3618 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3619 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3620 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3621 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3622 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3623
3624 /* audio options */
3625 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3626 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3627 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3628 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3629 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3630
3631 /* grab options */
3632 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3633 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3634 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3635 { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3636 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3637 { NULL, },
3638 };
3639
3640 static void show_banner(void)
3641 {
3642 printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2003 Fabrice Bellard\n");
3643 }
3644
3645 static void show_license(void)
3646 {
3647 show_banner();
3648 #ifdef CONFIG_GPL
3649 printf(
3650 "This program is free software; you can redistribute it and/or modify\n"
3651 "it under the terms of the GNU General Public License as published by\n"
3652 "the Free Software Foundation; either version 2 of the License, or\n"
3653 "(at your option) any later version.\n"
3654 "\n"
3655 "This program is distributed in the hope that it will be useful,\n"
3656 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3657 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3658 "GNU General Public License for more details.\n"
3659 "\n"
3660 "You should have received a copy of the GNU General Public License\n"
3661 "along with this program; if not, write to the Free Software\n"
3662 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
3663 );
3664 #else
3665 printf(
3666 "This library is free software; you can redistribute it and/or\n"
3667 "modify it under the terms of the GNU Lesser General Public\n"
3668 "License as published by the Free Software Foundation; either\n"
3669 "version 2 of the License, or (at your option) any later version.\n"
3670 "\n"
3671 "This library is distributed in the hope that it will be useful,\n"
3672 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3673 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3674 "Lesser General Public License for more details.\n"
3675 "\n"
3676 "You should have received a copy of the GNU Lesser General Public\n"
3677 "License along with this library; if not, write to the Free Software\n"
3678 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
3679 );
3680 #endif
3681 exit(1);
3682 }
3683
3684 static void show_help(void)
3685 {
3686 show_banner();
3687 printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
3688 "Hyper fast Audio and Video encoder\n");
3689 printf("\n");
3690 show_help_options(options, "Main options:\n",
3691 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3692 show_help_options(options, "\nVideo options:\n"