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