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