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