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