projects / libav.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
increase size of crop table
[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;
cfcbbe48 3042 audio_enc->channels = audio_channels;
1629626f
FB		 3043 } else {
3044 codec_id = file_oformat->audio_codec;
3045 if (audio_codec_id != CODEC_ID_NONE)
3046 codec_id = audio_codec_id;
3047 audio_enc->codec_id = codec_id;
3048
3049 audio_enc->bit_rate = audio_bit_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 }
cfcbbe48 3059 audio_enc->sample_rate = audio_sample_rate;
85f07f22
FB		 3060 }
3061
3062 oc->nb_streams = nb_streams;
3063
3064 if (!nb_streams) {
919f448d 3065 fprintf(stderr, "No audio or video streams available\n");
85f07f22
FB		 3066 exit(1);
3067 }
3068
4568325a
RS		 3069 oc->timestamp = rec_timestamp;
3070
3071 if (str_title)
79fdaa4c 3072 pstrcpy(oc->title, sizeof(oc->title), str_title);
85f07f22 3073 if (str_author)
79fdaa4c 3074 pstrcpy(oc->author, sizeof(oc->author), str_author);
85f07f22 3075 if (str_copyright)
79fdaa4c 3076 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
85f07f22 3077 if (str_comment)
79fdaa4c 3078 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
85f07f22
FB		 3079 }
3080
1629626f 3081 output_files[nb_output_files++] = oc;
85f07f22
FB		 3082
3083 strcpy(oc->filename, filename);
919f448d
FB		 3084
3085 /* check filename in case of an image number is expected */
79fdaa4c
FB		 3086 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3087 if (filename_number_test(oc->filename) < 0) {
3088 print_error(oc->filename, AVERROR_NUMEXPECTED);
919f448d 3089 exit(1);
79fdaa4c 3090 }
919f448d
FB		 3091 }
3092
79fdaa4c 3093 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
85f07f22
FB		 3094 /* test if it already exists to avoid loosing precious files */
3095 if (!file_overwrite &&
3096 (strchr(filename, ':') == NULL ||
3097 strstart(filename, "file:", NULL))) {
3098 if (url_exist(filename)) {
3099 int c;
3100
d9a916e2
CY		 3101 if ( !using_stdin ) {
3102 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3103 fflush(stderr);
3104 c = getchar();
3105 if (toupper(c) != 'Y') {
3106 fprintf(stderr, "Not overwriting - exiting\n");
3107 exit(1);
3108 }
3109 }
3110 else {
3111 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
85f07f22 3112 exit(1);
d9a916e2 3113 }
85f07f22
FB		 3114 }
3115 }
3116
3117 /* open the file */
3118 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3119 fprintf(stderr, "Could not open '%s'\n", filename);
3120 exit(1);
3121 }
3122 }
3123
817b23ff
FB		 3124 memset(ap, 0, sizeof(*ap));
3125 ap->image_format = image_format;
3126 if (av_set_parameters(oc, ap) < 0) {
3127 fprintf(stderr, "%s: Invalid encoding parameters\n",
3128 oc->filename);
3129 exit(1);
3130 }
3131
85f07f22 3132 /* reset some options */
79fdaa4c
FB		 3133 file_oformat = NULL;
3134 file_iformat = NULL;
817b23ff 3135 image_format = NULL;
85f07f22
FB		 3136 audio_disable = 0;
3137 video_disable = 0;
3138 audio_codec_id = CODEC_ID_NONE;
3139 video_codec_id = CODEC_ID_NONE;
1629626f
FB		 3140 audio_stream_copy = 0;
3141 video_stream_copy = 0;
85f07f22
FB		 3142}
3143
a38469e1 3144/* prepare dummy protocols for grab */
b29f97d1 3145static void prepare_grab(void)
a38469e1
FB		 3146{
3147 int has_video, has_audio, i, j;
3148 AVFormatContext *oc;
3149 AVFormatContext *ic;
79a7c268 3150 AVFormatParameters vp1, *vp = &vp1;
a38469e1 3151 AVFormatParameters ap1, *ap = &ap1;
79a7c268 3152
a38469e1
FB		 3153 /* see if audio/video inputs are needed */
3154 has_video = 0;
3155 has_audio = 0;
3156 memset(ap, 0, sizeof(*ap));
79a7c268 3157 memset(vp, 0, sizeof(*vp));
a38469e1
FB		 3158 for(j=0;j<nb_output_files;j++) {
3159 oc = output_files[j];
3160 for(i=0;i<oc->nb_streams;i++) {
3161 AVCodecContext *enc = &oc->streams[i]->codec;
3162 switch(enc->codec_type) {
3163 case CODEC_TYPE_AUDIO:
3164 if (enc->sample_rate > ap->sample_rate)
3165 ap->sample_rate = enc->sample_rate;
3166 if (enc->channels > ap->channels)
3167 ap->channels = enc->channels;
3168 has_audio = 1;
3169 break;
3170 case CODEC_TYPE_VIDEO:
79a7c268
FB		 3171 if (enc->width > vp->width)
3172 vp->width = enc->width;
3173 if (enc->height > vp->height)
3174 vp->height = enc->height;
14bea432
MN		 3175
3176 assert(enc->frame_rate_base == DEFAULT_FRAME_RATE_BASE);
3177 if (enc->frame_rate > vp->frame_rate){
3178 vp->frame_rate = enc->frame_rate;
3179 vp->frame_rate_base = enc->frame_rate_base;
3180 }
a38469e1
FB		 3181 has_video = 1;
3182 break;
51bd4565 3183 default:
c04643a2 3184 av_abort();
a38469e1
FB		 3185 }
3186 }
3187 }
3188
3189 if (has_video == 0 && has_audio == 0) {
3190 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3191 exit(1);
3192 }
3193
3194 if (has_video) {
79fdaa4c 3195 AVInputFormat *fmt1;
8aa3ee32 3196 fmt1 = av_find_input_format(video_grab_format);
a5df11ab
FB		 3197 vp->device = video_device;
3198 vp->channel = video_channel;
e3ee3283 3199 vp->standard = video_standard;
79a7c268 3200 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
bf5af568 3201 fprintf(stderr, "Could not find video grab device\n");
a38469e1
FB		 3202 exit(1);
3203 }
ddaae6a9
RS		 3204 /* If not enough info to get the stream parameters, we decode the
3205 first frames to get it. */
3206 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3207 fprintf(stderr, "Could not find video grab parameters\n");
3208 exit(1);
3209 }
79fdaa4c 3210 /* by now video grab has one stream */
14bea432
MN		 3211 ic->streams[0]->r_frame_rate = vp->frame_rate;
3212 ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
a38469e1 3213 input_files[nb_input_files] = ic;
d8019eb5
AD		 3214
3215 if (verbose >= 0)
3216 dump_format(ic, nb_input_files, "", 0);
3217
a38469e1
FB		 3218 nb_input_files++;
3219 }
1501987b 3220 if (has_audio && audio_grab_format) {
79fdaa4c 3221 AVInputFormat *fmt1;
8aa3ee32 3222 fmt1 = av_find_input_format(audio_grab_format);
79a7c268 3223 ap->device = audio_device;
79fdaa4c 3224 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
bf5af568 3225 fprintf(stderr, "Could not find audio grab device\n");
a38469e1
FB		 3226 exit(1);
3227 }
3228 input_files[nb_input_files] = ic;
d8019eb5
AD		 3229
3230 if (verbose >= 0)
3231 dump_format(ic, nb_input_files, "", 0);
3232
a38469e1
FB		 3233 nb_input_files++;
3234 }
3235}
3236
5abdb4b1 3237/* same option as mencoder */
b29f97d1 3238static void opt_pass(const char *pass_str)
5abdb4b1
FB		 3239{
3240 int pass;
3241 pass = atoi(pass_str);
3242 if (pass != 1 && pass != 2) {
3243 fprintf(stderr, "pass number can be only 1 or 2\n");
3244 exit(1);
3245 }
3246 do_pass = pass;
3247}
a38469e1 3248
f3ec2d46 3249#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
0c1a9eda 3250static int64_t getutime(void)
5727b222 3251{
f3ec2d46 3252 return av_gettime();
5727b222 3253}
bdc4796f 3254#else
0c1a9eda 3255static int64_t getutime(void)
bdc4796f 3256{
f3ec2d46
SG		 3257 struct rusage rusage;
3258
3259 getrusage(RUSAGE_SELF, &rusage);
3260 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
bdc4796f
FB		 3261}
3262#endif
5727b222 3263
79fdaa4c
FB		 3264extern int ffm_nopts;
3265
b29f97d1 3266static void opt_bitexact(void)
79fdaa4c 3267{
b0368839 3268 bitexact=1;
79fdaa4c
FB		 3269 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3270 ffm_nopts = 1;
3271}
3272
b29f97d1 3273static void show_formats(void)
85f07f22 3274{
79fdaa4c
FB		 3275 AVInputFormat *ifmt;
3276 AVOutputFormat *ofmt;
817b23ff 3277 AVImageFormat *image_fmt;
85f07f22 3278 URLProtocol *up;
3738fe1a
MN		 3279 AVCodec *p, *p2;
3280 const char **pp, *last_name;
3281
3282 printf("File formats:\n");
3283 last_name= "000";
3284 for(;;){
3285 int decode=0;
3286 int encode=0;
3287 const char *name=NULL;
3288
3289 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3290 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3291 strcmp(ofmt->name, last_name)>0){
3292 name= ofmt->name;
3293 encode=1;
3294 }
3295 }
3296 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3297 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3298 strcmp(ifmt->name, last_name)>0){
3299 name= ifmt->name;
3300 encode=0;
3301 }
3302 if(name && strcmp(ifmt->name, name)==0)
3303 decode=1;
3304 }
3305 if(name==NULL)
3306 break;
3307 last_name= name;
3308
3309 printf(
3310 " %s%s %s\n",
3311 decode ? "D":" ",
3312 encode ? "E":" ",
3313 name);
817b23ff
FB		 3314 }
3315 printf("\n");
3316
3738fe1a 3317 printf("Image formats:\n");
817b23ff
FB		 3318 for(image_fmt = first_image_format; image_fmt != NULL;
3319 image_fmt = image_fmt->next) {
3738fe1a
MN		 3320 printf(
3321 " %s%s %s\n",
3322 image_fmt->img_read ? "D":" ",
3323 image_fmt->img_write ? "E":" ",
3324 image_fmt->name);
817b23ff
FB		 3325 }
3326 printf("\n");
3327
85f07f22 3328 printf("Codecs:\n");
3738fe1a
MN		 3329 last_name= "000";
3330 for(;;){
3331 int decode=0;
3332 int encode=0;
3333 int cap=0;
3334
3335 p2=NULL;
3336 for(p = first_avcodec; p != NULL; p = p->next) {
3337 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3338 strcmp(p->name, last_name)>0){
3339 p2= p;
3340 decode= encode= cap=0;
3341 }
3342 if(p2 && strcmp(p->name, p2->name)==0){
3343 if(p->decode) decode=1;
3344 if(p->encode) encode=1;
3345 cap |= p->capabilities;
3346 }
3347 }
3348 if(p2==NULL)
3349 break;
3350 last_name= p2->name;
3351
3352 printf(
3353 " %s%s%s%s%s%s %s",
3354 decode ? "D": (/*p2->decoder ? "d":*/" "),
3355 encode ? "E":" ",
3356 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3357 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3358 cap & CODEC_CAP_DR1 ? "D":" ",
3359 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3360 p2->name);
3361 /* if(p2->decoder && decode==0)
3362 printf(" use %s for decoding", p2->decoder->name);*/
3363 printf("\n");
85f07f22
FB		 3364 }
3365 printf("\n");
3366
3738fe1a 3367 printf("Supported file protocols:\n");
85f07f22
FB		 3368 for(up = first_protocol; up != NULL; up = up->next)
3369 printf(" %s:", up->name);
3370 printf("\n");
3371
3738fe1a
MN		 3372 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3373 printf("Motion estimation methods:\n");
85f07f22
FB		 3374 pp = motion_str;
3375 while (*pp) {
3376 printf(" %s", *pp);
101bea5f 3377 if ((pp - motion_str + 1) == ME_ZERO)
85f07f22 3378 printf("(fastest)");
101bea5f 3379 else if ((pp - motion_str + 1) == ME_FULL)
85f07f22 3380 printf("(slowest)");
101bea5f 3381 else if ((pp - motion_str + 1) == ME_EPZS)
85f07f22
FB		 3382 printf("(default)");
3383 pp++;
3384 }
3738fe1a
MN		 3385 printf("\n\n");
3386 printf(
3387"Note, the names of encoders and decoders dont always match, so there are\n"
3388"several cases where the above table shows encoder only or decoder only entries\n"
3389"even though both encoding and decoding are supported for example, the h263\n"
3390"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3391"worse\n");
85f07f22
FB		 3392 exit(1);
3393}
3394
84f608f4
VM		 3395void parse_matrix_coeffs(uint16_t *dest, const char *str)
3396{
3397 int i;
3398 const char *p = str;
3399 for(i = 0;; i++) {
3400 dest[i] = atoi(p);
3401 if(i == 63)
3402 break;
3403 p = strchr(p, ',');
3404 if(!p) {
3405 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3406 exit(1);
3407 }
3408 p++;
3409 }
3410}
3411
3412void opt_inter_matrix(const char *arg)
3413{
3414 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3415 parse_matrix_coeffs(inter_matrix, arg);
3416}
3417
3418void opt_intra_matrix(const char *arg)
3419{
3420 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3421 parse_matrix_coeffs(intra_matrix, arg);
3422}
3423
e0595741
VM		 3424static void opt_target(const char *arg)
3425{
3426 int norm = -1;
3427
3428 if(!strncmp(arg, "pal-", 4)) {
3429 norm = 0;
3430 arg += 4;
3431 } else if(!strncmp(arg, "ntsc-", 5)) {
3432 norm = 1;
3433 arg += 5;
3434 } else {
3435 int fr;
3436 /* Calculate FR via float to avoid int overflow */
3437 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3438 if(fr == 25000) {
3439 norm = 0;
3440 } else if((fr == 29970) || (fr == 23976)) {
3441 norm = 1;
3442 } else {
3443 /* Try to determine PAL/NTSC by peeking in the input files */
3444 if(nb_input_files) {
3445 int i, j;
3446 for(j = 0; j < nb_input_files; j++) {
3447 for(i = 0; i < input_files[j]->nb_streams; i++) {
3448 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3449 if(c->codec_type != CODEC_TYPE_VIDEO)
3450 continue;
3451 fr = c->frame_rate * 1000 / c->frame_rate_base;
3452 if(fr == 25000) {
3453 norm = 0;
3454 break;
3455 } else if((fr == 29970) || (fr == 23976)) {
3456 norm = 1;
3457 break;
3458 }
3459 }
3460 if(norm >= 0)
3461 break;
3462 }
3463 }
3464 }
3465 if(verbose && norm >= 0)
3466 printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3467 }
3468
3469 if(norm < 0) {
3470 fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3471 fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3472 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3473 exit(1);
3474 }
3475
3476 if(!strcmp(arg, "vcd")) {
3477
3478 opt_video_codec("mpeg1video");
3479 opt_audio_codec("mp2");
3480 opt_format("vcd");
3481
3482 opt_frame_size(norm ? "352x240" : "352x288");
3483
3484 video_bit_rate = 1150000;
3485 video_rc_max_rate = 1150000;
3486 video_rc_min_rate = 1150000;
fb066639 3487 video_rc_buffer_size = 40*1024*8;
e0595741
VM		 3488
3489 audio_bit_rate = 224000;
3490 audio_sample_rate = 44100;
3491
3492 } else if(!strcmp(arg, "svcd")) {
3493
3494 opt_video_codec("mpeg2video");
3495 opt_audio_codec("mp2");
24515926 3496 opt_format("svcd");
e0595741
VM		 3497
3498 opt_frame_size(norm ? "480x480" : "480x576");
3499 opt_gop_size(norm ? "18" : "15");
3500
3501 video_bit_rate = 2040000;
3502 video_rc_max_rate = 2516000;
55bbad6f 3503 video_rc_min_rate = 0; //1145000;
fb066639 3504 video_rc_buffer_size = 224*1024*8;
baaf3f46 3505 use_scan_offset = 1;
e0595741
VM		 3506
3507 audio_bit_rate = 224000;
3508 audio_sample_rate = 44100;
3509
3510 } else if(!strcmp(arg, "dvd")) {
3511
3512 opt_video_codec("mpeg2video");
3513 opt_audio_codec("ac3");
3514 opt_format("vob");
3515
3516 opt_frame_size(norm ? "720x480" : "720x576");
3517 opt_gop_size(norm ? "18" : "15");
3518
3519 video_bit_rate = 6000000;
3520 video_rc_max_rate = 9000000;
55bbad6f 3521 video_rc_min_rate = 0; //1500000;
fb066639 3522 video_rc_buffer_size = 224*1024*8;
e0595741
VM		 3523
3524 audio_bit_rate = 448000;
3525 audio_sample_rate = 48000;
3526
3527 } else {
3528 fprintf(stderr, "Unknown target: %s\n", arg);
3529 exit(1);
3530 }
3531}
3532
242f5b0a
MN		 3533static void show_version(void)
3534{
3535 printf("ffmpeg " FFMPEG_VERSION "\n"
3536 "libavcodec %d\n"
3537 "libavformat %d\n",
3538 avcodec_build(), LIBAVFORMAT_BUILD);
3539 exit(1);
3540}
3541
85f07f22 3542const OptionDef options[] = {
02d504a7
FB		 3543 /* main options */
3544 { "L", 0, {(void*)show_license}, "show license" },
bdc4796f 3545 { "h", 0, {(void*)show_help}, "show help" },
242f5b0a 3546 { "version", 0, {(void*)show_version}, "show version" },
bdc4796f
FB		 3547 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3548 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
817b23ff 3549 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
bdc4796f
FB		 3550 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3551 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3552 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3553 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
254abc2e 3554 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
a6a92a9a 3555 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
bdc4796f 3556 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4568325a 3557 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
bdc4796f
FB		 3558 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3559 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3560 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
1d366fce 3561 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
0c9bbaec 3562 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
bdc4796f 3563 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5727b222 3564 "add timings for benchmarking" },
254abc2e 3565 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
a0663ba4 3566 "dump each input packet" },
254abc2e
FB		 3567 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3568 "when dumping packets, also dump the payload" },
79fdaa4c 3569 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
b1b77fe9
FB		 3570 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3571 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
f068206e 3572 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
e0595741 3573 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\" or \"dvd\")", "type" },
9c3d33d6 3574 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
f4f3223f 3575 { "sync", HAS_ARG | OPT_EXPERT, {(void*)opt_sync_method}, "sync method", "" },
72bd8100 3576 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
02d504a7
FB		 3577
3578 /* video options */
3579 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3580 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
02d504a7
FB		 3581 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3582 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3583 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3584 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3585 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3586 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3587 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
1ff93ffc
TK		 3588 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3589 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3590 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3591 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3592 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
02d504a7
FB		 3593 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3594 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3595 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3596 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3597 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3598 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4ea4b274
MN		 3599 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3600 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video l