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