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