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