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