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