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