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