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