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