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