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