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