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