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