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