prevent exit missuse
[libav.git] / ffmpeg.c
CommitLineData
85f07f22 1/*
115329f1 2 * FFmpeg main
01310af2 3 * Copyright (c) 2000-2003 Fabrice Bellard
85f07f22 4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
bf5af568
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
85f07f22 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
85f07f22 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
bf5af568
FB
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
85f07f22 16 *
bf5af568 17 * You should have received a copy of the GNU Lesser General Public
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
85f07f22 20 */
daf8e955 21#define HAVE_AV_CONFIG_H
d86b83f8 22#include <signal.h>
22f7a060 23#include <limits.h>
daf8e955 24#include "avformat.h"
18a54b04 25#include "swscale.h"
10d104e4 26#include "framehook.h"
6fd46414 27#include "opt.h"
f5a478f6 28#include "fifo.h"
daf8e955 29
d86b83f8
RP
30#ifdef __MINGW32__
31#include <conio.h>
32#else
85f07f22
FB
33#include <unistd.h>
34#include <fcntl.h>
35#include <sys/ioctl.h>
85f07f22 36#include <sys/time.h>
85f07f22 37#include <termios.h>
5727b222 38#include <sys/resource.h>
bdc4796f 39#endif
f3ec2d46
SG
40#ifdef CONFIG_OS2
41#include <sys/types.h>
42#include <sys/select.h>
43#include <stdlib.h>
44#endif
64c020a8 45#undef time //needed because HAVE_AV_CONFIG_H is defined on top
bf5af568 46#include <time.h>
85f07f22 47
f1cc88a5 48#include "version.h"
01310af2
FB
49#include "cmdutils.h"
50
2b18dcd0
MN
51#undef NDEBUG
52#include <assert.h>
53
8aa1e3da
MN
54#if !defined(INFINITY) && defined(HUGE_VAL)
55#define INFINITY HUGE_VAL
56#endif
85f07f22 57
c367d067
MN
58#undef exit
59
85f07f22
FB
60/* select an input stream for an output stream */
61typedef struct AVStreamMap {
62 int file_index;
63 int stream_index;
b4a3389e
WG
64 int sync_file_index;
65 int sync_stream_index;
85f07f22
FB
66} AVStreamMap;
67
0a38bafd
PB
68/** select an input file for an output file */
69typedef struct AVMetaDataMap {
70 int out_file;
71 int in_file;
72} AVMetaDataMap;
73
85f07f22
FB
74extern const OptionDef options[];
75
02d504a7
FB
76static void show_help(void);
77static void show_license(void);
637b5326 78static int opt_default(const char *opt, const char *arg);
85f07f22
FB
79
80#define MAX_FILES 20
81
82static AVFormatContext *input_files[MAX_FILES];
a6a92a9a 83static int64_t input_files_ts_offset[MAX_FILES];
85f07f22
FB
84static int nb_input_files = 0;
85
86static AVFormatContext *output_files[MAX_FILES];
87static int nb_output_files = 0;
88
89static AVStreamMap stream_maps[MAX_FILES];
90static int nb_stream_maps;
91
0a38bafd
PB
92static AVMetaDataMap meta_data_maps[MAX_FILES];
93static int nb_meta_data_maps;
94
79fdaa4c
FB
95static AVInputFormat *file_iformat;
96static AVOutputFormat *file_oformat;
55cf1959
MN
97static int frame_width = 0;
98static int frame_height = 0;
880e8ba7 99static float frame_aspect_ratio = 0;
644a9262 100static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
1ff93ffc
TK
101static int frame_padtop = 0;
102static int frame_padbottom = 0;
103static int frame_padleft = 0;
104static int frame_padright = 0;
105static int padcolor[3] = {16,128,128}; /* default to black */
ab6d194a
MN
106static int frame_topBand = 0;
107static int frame_bottomBand = 0;
108static int frame_leftBand = 0;
109static int frame_rightBand = 0;
cf7fc795 110static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
14bea432
MN
111static int frame_rate = 25;
112static int frame_rate_base = 1;
158c7f05 113static float video_qscale = 0;
9cdd6a24 114static int video_qdiff = 3;
84f608f4
VM
115static uint16_t *intra_matrix = NULL;
116static uint16_t *inter_matrix = NULL;
ac2830ec 117#if 0 //experimental, (can be removed)
3aa102be
MN
118static float video_rc_qsquish=1.0;
119static float video_rc_qmod_amp=0;
120static int video_rc_qmod_freq=0;
ac2830ec 121#endif
3aa102be
MN
122static char *video_rc_override_string=NULL;
123static char *video_rc_eq="tex^qComp";
3bea5386 124static int me_method = ME_EPZS;
85f07f22 125static int video_disable = 0;
f3356e9c 126static int video_discard = 0;
85f07f22 127static int video_codec_id = CODEC_ID_NONE;
b2a2197e 128static int video_codec_tag = 0;
85f07f22 129static int same_quality = 0;
cfcf0ffd 130static int do_deinterlace = 0;
f560dd82 131static int strict = 0;
bb198e19 132static int top_field_first = -1;
f4f3223f 133static int me_threshold = 0;
1a11cbcc 134static int intra_dc_precision = 8;
5894e1bb 135static int loop_input = 0;
8108551a 136static int loop_output = AVFMT_NOOUTPUTLOOP;
0888fd22 137static int qp_hist = 0;
85f07f22 138
85f07f22
FB
139static int intra_only = 0;
140static int audio_sample_rate = 44100;
c57c770d
JR
141#define QSCALE_NONE -99999
142static float audio_qscale = QSCALE_NONE;
85f07f22
FB
143static int audio_disable = 0;
144static int audio_channels = 1;
145static int audio_codec_id = CODEC_ID_NONE;
b2a2197e 146static int audio_codec_tag = 0;
cf7fc795
FB
147static char *audio_language = NULL;
148
149static int subtitle_codec_id = CODEC_ID_NONE;
150static char *subtitle_language = NULL;
85f07f22 151
17c88cb0
MN
152static float mux_preload= 0.5;
153static float mux_max_delay= 0.7;
2db3c638 154
0c1a9eda 155static int64_t recording_time = 0;
8831db5c 156static int64_t start_time = 0;
4568325a 157static int64_t rec_timestamp = 0;
a6a92a9a 158static int64_t input_ts_offset = 0;
85f07f22
FB
159static int file_overwrite = 0;
160static char *str_title = NULL;
161static char *str_author = NULL;
162static char *str_copyright = NULL;
163static char *str_comment = NULL;
63d5075c 164static char *str_album = NULL;
5727b222 165static int do_benchmark = 0;
a0663ba4 166static int do_hex_dump = 0;
254abc2e 167static int do_pkt_dump = 0;
43f1708f 168static int do_psnr = 0;
ce7c56c2 169static int do_vstats = 0;
5abdb4b1
FB
170static int do_pass = 0;
171static char *pass_logfilename = NULL;
1629626f
FB
172static int audio_stream_copy = 0;
173static int video_stream_copy = 0;
cf7fc795 174static int subtitle_stream_copy = 0;
986ebcdb
MN
175static int video_sync_method= 1;
176static int audio_sync_method= 0;
72bd8100 177static int copy_ts= 0;
ca80810b 178static int opt_shortest = 0; //
90ad92b3 179static int video_global_header = 0;
5abdb4b1 180
bdfcbbed
MK
181static int rate_emu = 0;
182
a5df11ab 183static int video_channel = 0;
e3ee3283 184static char *video_standard = "ntsc";
79a7c268 185
a9aa3467 186static int audio_volume = 256;
8aa3ee32 187
d9a916e2 188static int using_stdin = 0;
bee0d9e5 189static int using_vhook = 0;
f068206e 190static int verbose = 1;
9c3d33d6 191static int thread_count= 1;
b51469a0 192static int q_pressed = 0;
1008ceb3
MN
193static int64_t video_size = 0;
194static int64_t audio_size = 0;
195static int64_t extra_size = 0;
a6a92a9a
WG
196static int nb_frames_dup = 0;
197static int nb_frames_drop = 0;
6e454c38 198static int input_sync;
b6e16b86 199static int limit_filesize = 0; //
d9a916e2 200
5b6d5596 201static int pgmyuv_compatibility_hack=0;
023857be 202static int dts_delta_threshold = 10;
5b6d5596 203
18a54b04
LA
204static int sws_flags = SWS_BICUBIC;
205
8bbf6db9
MN
206const char **opt_names=NULL;
207int opt_name_count=0;
23b254fb 208AVCodecContext *avctx_opts[CODEC_TYPE_NB];
4eb72c6b 209AVFormatContext *avformat_opts;
7fc98937 210static int64_t timer_start = 0;
8bbf6db9 211
748c2fca
MN
212static AVBitStreamFilterContext *video_bitstream_filters=NULL;
213static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
214static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
5b6d5596 215
5abdb4b1 216#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
85f07f22 217
b4a3389e
WG
218struct AVInputStream;
219
85f07f22
FB
220typedef struct AVOutputStream {
221 int file_index; /* file index */
222 int index; /* stream index in the output file */
223 int source_index; /* AVInputStream index */
224 AVStream *st; /* stream in the output file */
ec5517d5
FB
225 int encoding_needed; /* true if encoding needed for this stream */
226 int frame_number;
227 /* input pts and corresponding output pts
228 for A/V sync */
b4a3389e
WG
229 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
230 struct AVInputStream *sync_ist; /* input stream to sync against */
e928649b 231 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
85f07f22 232 /* video only */
07d0cdfc 233 int video_resample;
a4d36c11 234 AVFrame pict_tmp; /* temporary image for resampling */
18a54b04
LA
235 struct SwsContext *img_resample_ctx; /* for image resampling */
236 int resample_height;
34b10a57 237
07d0cdfc 238 int video_crop;
34b10a57
D
239 int topBand; /* cropping area sizes */
240 int leftBand;
115329f1 241
07d0cdfc 242 int video_pad;
1ff93ffc
TK
243 int padtop; /* padding area sizes */
244 int padbottom;
245 int padleft;
246 int padright;
115329f1 247
85f07f22
FB
248 /* audio only */
249 int audio_resample;
250 ReSampleContext *resample; /* for audio resampling */
f5a478f6 251 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
5abdb4b1 252 FILE *logfile;
85f07f22
FB
253} AVOutputStream;
254
255typedef struct AVInputStream {
256 int file_index;
257 int index;
258 AVStream *st;
259 int discard; /* true if stream data should be discarded */
260 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
0c1a9eda 261 int64_t sample_index; /* current sample */
bdfcbbed
MK
262
263 int64_t start; /* time when read started */
264 unsigned long frame; /* current frame */
254abc2e
FB
265 int64_t next_pts; /* synthetic pts for cases where pkt.pts
266 is not defined */
e7d0374f 267 int64_t pts; /* current pts */
ff4905a5 268 int is_start; /* is 1 at the start and after a discontinuity */
85f07f22
FB
269} AVInputStream;
270
271typedef struct AVInputFile {
272 int eof_reached; /* true if eof reached */
273 int ist_index; /* index of first stream in ist_table */
274 int buffer_size; /* current total buffer size */
79fdaa4c 275 int nb_streams; /* nb streams we are aware of */
85f07f22
FB
276} AVInputFile;
277
2f30a81d 278#ifndef __MINGW32__
bdc4796f 279
85f07f22
FB
280/* init terminal so that we can grab keys */
281static struct termios oldtty;
d86b83f8 282#endif
85f07f22
FB
283
284static void term_exit(void)
285{
d86b83f8 286#ifndef __MINGW32__
85f07f22 287 tcsetattr (0, TCSANOW, &oldtty);
d86b83f8 288#endif
85f07f22
FB
289}
290
9680a722
RP
291static volatile sig_atomic_t received_sigterm = 0;
292
293static void
294sigterm_handler(int sig)
295{
296 received_sigterm = sig;
297 term_exit();
298}
299
85f07f22
FB
300static void term_init(void)
301{
d86b83f8 302#ifndef __MINGW32__
85f07f22
FB
303 struct termios tty;
304
305 tcgetattr (0, &tty);
306 oldtty = tty;
307
308 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
309 |INLCR|IGNCR|ICRNL|IXON);
310 tty.c_oflag |= OPOST;
311 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
312 tty.c_cflag &= ~(CSIZE|PARENB);
313 tty.c_cflag |= CS8;
314 tty.c_cc[VMIN] = 1;
315 tty.c_cc[VTIME] = 0;
115329f1 316
85f07f22 317 tcsetattr (0, TCSANOW, &tty);
d86b83f8
RP
318 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
319#endif
85f07f22 320
9680a722 321 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
9680a722
RP
322 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
323 /*
324 register a function to be called at normal program termination
325 */
85f07f22 326 atexit(term_exit);
9ddd71fc
FR
327#ifdef CONFIG_BEOS_NETSERVER
328 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
329#endif
85f07f22
FB
330}
331
332/* read a key without blocking */
333static int read_key(void)
334{
d86b83f8
RP
335#ifdef __MINGW32__
336 if(kbhit())
337 return(getch());
338#else
9ddd71fc 339 int n = 1;
85f07f22 340 unsigned char ch;
9ddd71fc
FR
341#ifndef CONFIG_BEOS_NETSERVER
342 struct timeval tv;
85f07f22
FB
343 fd_set rfds;
344
345 FD_ZERO(&rfds);
346 FD_SET(0, &rfds);
347 tv.tv_sec = 0;
348 tv.tv_usec = 0;
349 n = select(1, &rfds, NULL, NULL, &tv);
9ddd71fc 350#endif
85f07f22 351 if (n > 0) {
cb09b2ed
PG
352 n = read(0, &ch, 1);
353 if (n == 1)
85f07f22 354 return ch;
cb09b2ed
PG
355
356 return n;
85f07f22 357 }
d86b83f8 358#endif
85f07f22
FB
359 return -1;
360}
361
b51469a0
LS
362static int decode_interrupt_cb(void)
363{
364 return q_pressed || (q_pressed = read_key() == 'q');
365}
366
b29f97d1 367static int read_ffserver_streams(AVFormatContext *s, const char *filename)
85f07f22 368{
79fdaa4c 369 int i, err;
85f07f22
FB
370 AVFormatContext *ic;
371
79fdaa4c
FB
372 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
373 if (err < 0)
374 return err;
85f07f22
FB
375 /* copy stream format */
376 s->nb_streams = ic->nb_streams;
377 for(i=0;i<ic->nb_streams;i++) {
378 AVStream *st;
1e491e29 379
f37f8d4c 380 // FIXME: a more elegant solution is needed
e1031171 381 st = av_mallocz(sizeof(AVStream));
85f07f22 382 memcpy(st, ic->streams[i], sizeof(AVStream));
f37f8d4c
AB
383 st->codec = avcodec_alloc_context();
384 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
85f07f22
FB
385 s->streams[i] = st;
386 }
387
388 av_close_input_file(ic);
389 return 0;
390}
391
b4a3389e
WG
392static double
393get_sync_ipts(const AVOutputStream *ost)
394{
395 const AVInputStream *ist = ost->sync_ist;
396 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
397}
398
748c2fca
MN
399static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
400 while(bsfc){
401 AVPacket new_pkt= *pkt;
402 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
403 &new_pkt.data, &new_pkt.size,
404 pkt->data, pkt->size,
405 pkt->flags & PKT_FLAG_KEY);
406 if(a){
407 av_free_packet(pkt);
408 new_pkt.destruct= av_destruct_packet;
409 }
410 *pkt= new_pkt;
411
412 bsfc= bsfc->next;
413 }
414
415 av_interleaved_write_frame(s, pkt);
416}
417
817b23ff 418#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
85f07f22 419
115329f1
DB
420static void do_audio_out(AVFormatContext *s,
421 AVOutputStream *ost,
85f07f22
FB
422 AVInputStream *ist,
423 unsigned char *buf, int size)
424{
0c1a9eda 425 uint8_t *buftmp;
d66c7abc
SC
426 static uint8_t *audio_buf = NULL;
427 static uint8_t *audio_out = NULL;
558eae03 428 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
d66c7abc 429
85f07f22 430 int size_out, frame_bytes, ret;
01f4895c 431 AVCodecContext *enc= ost->st->codec;
85f07f22 432
d66c7abc
SC
433 /* SC: dynamic allocation of buffers */
434 if (!audio_buf)
435 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
436 if (!audio_out)
558eae03 437 audio_out = av_malloc(audio_out_size);
d66c7abc
SC
438 if (!audio_buf || !audio_out)
439 return; /* Should signal an error ! */
440
986ebcdb 441 if(audio_sync_method){
115329f1 442 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
f5a478f6 443 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
01f4895c
MN
444 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
445 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
ff4905a5 446
986ebcdb
MN
447 //FIXME resample delay
448 if(fabs(delta) > 50){
ff4905a5
MN
449 if(ist->is_start){
450 if(byte_delta < 0){
f41dd5aa 451 byte_delta= FFMAX(byte_delta, -size);
ff4905a5
MN
452 size += byte_delta;
453 buf -= byte_delta;
454 if(verbose > 2)
455 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
456 if(!size)
457 return;
458 ist->is_start=0;
459 }else{
460 static uint8_t *input_tmp= NULL;
461 input_tmp= av_realloc(input_tmp, byte_delta + size);
462
463 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
464 ist->is_start=0;
465 else
466 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
467
468 memset(input_tmp, 0, byte_delta);
469 memcpy(input_tmp + byte_delta, buf, size);
470 buf= input_tmp;
471 size += byte_delta;
472 if(verbose > 2)
473 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
474 }
475 }else if(audio_sync_method>1){
f66e4f5f 476 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
ff4905a5
MN
477 assert(ost->audio_resample);
478 if(verbose > 2)
479 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
949b1a13 480// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
ff4905a5
MN
481 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
482 }
115329f1 483 }
986ebcdb 484 }else
b4a3389e 485 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
f5a478f6 486 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
85f07f22
FB
487
488 if (ost->audio_resample) {
489 buftmp = audio_buf;
115329f1 490 size_out = audio_resample(ost->resample,
85f07f22 491 (short *)buftmp, (short *)buf,
01f4895c 492 size / (ist->st->codec->channels * 2));
85f07f22
FB
493 size_out = size_out * enc->channels * 2;
494 } else {
495 buftmp = buf;
496 size_out = size;
497 }
498
499 /* now encode as many frames as possible */
a0663ba4 500 if (enc->frame_size > 1) {
85f07f22 501 /* output resampled raw samples */
f5a478f6 502 av_fifo_write(&ost->fifo, buftmp, size_out);
85f07f22
FB
503
504 frame_bytes = enc->frame_size * 2 * enc->channels;
115329f1 505
f5a478f6 506 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
e928649b
MN
507 AVPacket pkt;
508 av_init_packet(&pkt);
509
115329f1 510 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
a0663ba4 511 (short *)audio_buf);
1008ceb3 512 audio_size += ret;
e928649b
MN
513 pkt.stream_index= ost->index;
514 pkt.data= audio_out;
515 pkt.size= ret;
e7902f20 516 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
c0df9d75 517 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
e928649b 518 pkt.flags |= PKT_FLAG_KEY;
748c2fca 519 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
115329f1 520
986ebcdb 521 ost->sync_opts += enc->frame_size;
85f07f22
FB
522 }
523 } else {
e928649b
MN
524 AVPacket pkt;
525 av_init_packet(&pkt);
986ebcdb 526
c43042a7 527 ost->sync_opts += size_out / (2 * enc->channels);
986ebcdb 528
a0663ba4
FB
529 /* output a pcm frame */
530 /* XXX: change encoding codec API to avoid this ? */
531 switch(enc->codec->id) {
b461b3bc
RD
532 case CODEC_ID_PCM_S32LE:
533 case CODEC_ID_PCM_S32BE:
534 case CODEC_ID_PCM_U32LE:
535 case CODEC_ID_PCM_U32BE:
536 size_out = size_out << 1;
537 break;
538 case CODEC_ID_PCM_S24LE:
539 case CODEC_ID_PCM_S24BE:
540 case CODEC_ID_PCM_U24LE:
541 case CODEC_ID_PCM_U24BE:
542 case CODEC_ID_PCM_S24DAUD:
543 size_out = size_out / 2 * 3;
544 break;
a0663ba4
FB
545 case CODEC_ID_PCM_S16LE:
546 case CODEC_ID_PCM_S16BE:
547 case CODEC_ID_PCM_U16LE:
548 case CODEC_ID_PCM_U16BE:
549 break;
550 default:
551 size_out = size_out >> 1;
552 break;
553 }
115329f1 554 ret = avcodec_encode_audio(enc, audio_out, size_out,
bb270c08 555 (short *)buftmp);
1008ceb3 556 audio_size += ret;
e928649b
MN
557 pkt.stream_index= ost->index;
558 pkt.data= audio_out;
559 pkt.size= ret;
e7902f20 560 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
c0df9d75 561 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
e928649b 562 pkt.flags |= PKT_FLAG_KEY;
748c2fca 563 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
85f07f22
FB
564 }
565}
566
10d104e4
PG
567static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
568{
569 AVCodecContext *dec;
570 AVPicture *picture2;
571 AVPicture picture_tmp;
0c1a9eda 572 uint8_t *buf = 0;
10d104e4 573
01f4895c 574 dec = ist->st->codec;
10d104e4
PG
575
576 /* deinterlace : must be done before any resize */
bee0d9e5 577 if (do_deinterlace || using_vhook) {
10d104e4
PG
578 int size;
579
580 /* create temporary picture */
581 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
582 buf = av_malloc(size);
583 if (!buf)
584 return;
115329f1 585
10d104e4
PG
586 picture2 = &picture_tmp;
587 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
588
dafc3856 589 if (do_deinterlace){
115329f1 590 if(avpicture_deinterlace(picture2, picture,
dafc3856
MN
591 dec->pix_fmt, dec->width, dec->height) < 0) {
592 /* if error, do not deinterlace */
593 av_free(buf);
594 buf = NULL;
595 picture2 = picture;
596 }
597 } else {
636d6a4a 598 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
bee0d9e5 599 }
10d104e4
PG
600 } else {
601 picture2 = picture;
602 }
603
604 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
605
606 if (picture != picture2)
607 *picture = *picture2;
608 *bufp = buf;
609}
610
ec5517d5
FB
611/* we begin to correct av delay at this threshold */
612#define AV_DELAY_MAX 0.100
85f07f22 613
115329f1
DB
614static void do_subtitle_out(AVFormatContext *s,
615 AVOutputStream *ost,
cf7fc795
FB
616 AVInputStream *ist,
617 AVSubtitle *sub,
618 int64_t pts)
619{
620 static uint8_t *subtitle_out = NULL;
621 int subtitle_out_max_size = 65536;
622 int subtitle_out_size, nb, i;
623 AVCodecContext *enc;
624 AVPacket pkt;
625
626 if (pts == AV_NOPTS_VALUE) {
627 fprintf(stderr, "Subtitle packets must have a pts\n");
628 return;
629 }
630
01f4895c 631 enc = ost->st->codec;
cf7fc795
FB
632
633 if (!subtitle_out) {
634 subtitle_out = av_malloc(subtitle_out_max_size);
635 }
636
637 /* Note: DVB subtitle need one packet to draw them and one other
638 packet to clear them */
639 /* XXX: signal it in the codec context ? */
640 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
641 nb = 2;
642 else
643 nb = 1;
644
645 for(i = 0; i < nb; i++) {
115329f1 646 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
cf7fc795 647 subtitle_out_max_size, sub);
115329f1 648
cf7fc795
FB
649 av_init_packet(&pkt);
650 pkt.stream_index = ost->index;
651 pkt.data = subtitle_out;
652 pkt.size = subtitle_out_size;
653 pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
654 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
655 /* XXX: the pts correction is handled here. Maybe handling
656 it in the codec would be better */
657 if (i == 0)
658 pkt.pts += 90 * sub->start_display_time;
659 else
660 pkt.pts += 90 * sub->end_display_time;
661 }
748c2fca 662 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
cf7fc795
FB
663 }
664}
665
8a6cb114 666static int bit_buffer_size= 1024*256;
27537106 667static uint8_t *bit_buffer= NULL;
1ff93ffc 668
115329f1
DB
669static void do_video_out(AVFormatContext *s,
670 AVOutputStream *ost,
85f07f22 671 AVInputStream *ist,
7a0f9d7e 672 AVFrame *in_picture,
986ebcdb 673 int *frame_size)
85f07f22 674{
ec5517d5 675 int nb_frames, i, ret;
07d0cdfc 676 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
18a54b04 677 AVFrame picture_crop_temp, picture_pad_temp;
cfcf0ffd 678 AVCodecContext *enc, *dec;
115329f1 679
a4d36c11 680 avcodec_get_frame_defaults(&picture_crop_temp);
07d0cdfc 681 avcodec_get_frame_defaults(&picture_pad_temp);
a4d36c11 682
01f4895c
MN
683 enc = ost->st->codec;
684 dec = ist->st->codec;
85f07f22 685
ec5517d5
FB
686 /* by default, we output a single frame */
687 nb_frames = 1;
688
204c0f48
PG
689 *frame_size = 0;
690
986ebcdb 691 if(video_sync_method){
10d104e4 692 double vdelta;
b4a3389e 693 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
e928649b
MN
694 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
695 if (vdelta < -1.1)
696 nb_frames = 0;
697 else if (vdelta > 1.1)
70122f29 698 nb_frames = lrintf(vdelta);
949b1a13 699//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
50c3dd32
MN
700 if (nb_frames == 0){
701 ++nb_frames_drop;
702 if (verbose>2)
703 fprintf(stderr, "*** drop!\n");
8300609b
MN
704 }else if (nb_frames > 1) {
705 nb_frames_dup += nb_frames;
50c3dd32 706 if (verbose>2)
8300609b 707 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
50c3dd32
MN
708 }
709 }else
b4a3389e 710 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
445f1b83 711
7ca60994 712 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
115329f1 713 if (nb_frames <= 0)
85f07f22 714 return;
ce7c56c2 715
07d0cdfc 716 if (ost->video_crop) {
636d6a4a 717 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
07d0cdfc 718 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
4e780252 719 return;
07d0cdfc
LA
720 }
721 formatted_picture = &picture_crop_temp;
18a54b04
LA
722 } else {
723 formatted_picture = in_picture;
07d0cdfc
LA
724 }
725
726 final_picture = formatted_picture;
727 padding_src = formatted_picture;
728 resampling_dst = &ost->pict_tmp;
729 if (ost->video_pad) {
730 final_picture = &ost->pict_tmp;
731 if (ost->video_resample) {
636d6a4a 732 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
07d0cdfc 733 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
4e780252 734 return;
07d0cdfc
LA
735 }
736 resampling_dst = &picture_pad_temp;
737 }
738 }
739
85f07f22 740 if (ost->video_resample) {
07d0cdfc 741 padding_src = NULL;
34b10a57 742 final_picture = &ost->pict_tmp;
18a54b04
LA
743 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
744 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
f122deb4 745 }
07d0cdfc
LA
746
747 if (ost->video_pad) {
636d6a4a 748 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
07d0cdfc
LA
749 enc->height, enc->width, enc->pix_fmt,
750 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
85f07f22 751 }
07d0cdfc 752
85f07f22 753 /* duplicates frame if needed */
ec5517d5 754 for(i=0;i<nb_frames;i++) {
e928649b
MN
755 AVPacket pkt;
756 av_init_packet(&pkt);
757 pkt.stream_index= ost->index;
758
e8750b00
FR
759 if (s->oformat->flags & AVFMT_RAWPICTURE) {
760 /* raw pictures are written as AVPicture structure to
761 avoid any copies. We support temorarily the older
762 method. */
2744ca9a 763 AVFrame* old_frame = enc->coded_frame;
bb270c08 764 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
e928649b
MN
765 pkt.data= (uint8_t *)final_picture;
766 pkt.size= sizeof(AVPicture);
e7902f20 767 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
c0df9d75 768 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
e928649b
MN
769 if(dec->coded_frame && dec->coded_frame->key_frame)
770 pkt.flags |= PKT_FLAG_KEY;
771
748c2fca 772 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
bb270c08 773 enc->coded_frame = old_frame;
e8750b00 774 } else {
492cd3a9 775 AVFrame big_picture;
a4d36c11
MN
776
777 big_picture= *final_picture;
7a0f9d7e
FB
778 /* better than nothing: use input picture interlaced
779 settings */
780 big_picture.interlaced_frame = in_picture->interlaced_frame;
23b254fb 781 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
bb198e19
MN
782 if(top_field_first == -1)
783 big_picture.top_field_first = in_picture->top_field_first;
784 else
2a8edc5d 785 big_picture.top_field_first = top_field_first;
bb198e19 786 }
7a0f9d7e 787
85f07f22
FB
788 /* handles sameq here. This is not correct because it may
789 not be a global option */
790 if (same_quality) {
1e491e29
MN
791 big_picture.quality = ist->st->quality;
792 }else
793 big_picture.quality = ost->st->quality;
f4f3223f
MN
794 if(!me_threshold)
795 big_picture.pict_type = 0;
50c3dd32 796// big_picture.pts = AV_NOPTS_VALUE;
c0df9d75
MN
797 big_picture.pts= ost->sync_opts;
798// big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
949b1a13 799//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
115329f1 800 ret = avcodec_encode_video(enc,
8a6cb114 801 bit_buffer, bit_buffer_size,
1e491e29 802 &big_picture);
4156a436
PI
803 if (ret == -1) {
804 fprintf(stderr, "Video encoding failed\n");
805 exit(1);
806 }
44429457 807 //enc->frame_number = enc->real_pict_num;
4bbc6260 808 if(ret>0){
27537106 809 pkt.data= bit_buffer;
e928649b 810 pkt.size= ret;
e7902f20 811 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
c0df9d75 812 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
949b1a13 813/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
c0df9d75
MN
814 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
815 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
50c3dd32 816
e928649b
MN
817 if(enc->coded_frame && enc->coded_frame->key_frame)
818 pkt.flags |= PKT_FLAG_KEY;
748c2fca 819 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
e928649b
MN
820 *frame_size = ret;
821 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
822 // enc->frame_number-1, enc->real_pict_num, ret,
823 // enc->pict_type);
824 /* if two pass, output log */
825 if (ost->logfile && enc->stats_out) {
826 fprintf(ost->logfile, "%s", enc->stats_out);
827 }
5abdb4b1 828 }
85f07f22 829 }
50c3dd32 830 ost->sync_opts++;
ec5517d5 831 ost->frame_number++;
85f07f22
FB
832 }
833}
834
140cb663
MN
835static double psnr(double d){
836 if(d==0) return INFINITY;
b29f97d1 837 return -10.0*log(d)/log(10.0);
140cb663
MN
838}
839
115329f1 840static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
ec5517d5 841 int frame_size)
ce7c56c2
J
842{
843 static FILE *fvstats=NULL;
ce7c56c2 844 char filename[40];
bf5af568
FB
845 time_t today2;
846 struct tm *today;
ce7c56c2
J
847 AVCodecContext *enc;
848 int frame_number;
0c1a9eda 849 int64_t ti;
ce7c56c2 850 double ti1, bitrate, avg_bitrate;
115329f1 851
ce7c56c2
J
852 if (!fvstats) {
853 today2 = time(NULL);
854 today = localtime(&today2);
2fc8ea24 855 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
ce7c56c2
J
856 today->tm_min,
857 today->tm_sec);
858 fvstats = fopen(filename,"w");
859 if (!fvstats) {
860 perror("fopen");
861 exit(1);
862 }
863 }
115329f1 864
f27a7268 865 ti = INT64_MAX;
01f4895c 866 enc = ost->st->codec;
ce7c56c2 867 if (enc->codec_type == CODEC_TYPE_VIDEO) {
ec5517d5 868 frame_number = ost->frame_number;
158c7f05 869 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
140cb663 870 if (enc->flags&CODEC_FLAG_PSNR)
492cd3a9 871 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
115329f1 872
ce7c56c2 873 fprintf(fvstats,"f_size= %6d ", frame_size);
ec5517d5 874 /* compute pts value */
c0df9d75 875 ti1 = ost->sync_opts * av_q2d(enc->time_base);
ce7c56c2
J
876 if (ti1 < 0.01)
877 ti1 = 0.01;
115329f1 878
c0df9d75 879 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1008ceb3 880 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
ce7c56c2 881 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1008ceb3 882 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
115329f1 883 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
ce7c56c2 884 }
ec5517d5
FB
885}
886
b29f97d1 887static void print_report(AVFormatContext **output_files,
bb270c08
DB
888 AVOutputStream **ost_table, int nb_ostreams,
889 int is_last_report)
ec5517d5
FB
890{
891 char buf[1024];
892 AVOutputStream *ost;
893 AVFormatContext *oc, *os;
0c1a9eda 894 int64_t total_size;
ec5517d5
FB
895 AVCodecContext *enc;
896 int frame_number, vid, i;
897 double bitrate, ti1, pts;
0c1a9eda 898 static int64_t last_time = -1;
0888fd22 899 static int qp_histogram[52];
115329f1 900
ec5517d5 901 if (!is_last_report) {
0c1a9eda 902 int64_t cur_time;
ec5517d5
FB
903 /* display the report every 0.5 seconds */
904 cur_time = av_gettime();
905 if (last_time == -1) {
906 last_time = cur_time;
907 return;
115329f1 908 }
ec5517d5
FB
909 if ((cur_time - last_time) < 500000)
910 return;
911 last_time = cur_time;
912 }
913
ce7c56c2 914
ec5517d5
FB
915 oc = output_files[0];
916
917 total_size = url_ftell(&oc->pb);
115329f1 918
ec5517d5
FB
919 buf[0] = '\0';
920 ti1 = 1e10;
921 vid = 0;
922 for(i=0;i<nb_ostreams;i++) {
923 ost = ost_table[i];
924 os = output_files[ost->file_index];
01f4895c 925 enc = ost->st->codec;
10d104e4 926 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
0ecca7a4 927 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
158c7f05 928 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
10d104e4 929 }
ec5517d5 930 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
7fc98937
LW
931 float t = (av_gettime()-timer_start) / 1000000.0;
932
ec5517d5 933 frame_number = ost->frame_number;
7fc98937
LW
934 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
935 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
936 enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
890972be 937 if(is_last_report)
0ecca7a4 938 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
0888fd22
MN
939 if(qp_hist && enc->coded_frame){
940 int j;
941 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
942 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
943 qp_histogram[qp]++;
944 for(j=0; j<32; j++)
945 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
946 }
890972be
MN
947 if (enc->flags&CODEC_FLAG_PSNR){
948 int j;
949 double error, error_sum=0;
950 double scale, scale_sum=0;
951 char type[3]= {'Y','U','V'};
0ecca7a4 952 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
890972be
MN
953 for(j=0; j<3; j++){
954 if(is_last_report){
955 error= enc->error[j];
956 scale= enc->width*enc->height*255.0*255.0*frame_number;
957 }else{
958 error= enc->coded_frame->error[j];
959 scale= enc->width*enc->height*255.0*255.0;
960 }
961 if(j) scale/=4;
962 error_sum += error;
963 scale_sum += scale;
0ecca7a4 964 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
890972be 965 }
0ecca7a4 966 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
890972be 967 }
ec5517d5
FB
968 vid = 1;
969 }
970 /* compute min output value */
9ee91c2f 971 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
5d9827bc 972 if ((pts < ti1) && (pts > 0))
ec5517d5
FB
973 ti1 = pts;
974 }
975 if (ti1 < 0.01)
976 ti1 = 0.01;
115329f1 977
f068206e
BE
978 if (verbose || is_last_report) {
979 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
115329f1
DB
980
981 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
ec5517d5
FB
982 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
983 (double)total_size / 1024, ti1, bitrate);
a6a92a9a 984
bb270c08
DB
985 if (verbose > 1)
986 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
987 nb_frames_dup, nb_frames_drop);
115329f1 988
d8019eb5
AD
989 if (verbose >= 0)
990 fprintf(stderr, "%s \r", buf);
991
ec5517d5
FB
992 fflush(stderr);
993 }
115329f1 994
1008ceb3
MN
995 if (is_last_report && verbose >= 0){
996 int64_t raw= audio_size + video_size + extra_size;
f068206e 997 fprintf(stderr, "\n");
1008ceb3
MN
998 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
999 video_size/1024.0,
1000 audio_size/1024.0,
1001 extra_size/1024.0,
1002 100.0*(total_size - raw)/raw
1003 );
1004 }
ce7c56c2
J
1005}
1006
a700a6ae
FB
1007/* pkt = NULL means EOF (needed to flush decoder buffers) */
1008static int output_packet(AVInputStream *ist, int ist_index,
1009 AVOutputStream **ost_table, int nb_ostreams,
4b85a28f 1010 const AVPacket *pkt)
a700a6ae
FB
1011{
1012 AVFormatContext *os;
1013 AVOutputStream *ost;
1014 uint8_t *ptr;
1015 int len, ret, i;
1016 uint8_t *data_buf;
1017 int data_size, got_picture;
1018 AVFrame picture;
a700a6ae 1019 void *buffer_to_free;
f038fe8b 1020 static unsigned int samples_size= 0;
78953e62 1021 static short *samples= NULL;
cf7fc795
FB
1022 AVSubtitle subtitle, *subtitle_to_free;
1023 int got_subtitle;
115329f1 1024
2b18dcd0
MN
1025 if(!pkt){
1026 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1027 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
c0df9d75 1028 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
a700a6ae 1029 } else {
a603bf8d 1030// assert(ist->pts == ist->next_pts);
a700a6ae 1031 }
115329f1 1032
a700a6ae
FB
1033 if (pkt == NULL) {
1034 /* EOF handling */
1035 ptr = NULL;
1036 len = 0;
1037 goto handle_eof;
1038 }
1039
1040 len = pkt->size;
1041 ptr = pkt->data;
1042 while (len > 0) {
1043 handle_eof:
1044 /* decode the packet if needed */
1045 data_buf = NULL; /* fail safe */
1046 data_size = 0;
cf7fc795 1047 subtitle_to_free = NULL;
a700a6ae 1048 if (ist->decoding_needed) {
01f4895c 1049 switch(ist->st->codec->codec_type) {
df84ac2e 1050 case CODEC_TYPE_AUDIO:{
115329f1 1051 if(pkt)
78953e62 1052 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
5d55e966 1053 data_size= samples_size;
a700a6ae
FB
1054 /* XXX: could avoid copy if PCM 16 bits with same
1055 endianness as CPU */
5d55e966 1056 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
a700a6ae
FB
1057 ptr, len);
1058 if (ret < 0)
1059 goto fail_decode;
1060 ptr += ret;
1061 len -= ret;
1062 /* Some bug in mpeg audio decoder gives */
1063 /* data_size < 0, it seems they are overflows */
1064 if (data_size <= 0) {
1065 /* no audio frame */
1066 continue;
1067 }
1068 data_buf = (uint8_t *)samples;
115329f1 1069 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
01f4895c 1070 (ist->st->codec->sample_rate * ist->st->codec->channels);
df84ac2e 1071 break;}
a700a6ae 1072 case CODEC_TYPE_VIDEO:
01f4895c 1073 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
a700a6ae 1074 /* XXX: allocate picture correctly */
9740beff
MN
1075 avcodec_get_frame_defaults(&picture);
1076
115329f1 1077 ret = avcodec_decode_video(ist->st->codec,
a700a6ae
FB
1078 &picture, &got_picture, ptr, len);
1079 ist->st->quality= picture.quality;
115329f1 1080 if (ret < 0)
a700a6ae
FB
1081 goto fail_decode;
1082 if (!got_picture) {
1083 /* no picture yet */
1084 goto discard_packet;
1085 }
01f4895c 1086 if (ist->st->codec->time_base.num != 0) {
115329f1 1087 ist->next_pts += ((int64_t)AV_TIME_BASE *
01f4895c
MN
1088 ist->st->codec->time_base.num) /
1089 ist->st->codec->time_base.den;
a700a6ae
FB
1090 }
1091 len = 0;
1092 break;
cf7fc795 1093 case CODEC_TYPE_SUBTITLE:
115329f1 1094 ret = avcodec_decode_subtitle(ist->st->codec,
cf7fc795
FB
1095 &subtitle, &got_subtitle, ptr, len);
1096 if (ret < 0)
a700a6ae 1097 goto fail_decode;
cf7fc795
FB
1098 if (!got_subtitle) {
1099 goto discard_packet;
a700a6ae 1100 }
cf7fc795
FB
1101 subtitle_to_free = &subtitle;
1102 len = 0;
1103 break;
1104 default:
1105 goto fail_decode;
1106 }
1107 } else {
bde0705c
LW
1108 switch(ist->st->codec->codec_type) {
1109 case CODEC_TYPE_AUDIO:
1110 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1111 (ist->st->codec->sample_rate * ist->st->codec->channels);
1112 break;
1113 case CODEC_TYPE_VIDEO:
1114 if (ist->st->codec->time_base.num != 0) {
1115 ist->next_pts += ((int64_t)AV_TIME_BASE *
1116 ist->st->codec->time_base.num) /
1117 ist->st->codec->time_base.den;
2fef0bdf 1118 }
bde0705c 1119 break;
a700a6ae 1120 }
bde0705c
LW
1121 data_buf = ptr;
1122 data_size = len;
1123 ret = len;
1124 len = 0;
1125 }
a700a6ae 1126
bde0705c
LW
1127 buffer_to_free = NULL;
1128 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1129 pre_process_video_frame(ist, (AVPicture *)&picture,
1130 &buffer_to_free);
1131 }
a700a6ae 1132
bde0705c
LW
1133 // preprocess audio (volume)
1134 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1135 if (audio_volume != 256) {
1136 short *volp;
1137 volp = samples;
1138 for(i=0;i<(data_size / sizeof(short));i++) {
1139 int v = ((*volp) * audio_volume + 128) >> 8;
1140 if (v < -32768) v = -32768;
1141 if (v > 32767) v = 32767;
1142 *volp++ = v;
7e987c33
C
1143 }
1144 }
bde0705c 1145 }
7e987c33 1146
bde0705c
LW
1147 /* frame rate emulation */
1148 if (ist->st->codec->rate_emu) {
1149 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1150 int64_t now = av_gettime() - ist->start;
1151 if (pts > now)
1152 usleep(pts - now);
a700a6ae 1153
bde0705c
LW
1154 ist->frame++;
1155 }
a700a6ae
FB
1156
1157#if 0
bde0705c
LW
1158 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1159 is the one of the next displayed one */
1160 /* XXX: add mpeg4 too ? */
1161 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1162 if (ist->st->codec->pict_type != B_TYPE) {
1163 int64_t tmp;
1164 tmp = ist->last_ip_pts;
1165 ist->last_ip_pts = ist->frac_pts.val;
1166 ist->frac_pts.val = tmp;
a700a6ae 1167 }
bde0705c 1168 }
a700a6ae 1169#endif
bde0705c
LW
1170 /* if output time reached then transcode raw format,
1171 encode packets and output them */
1172 if (start_time == 0 || ist->pts >= start_time)
1173 for(i=0;i<nb_ostreams;i++) {
1174 int frame_size;
a700a6ae 1175
bde0705c
LW
1176 ost = ost_table[i];
1177 if (ost->source_index == ist_index) {
1178 os = output_files[ost->file_index];
a700a6ae
FB
1179
1180#if 0
bde0705c
LW
1181 printf("%d: got pts=%0.3f %0.3f\n", i,
1182 (double)pkt->pts / AV_TIME_BASE,
1183 ((double)ist->pts / AV_TIME_BASE) -
1184 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
a700a6ae 1185#endif
bde0705c
LW
1186 /* set the input output pts pairs */
1187 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1188
1189 if (ost->encoding_needed) {
1190 switch(ost->st->codec->codec_type) {
1191 case CODEC_TYPE_AUDIO:
1192 do_audio_out(os, ost, ist, data_buf, data_size);
1193 break;
1194 case CODEC_TYPE_VIDEO:
1195 do_video_out(os, ost, ist, &picture, &frame_size);
1196 video_size += frame_size;
1197 if (do_vstats && frame_size)
1198 do_video_stats(os, ost, frame_size);
1199 break;
1200 case CODEC_TYPE_SUBTITLE:
1201 do_subtitle_out(os, ost, ist, &subtitle,
1202 pkt->pts);
1203 break;
1204 default:
1205 av_abort();
1206 }
1207 } else {
1208 AVFrame avframe; //FIXME/XXX remove this
1209 AVPacket opkt;
1210 av_init_packet(&opkt);
1211
1212 /* no reencoding needed : output the packet directly */
1213 /* force the input stream PTS */
1214
1215 avcodec_get_frame_defaults(&avframe);
1216 ost->st->codec->coded_frame= &avframe;
1217 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1218
1219 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1220 audio_size += data_size;
1221 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1222 video_size += data_size;
1223 ost->sync_opts++;
1224 }
1225
1226 opkt.stream_index= ost->index;
1227 if(pkt->pts != AV_NOPTS_VALUE)
1228 opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1229 else
1230 opkt.pts= AV_NOPTS_VALUE;
1231
1232 {
1233 int64_t dts;
1234 if (pkt->dts == AV_NOPTS_VALUE)
1235 dts = ist->next_pts;
6c55b27f 1236 else
bde0705c
LW
1237 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1238 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
a700a6ae 1239 }
bde0705c
LW
1240 opkt.flags= pkt->flags;
1241
1242 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1243 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1244 opkt.destruct= av_destruct_packet;
1245
1246 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1247 ost->st->codec->frame_number++;
1248 ost->frame_number++;
1249 av_free_packet(&opkt);
a700a6ae
FB
1250 }
1251 }
bde0705c
LW
1252 }
1253 av_free(buffer_to_free);
1254 /* XXX: allocate the subtitles in the codec ? */
1255 if (subtitle_to_free) {
1256 if (subtitle_to_free->rects != NULL) {
1257 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1258 av_free(subtitle_to_free->rects[i].bitmap);
1259 av_free(subtitle_to_free->rects[i].rgba_palette);
c6ec28b1 1260 }
bde0705c 1261 av_freep(&subtitle_to_free->rects);
cf7fc795 1262 }
bde0705c
LW
1263 subtitle_to_free->num_rects = 0;
1264 subtitle_to_free = NULL;
a700a6ae 1265 }
bde0705c 1266 }
a700a6ae 1267 discard_packet:
6f824977
MN
1268 if (pkt == NULL) {
1269 /* EOF handling */
115329f1 1270
6f824977
MN
1271 for(i=0;i<nb_ostreams;i++) {
1272 ost = ost_table[i];
1273 if (ost->source_index == ist_index) {
01f4895c 1274 AVCodecContext *enc= ost->st->codec;
6f824977 1275 os = output_files[ost->file_index];
115329f1 1276
01f4895c 1277 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
6f824977 1278 continue;
01f4895c 1279 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
6f824977
MN
1280 continue;
1281
1282 if (ost->encoding_needed) {
1283 for(;;) {
1284 AVPacket pkt;
cef7cc72 1285 int fifo_bytes;
6f824977
MN
1286 av_init_packet(&pkt);
1287 pkt.stream_index= ost->index;
115329f1 1288
01f4895c 1289 switch(ost->st->codec->codec_type) {
115329f1 1290 case CODEC_TYPE_AUDIO:
f5a478f6 1291 fifo_bytes = av_fifo_size(&ost->fifo);
cef7cc72
JR
1292 ret = 0;
1293 /* encode any samples remaining in fifo */
1294 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1295 int fs_tmp = enc->frame_size;
1296 enc->frame_size = fifo_bytes / (2 * enc->channels);
f5a478f6 1297 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
cef7cc72
JR
1298 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1299 }
1300 enc->frame_size = fs_tmp;
9e0db7d5
MN
1301 }
1302 if(ret <= 0) {
cef7cc72
JR
1303 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1304 }
6f824977
MN
1305 audio_size += ret;
1306 pkt.flags |= PKT_FLAG_KEY;
1307 break;
1308 case CODEC_TYPE_VIDEO:
8a6cb114 1309 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
6f824977
MN
1310 video_size += ret;
1311 if(enc->coded_frame && enc->coded_frame->key_frame)
1312 pkt.flags |= PKT_FLAG_KEY;
1313 if (ost->logfile && enc->stats_out) {
1314 fprintf(ost->logfile, "%s", enc->stats_out);
1315 }
1316 break;
1317 default:
1318 ret=-1;
1319 }
115329f1 1320
6f824977
MN
1321 if(ret<=0)
1322 break;
27537106 1323 pkt.data= bit_buffer;
6f824977 1324 pkt.size= ret;
e7902f20 1325 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
c0df9d75 1326 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
748c2fca 1327 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
6f824977
MN
1328 }
1329 }
1330 }
1331 }
1332 }
115329f1 1333
a700a6ae
FB
1334 return 0;
1335 fail_decode:
1336 return -1;
1337}
1338
1339
85f07f22
FB
1340/*
1341 * The following code is the main loop of the file converter
1342 */
1343static int av_encode(AVFormatContext **output_files,
1344 int nb_output_files,
1345 AVFormatContext **input_files,
1346 int nb_input_files,
1347 AVStreamMap *stream_maps, int nb_stream_maps)
1348{
445f1b83 1349 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
85f07f22
FB
1350 AVFormatContext *is, *os;
1351 AVCodecContext *codec, *icodec;
1352 AVOutputStream *ost, **ost_table = NULL;
1353 AVInputStream *ist, **ist_table = NULL;
bdc4796f 1354 AVInputFile *file_table;
cb09b2ed 1355 int key;
bdc4796f 1356
51bd4565 1357 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
bdc4796f
FB
1358 if (!file_table)
1359 goto fail;
115329f1 1360
85f07f22
FB
1361 /* input stream init */
1362 j = 0;
1363 for(i=0;i<nb_input_files;i++) {
1364 is = input_files[i];
1365 file_table[i].ist_index = j;
79fdaa4c 1366 file_table[i].nb_streams = is->nb_streams;
85f07f22
FB
1367 j += is->nb_streams;
1368 }
1369 nb_istreams = j;
1370
1371 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1372 if (!ist_table)
bdc4796f 1373 goto fail;
115329f1 1374
85f07f22
FB
1375 for(i=0;i<nb_istreams;i++) {
1376 ist = av_mallocz(sizeof(AVInputStream));
1377 if (!ist)
1378 goto fail;
1379 ist_table[i] = ist;
1380 }
1381 j = 0;
1382 for(i=0;i<nb_input_files;i++) {
1383 is = input_files[i];
1384 for(k=0;k<is->nb_streams;k++) {
1385 ist = ist_table[j++];
1386 ist->st = is->streams[k];
1387 ist->file_index = i;
1388 ist->index = k;
1389 ist->discard = 1; /* the stream is discarded by default
1390 (changed later) */
bdfcbbed 1391
01f4895c 1392 if (ist->st->codec->rate_emu) {
bdfcbbed
MK
1393 ist->start = av_gettime();
1394 ist->frame = 0;
1395 }
85f07f22
FB
1396 }
1397 }
1398
1399 /* output stream init */
1400 nb_ostreams = 0;
1401 for(i=0;i<nb_output_files;i++) {
1402 os = output_files[i];
8a7bde1c
BC
1403 if (!os->nb_streams) {
1404 fprintf(stderr, "Output file does not contain any stream\n");
1405 exit(1);
1406 }
85f07f22
FB
1407 nb_ostreams += os->nb_streams;
1408 }
1409 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1410 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1411 exit(1);
1412 }
1413
bd073980
BF
1414 /* Sanity check the mapping args -- do the input files & streams exist? */
1415 for(i=0;i<nb_stream_maps;i++) {
1416 int fi = stream_maps[i].file_index;
1417 int si = stream_maps[i].stream_index;
115329f1 1418
bd073980
BF
1419 if (fi < 0 || fi > nb_input_files - 1 ||
1420 si < 0 || si > file_table[fi].nb_streams - 1) {
1421 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1422 exit(1);
1423 }
b4a3389e
WG
1424 fi = stream_maps[i].sync_file_index;
1425 si = stream_maps[i].sync_stream_index;
1426 if (fi < 0 || fi > nb_input_files - 1 ||
1427 si < 0 || si > file_table[fi].nb_streams - 1) {
1428 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1429 exit(1);
1430 }
bd073980 1431 }
115329f1 1432
85f07f22
FB
1433 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1434 if (!ost_table)
1435 goto fail;
1436 for(i=0;i<nb_ostreams;i++) {
1437 ost = av_mallocz(sizeof(AVOutputStream));
1438 if (!ost)
1439 goto fail;
1440 ost_table[i] = ost;
1441 }
115329f1 1442
85f07f22
FB
1443 n = 0;
1444 for(k=0;k<nb_output_files;k++) {
1445 os = output_files[k];
1446 for(i=0;i<os->nb_streams;i++) {
1447 int found;
1448 ost = ost_table[n++];
1449 ost->file_index = k;
1450 ost->index = i;
1451 ost->st = os->streams[i];
1452 if (nb_stream_maps > 0) {
115329f1 1453 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
85f07f22 1454 stream_maps[n-1].stream_index;
115329f1 1455
bd073980 1456 /* Sanity check that the stream types match */
01f4895c 1457 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
bd073980
BF
1458 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1459 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1460 ost->file_index, ost->index);
1461 exit(1);
1462 }
115329f1 1463
85f07f22
FB
1464 } else {
1465 /* get corresponding input stream index : we select the first one with the right type */
1466 found = 0;
1467 for(j=0;j<nb_istreams;j++) {
1468 ist = ist_table[j];
115329f1 1469 if (ist->discard &&
01f4895c 1470 ist->st->codec->codec_type == ost->st->codec->codec_type) {
85f07f22
FB
1471 ost->source_index = j;
1472 found = 1;
c19e76ce 1473 break;
85f07f22
FB
1474 }
1475 }
115329f1 1476
85f07f22
FB
1477 if (!found) {
1478 /* try again and reuse existing stream */
1479 for(j=0;j<nb_istreams;j++) {
1480 ist = ist_table[j];
01f4895c 1481 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
85f07f22
FB
1482 ost->source_index = j;
1483 found = 1;
1484 }
1485 }
1486 if (!found) {
1487 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1488 ost->file_index, ost->index);
1489 exit(1);
1490 }
1491 }
1492 }
1493 ist = ist_table[ost->source_index];
1494 ist->discard = 0;
b4a3389e
WG
1495 ost->sync_ist = (nb_stream_maps > 0) ?
1496 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1497 stream_maps[n-1].sync_stream_index] : ist;
85f07f22
FB
1498 }
1499 }
1500
85f07f22
FB
1501 /* for each output stream, we compute the right encoding parameters */
1502 for(i=0;i<nb_ostreams;i++) {
1503 ost = ost_table[i];
1504 ist = ist_table[ost->source_index];
1505
01f4895c
MN
1506 codec = ost->st->codec;
1507 icodec = ist->st->codec;
85f07f22 1508
1629626f
FB
1509 if (ost->st->stream_copy) {
1510 /* if stream_copy is selected, no need to decode or encode */
1511 codec->codec_id = icodec->codec_id;
1512 codec->codec_type = icodec->codec_type;
b2a2197e 1513 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1629626f 1514 codec->bit_rate = icodec->bit_rate;
dffbfd06
MN
1515 codec->extradata= icodec->extradata;
1516 codec->extradata_size= icodec->extradata_size;
4408e75e 1517 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
d29de719
MN
1518 codec->time_base = icodec->time_base;
1519 else
1520 codec->time_base = ist->st->time_base;
1629626f
FB
1521 switch(codec->codec_type) {
1522 case CODEC_TYPE_AUDIO:
1523 codec->sample_rate = icodec->sample_rate;
1524 codec->channels = icodec->channels;
0a3b0447 1525 codec->frame_size = icodec->frame_size;
c1344911 1526 codec->block_align= icodec->block_align;
1629626f
FB
1527 break;
1528 case CODEC_TYPE_VIDEO:
8d74e55b
MD
1529 if(using_vhook) {
1530 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1531 exit(1);
1532 }
9df3437f 1533 codec->pix_fmt = icodec->pix_fmt;
1629626f
FB
1534 codec->width = icodec->width;
1535 codec->height = icodec->height;
ff8cc24b 1536 codec->has_b_frames = icodec->has_b_frames;
1629626f 1537 break;
cf7fc795
FB
1538 case CODEC_TYPE_SUBTITLE:
1539 break;
1629626f
FB
1540 default:
1541 av_abort();
1542 }
1543 } else {
1544 switch(codec->codec_type) {
1545 case CODEC_TYPE_AUDIO:
f5a478f6 1546 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
85f07f22 1547 goto fail;
115329f1 1548
85f07f22
FB
1549 if (codec->channels == icodec->channels &&
1550 codec->sample_rate == icodec->sample_rate) {
1551 ost->audio_resample = 0;
1552 } else {
e0d2714a 1553 if (codec->channels != icodec->channels &&
23c99253
MN
1554 (icodec->codec_id == CODEC_ID_AC3 ||
1555 icodec->codec_id == CODEC_ID_DTS)) {
1556 /* Special case for 5:1 AC3 and DTS input */
e0d2714a 1557 /* and mono or stereo output */
6dc96cb0
J
1558 /* Request specific number of channels */
1559 icodec->channels = codec->channels;
1560 if (codec->sample_rate == icodec->sample_rate)
1561 ost->audio_resample = 0;
1562 else {
1563 ost->audio_resample = 1;
6dc96cb0 1564 }
e0d2714a 1565 } else {
115329f1 1566 ost->audio_resample = 1;
986ebcdb
MN
1567 }
1568 }
ff4905a5 1569 if(audio_sync_method>1)
986ebcdb
MN
1570 ost->audio_resample = 1;
1571
1572 if(ost->audio_resample){
1573 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1574 codec->sample_rate, icodec->sample_rate);
1575 if(!ost->resample){
1576 printf("Can't resample. Aborting.\n");
1577 av_abort();
e0d2714a 1578 }
85f07f22
FB
1579 }
1580 ist->decoding_needed = 1;
1581 ost->encoding_needed = 1;
1629626f
FB
1582 break;
1583 case CODEC_TYPE_VIDEO:
c3f11d19
LA
1584 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1585 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1586 ost->video_resample = ((codec->width != icodec->width -
1587 (frame_leftBand + frame_rightBand) +
1588 (frame_padleft + frame_padright)) ||
1589 (codec->height != icodec->height -
1590 (frame_topBand + frame_bottomBand) +
18a54b04
LA
1591 (frame_padtop + frame_padbottom)) ||
1592 (codec->pix_fmt != icodec->pix_fmt));
c3f11d19 1593 if (ost->video_crop) {
34b10a57
D
1594 ost->topBand = frame_topBand;
1595 ost->leftBand = frame_leftBand;
c3f11d19
LA
1596 }
1597 if (ost->video_pad) {
1ff93ffc
TK
1598 ost->padtop = frame_padtop;
1599 ost->padleft = frame_padleft;
1600 ost->padbottom = frame_padbottom;
1601 ost->padright = frame_padright;
c3f11d19
LA
1602 if (!ost->video_resample) {
1603 avcodec_get_frame_defaults(&ost->pict_tmp);
1604 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1605 codec->width, codec->height ) )
1606 goto fail;
1607 }
1608 }
1609 if (ost->video_resample) {
2de28abb 1610 avcodec_get_frame_defaults(&ost->pict_tmp);
18a54b04 1611 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2caa92d9 1612 codec->width, codec->height ) )
7a168618 1613 exit(1);
85f07f22 1614
18a54b04
LA
1615 ost->img_resample_ctx = sws_getContext(
1616 icodec->width - (frame_leftBand + frame_rightBand),
1617 icodec->height - (frame_topBand + frame_bottomBand),
1618 icodec->pix_fmt,
07d0cdfc
LA
1619 codec->width - (frame_padleft + frame_padright),
1620 codec->height - (frame_padtop + frame_padbottom),
18a54b04
LA
1621 codec->pix_fmt,
1622 sws_flags, NULL, NULL, NULL);
0b50ac8a
LA
1623 if (ost->img_resample_ctx == NULL) {
1624 fprintf(stderr, "Cannot get resampling context\n");
1625 exit(1);
1626 }
18a54b04 1627 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
85f07f22
FB
1628 }
1629 ost->encoding_needed = 1;
1630 ist->decoding_needed = 1;
1629626f 1631 break;
cf7fc795
FB
1632 case CODEC_TYPE_SUBTITLE:
1633 ost->encoding_needed = 1;
1634 ist->decoding_needed = 1;
1635 break;
1629626f
FB
1636 default:
1637 av_abort();
cf7fc795 1638 break;
85f07f22 1639 }
1629626f 1640 /* two pass mode */
115329f1 1641 if (ost->encoding_needed &&
1629626f
FB
1642 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1643 char logfilename[1024];
1644 FILE *f;
1645 int size;
1646 char *logbuffer;
115329f1
DB
1647
1648 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1649 pass_logfilename ?
1629626f
FB
1650 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1651 if (codec->flags & CODEC_FLAG_PASS1) {
1652 f = fopen(logfilename, "w");
1653 if (!f) {
1654 perror(logfilename);
1655 exit(1);
1656 }
1657 ost->logfile = f;
1658 } else {
1659 /* read the log file */
1660 f = fopen(logfilename, "r");
1661 if (!f) {
1662 perror(logfilename);
1663 exit(1);
1664 }
1665 fseek(f, 0, SEEK_END);
1666 size = ftell(f);
1667 fseek(f, 0, SEEK_SET);
1668 logbuffer = av_malloc(size + 1);
1669 if (!logbuffer) {
1670 fprintf(stderr, "Could not allocate log buffer\n");
1671 exit(1);
1672 }
4776fa92 1673 size = fread(logbuffer, 1, size, f);
1629626f
FB
1674 fclose(f);
1675 logbuffer[size] = '\0';
1676 codec->stats_in = logbuffer;
5abdb4b1 1677 }
5abdb4b1
FB
1678 }
1679 }
8a6cb114
MN
1680 if(codec->codec_type == CODEC_TYPE_VIDEO){
1681 int size= codec->width * codec->height;
1682 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1683 }
85f07f22
FB
1684 }
1685
8a6cb114
MN
1686 if (!bit_buffer)
1687 bit_buffer = av_malloc(bit_buffer_size);
1688 if (!bit_buffer)
1689 goto fail;
1690
1629626f
FB
1691 /* dump the file output parameters - cannot be done before in case
1692 of stream copy */
1693 for(i=0;i<nb_output_files;i++) {
1694 dump_format(output_files[i], i, output_files[i]->filename, 1);
1695 }
1696
1697 /* dump the stream mapping */
d8019eb5
AD
1698 if (verbose >= 0) {
1699 fprintf(stderr, "Stream mapping:\n");
1700 for(i=0;i<nb_ostreams;i++) {
1701 ost = ost_table[i];
b4a3389e 1702 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
d8019eb5
AD
1703 ist_table[ost->source_index]->file_index,
1704 ist_table[ost->source_index]->index,
115329f1 1705 ost->file_index,
d8019eb5 1706 ost->index);
b4a3389e
WG
1707 if (ost->sync_ist != ist_table[ost->source_index])
1708 fprintf(stderr, " [sync #%d.%d]",
1709 ost->sync_ist->file_index,
1710 ost->sync_ist->index);
1711 fprintf(stderr, "\n");
d8019eb5 1712 }
1629626f
FB
1713 }
1714
85f07f22
FB
1715 /* open each encoder */
1716 for(i=0;i<nb_ostreams;i++) {
1717 ost = ost_table[i];
1718 if (ost->encoding_needed) {
1719 AVCodec *codec;
01f4895c 1720 codec = avcodec_find_encoder(ost->st->codec->codec_id);
85f07f22 1721 if (!codec) {
115329f1 1722 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
85f07f22
FB
1723 ost->file_index, ost->index);
1724 exit(1);
1725 }
01f4895c 1726 if (avcodec_open(ost->st->codec, codec) < 0) {
115329f1 1727 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
85f07f22
FB
1728 ost->file_index, ost->index);
1729 exit(1);
1730 }
01f4895c 1731 extra_size += ost->st->codec->extradata_size;
85f07f22
FB
1732 }
1733 }
1734
1735 /* open each decoder */
1736 for(i=0;i<nb_istreams;i++) {
1737 ist = ist_table[i];
1738 if (ist->decoding_needed) {
1739 AVCodec *codec;
01f4895c 1740 codec = avcodec_find_decoder(ist->st->codec->codec_id);
85f07f22 1741 if (!codec) {
115329f1 1742 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
01f4895c 1743 ist->st->codec->codec_id, ist->file_index, ist->index);
85f07f22
FB
1744 exit(1);
1745 }
01f4895c 1746 if (avcodec_open(ist->st->codec, codec) < 0) {
115329f1 1747 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
85f07f22
FB
1748 ist->file_index, ist->index);
1749 exit(1);
1750 }
01f4895c
MN
1751 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1752 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
85f07f22
FB
1753 }
1754 }
1755
1756 /* init pts */
1757 for(i=0;i<nb_istreams;i++) {
1758 ist = ist_table[i];
bb270c08 1759 is = input_files[ist->file_index];
e7d0374f 1760 ist->pts = 0;
c0df9d75 1761 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
115329f1 1762 if(ist->st->start_time == AV_NOPTS_VALUE)
bd1b79a1 1763 ist->next_pts=0;
fdb86eb1
MN
1764 if(input_files_ts_offset[ist->file_index])
1765 ist->next_pts= AV_NOPTS_VALUE;
ff4905a5 1766 ist->is_start = 1;
85f07f22 1767 }
bd1b79a1 1768
0a38bafd
PB
1769 /* set meta data information from input file if required */
1770 for (i=0;i<nb_meta_data_maps;i++) {
1771 AVFormatContext *out_file;
1772 AVFormatContext *in_file;
1773
1774 int out_file_index = meta_data_maps[i].out_file;
1775 int in_file_index = meta_data_maps[i].in_file;
1776 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1777 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
8fa36ae0 1778 ret = AVERROR(EINVAL);
0a38bafd
PB
1779 goto fail;
1780 }
1781 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1782 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
8fa36ae0 1783 ret = AVERROR(EINVAL);
0a38bafd 1784 goto fail;
115329f1
DB
1785 }
1786
0a38bafd
PB
1787 out_file = output_files[out_file_index];
1788 in_file = input_files[in_file_index];
1789
1790 strcpy(out_file->title, in_file->title);
1791 strcpy(out_file->author, in_file->author);
1792 strcpy(out_file->copyright, in_file->copyright);
1793 strcpy(out_file->comment, in_file->comment);
1794 strcpy(out_file->album, in_file->album);
1795 out_file->year = in_file->year;
1796 out_file->track = in_file->track;
1797 strcpy(out_file->genre, in_file->genre);
1798 }
115329f1 1799
85f07f22
FB
1800 /* open files and write file headers */
1801 for(i=0;i<nb_output_files;i++) {
1802 os = output_files[i];
79fdaa4c 1803 if (av_write_header(os) < 0) {
65bf3c53 1804 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
8fa36ae0 1805 ret = AVERROR(EINVAL);
a38469e1
FB
1806 goto fail;
1807 }
85f07f22
FB
1808 }
1809
d8019eb5 1810 if ( !using_stdin && verbose >= 0) {
d9a916e2 1811 fprintf(stderr, "Press [q] to stop encoding\n");
b51469a0
LS
1812 url_set_interrupt_cb(decode_interrupt_cb);
1813 }
a38469e1
FB
1814 term_init();
1815
cb09b2ed 1816 key = -1;
7fc98937 1817 timer_start = av_gettime();
51bd4565 1818
d9a916e2 1819 for(; received_sigterm == 0;) {
85f07f22
FB
1820 int file_index, ist_index;
1821 AVPacket pkt;
a9aeda81
PB
1822 double ipts_min;
1823 double opts_min;
23ffe323 1824
85f07f22 1825 redo:
a9aeda81
PB
1826 ipts_min= 1e100;
1827 opts_min= 1e100;
a38469e1 1828 /* if 'q' pressed, exits */
d9a916e2 1829 if (!using_stdin) {
b51469a0
LS
1830 if (q_pressed)
1831 break;
cb09b2ed
PG
1832 /* read_key() returns 0 on EOF */
1833 key = read_key();
1834 if (key == 'q')
1835 break;
1836 }
a38469e1 1837
ec5517d5
FB
1838 /* select the stream that we must read now by looking at the
1839 smallest output pts */
85f07f22 1840 file_index = -1;
ec5517d5 1841 for(i=0;i<nb_ostreams;i++) {
23ffe323 1842 double ipts, opts;
ec5517d5
FB
1843 ost = ost_table[i];
1844 os = output_files[ost->file_index];
1845 ist = ist_table[ost->source_index];
01f4895c
MN
1846 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1847 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
23ffe323 1848 else
c0df9d75 1849 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
23ffe323
MN
1850 ipts = (double)ist->pts;
1851 if (!file_table[ist->file_index].eof_reached){
1852 if(ipts < ipts_min) {
1853 ipts_min = ipts;
1854 if(input_sync ) file_index = ist->file_index;
1855 }
1856 if(opts < opts_min) {
1857 opts_min = opts;
1858 if(!input_sync) file_index = ist->file_index;
1859 }
85f07f22 1860 }
01f4895c 1861 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
7ca60994
MN
1862 file_index= -1;
1863 break;
1864 }
85f07f22
FB
1865 }
1866 /* if none, if is finished */
51bd4565 1867 if (file_index < 0) {
85f07f22 1868 break;
ec5517d5
FB
1869 }
1870
85f07f22 1871 /* finish if recording time exhausted */
23ffe323 1872 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
85f07f22 1873 break;
ec5517d5 1874
b6e16b86
C
1875 /* finish if limit size exhausted */
1876 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1877 break;
1878
254abc2e 1879 /* read a frame from it and output it in the fifo */
85f07f22 1880 is = input_files[file_index];
254abc2e 1881 if (av_read_frame(is, &pkt) < 0) {
85f07f22 1882 file_table[file_index].eof_reached = 1;
ca80810b 1883 if (opt_shortest) break; else continue; //
85f07f22 1884 }
303e50e6 1885
254abc2e 1886 if (do_pkt_dump) {
750f0e1f 1887 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
817b23ff 1888 }
79fdaa4c
FB
1889 /* the following test is needed in case new streams appear
1890 dynamically in stream : we ignore them */
1891 if (pkt.stream_index >= file_table[file_index].nb_streams)
bf5af568 1892 goto discard_packet;
85f07f22
FB
1893 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1894 ist = ist_table[ist_index];
bf5af568
FB
1895 if (ist->discard)
1896 goto discard_packet;
85f07f22 1897
949b1a13 1898// fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
fdb86eb1 1899 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
c0df9d75 1900 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
c26abfa5 1901 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
72bd8100
MN
1902 input_files_ts_offset[ist->file_index]-= delta;
1903 if (verbose > 2)
4733abcb 1904 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
72bd8100
MN
1905 for(i=0; i<file_table[file_index].nb_streams; i++){
1906 int index= file_table[file_index].ist_index + i;
1907 ist_table[index]->next_pts += delta;
ff4905a5 1908 ist_table[index]->is_start=1;
72bd8100
MN
1909 }
1910 }
1911 }
1912
8831db5c 1913 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
a700a6ae 1914 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
d8019eb5
AD
1915
1916 if (verbose >= 0)
1917 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1918 ist->file_index, ist->index);
1919
a700a6ae
FB
1920 av_free_packet(&pkt);
1921 goto redo;
fe08925f 1922 }
cf7fc795 1923
bf5af568 1924 discard_packet:
85f07f22 1925 av_free_packet(&pkt);
115329f1 1926
ec5517d5
FB
1927 /* dump report by using the output first video and audio streams */
1928 print_report(output_files, ost_table, nb_ostreams, 0);
85f07f22 1929 }
a700a6ae
FB
1930
1931 /* at the end of stream, we must flush the decoder buffers */
1932 for(i=0;i<nb_istreams;i++) {
1933 ist = ist_table[i];
1934 if (ist->decoding_needed) {
1935 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1936 }
1937 }
1938
a38469e1 1939 term_exit();
85f07f22 1940
c4e37247
MN
1941 /* write the trailer if needed and close file */
1942 for(i=0;i<nb_output_files;i++) {
1943 os = output_files[i];
1944 av_write_trailer(os);
1945 }
1946
37f5cd5a
MN
1947 /* dump report by using the first video and audio streams */
1948 print_report(output_files, ost_table, nb_ostreams, 1);
1949
85f07f22
FB
1950 /* close each encoder */
1951 for(i=0;i<nb_ostreams;i++) {
1952 ost = ost_table[i];
1953 if (ost->encoding_needed) {
01f4895c
MN
1954 av_freep(&ost->st->codec->stats_in);
1955 avcodec_close(ost->st->codec);
85f07f22
FB
1956 }
1957 }
115329f1 1958
85f07f22
FB
1959 /* close each decoder */
1960 for(i=0;i<nb_istreams;i++) {
1961 ist = ist_table[i];
1962 if (ist->decoding_needed) {
01f4895c 1963 avcodec_close(ist->st->codec);
85f07f22
FB
1964 }
1965 }
85f07f22 1966
85f07f22 1967 /* finished ! */
115329f1 1968
85f07f22
FB
1969 ret = 0;
1970 fail1:
83b07470 1971 av_freep(&bit_buffer);
0f1578af 1972 av_free(file_table);
bdc4796f 1973
85f07f22
FB
1974 if (ist_table) {
1975 for(i=0;i<nb_istreams;i++) {
1976 ist = ist_table[i];
0f1578af 1977 av_free(ist);
85f07f22 1978 }
0f1578af 1979 av_free(ist_table);
85f07f22
FB
1980 }
1981 if (ost_table) {
1982 for(i=0;i<nb_ostreams;i++) {
1983 ost = ost_table[i];
1984 if (ost) {
5abdb4b1
FB
1985 if (ost->logfile) {
1986 fclose(ost->logfile);
1987 ost->logfile = NULL;
1988 }
f5a478f6
RS
1989 av_fifo_free(&ost->fifo); /* works even if fifo is not
1990 initialized but set to zero */
0f1578af 1991 av_free(ost->pict_tmp.data[0]);
85f07f22 1992 if (ost->video_resample)
18a54b04 1993 sws_freeContext(ost->img_resample_ctx);
85f07f22
FB
1994 if (ost->audio_resample)
1995 audio_resample_close(ost->resample);
0f1578af 1996 av_free(ost);
85f07f22
FB
1997 }
1998 }
0f1578af 1999 av_free(ost_table);
85f07f22
FB
2000 }
2001 return ret;
2002 fail:
8fa36ae0 2003 ret = AVERROR(ENOMEM);
85f07f22
FB
2004 goto fail1;
2005}
2006
2007#if 0
2008int file_read(const char *filename)
2009{
2010 URLContext *h;
2011 unsigned char buffer[1024];
2012 int len, i;
2013
2014 if (url_open(&h, filename, O_RDONLY) < 0) {
2015 printf("could not open '%s'\n", filename);
2016 return -1;
2017 }
2018 for(;;) {
2019 len = url_read(h, buffer, sizeof(buffer));
2020 if (len <= 0)
2021 break;
2022 for(i=0;i<len;i++) putchar(buffer[i]);
2023 }
2024 url_close(h);
2025 return 0;
2026}
2027#endif
2028
b29f97d1 2029static void opt_format(const char *arg)
85f07f22 2030{
817b23ff
FB
2031 /* compatibility stuff for pgmyuv */
2032 if (!strcmp(arg, "pgmyuv")) {
5b6d5596 2033 pgmyuv_compatibility_hack=1;
9286699a 2034// opt_image_format(arg);
5b6d5596 2035 arg = "image2";
17ceb4f9 2036 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
817b23ff
FB
2037 }
2038
79fdaa4c
FB
2039 file_iformat = av_find_input_format(arg);
2040 file_oformat = guess_format(arg, NULL, NULL);
2041 if (!file_iformat && !file_oformat) {
2042 fprintf(stderr, "Unknown input or output format: %s\n", arg);
85f07f22
FB
2043 exit(1);
2044 }
85f07f22
FB
2045}
2046
b29f97d1 2047static void opt_video_rc_eq(char *arg)
3aa102be
MN
2048{
2049 video_rc_eq = arg;
2050}
2051
b29f97d1 2052static void opt_video_rc_override_string(char *arg)
ac2830ec
MN
2053{
2054 video_rc_override_string = arg;
2055}
2056
f4f3223f
MN
2057static void opt_me_threshold(const char *arg)
2058{
2059 me_threshold = atoi(arg);
2060}
2061
f068206e
BE
2062static void opt_verbose(const char *arg)
2063{
2064 verbose = atoi(arg);
ab1c6dc9 2065 av_log_level = atoi(arg);
f068206e
BE
2066}
2067
b29f97d1 2068static void opt_frame_rate(const char *arg)
85f07f22 2069{
445f1b83
RS
2070 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2071 fprintf(stderr, "Incorrect frame rate\n");
bb270c08 2072 exit(1);
445f1b83 2073 }
85f07f22
FB
2074}
2075
b29f97d1 2076static void opt_frame_crop_top(const char *arg)
ab6d194a 2077{
115329f1 2078 frame_topBand = atoi(arg);
ab6d194a
MN
2079 if (frame_topBand < 0) {
2080 fprintf(stderr, "Incorrect top crop size\n");
2081 exit(1);
2082 }
2083 if ((frame_topBand % 2) != 0) {
2084 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2085 exit(1);
2086 }
2087 if ((frame_topBand) >= frame_height){
bb270c08 2088 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2089 exit(1);
2090 }
2091 frame_height -= frame_topBand;
2092}
2093
b29f97d1 2094static void opt_frame_crop_bottom(const char *arg)
ab6d194a
MN
2095{
2096 frame_bottomBand = atoi(arg);
2097 if (frame_bottomBand < 0) {
2098 fprintf(stderr, "Incorrect bottom crop size\n");
2099 exit(1);
2100 }
2101 if ((frame_bottomBand % 2) != 0) {
2102 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
115329f1 2103 exit(1);
ab6d194a
MN
2104 }
2105 if ((frame_bottomBand) >= frame_height){
bb270c08 2106 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2107 exit(1);
2108 }
2109 frame_height -= frame_bottomBand;
2110}
2111
b29f97d1 2112static void opt_frame_crop_left(const char *arg)
ab6d194a
MN
2113{
2114 frame_leftBand = atoi(arg);
2115 if (frame_leftBand < 0) {
2116 fprintf(stderr, "Incorrect left crop size\n");
2117 exit(1);
2118 }
2119 if ((frame_leftBand % 2) != 0) {
2120 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2121 exit(1);
2122 }
2123 if ((frame_leftBand) >= frame_width){
bb270c08 2124 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2125 exit(1);
2126 }
2127 frame_width -= frame_leftBand;
2128}
2129
b29f97d1 2130static void opt_frame_crop_right(const char *arg)
ab6d194a
MN
2131{
2132 frame_rightBand = atoi(arg);
2133 if (frame_rightBand < 0) {
2134 fprintf(stderr, "Incorrect right crop size\n");
2135 exit(1);
2136 }
2137 if ((frame_rightBand % 2) != 0) {
2138 fprintf(stderr, "Right crop size must be a multiple of 2\n");
115329f1 2139 exit(1);
ab6d194a
MN
2140 }
2141 if ((frame_rightBand) >= frame_width){
bb270c08 2142 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2143 exit(1);
2144 }
2145 frame_width -= frame_rightBand;
2146}
2147
b29f97d1 2148static void opt_frame_size(const char *arg)
85f07f22 2149{
445f1b83 2150 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
85f07f22
FB
2151 fprintf(stderr, "Incorrect frame size\n");
2152 exit(1);
2153 }
2154 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2155 fprintf(stderr, "Frame size must be a multiple of 2\n");
2156 exit(1);
2157 }
2158}
2159
1ff93ffc
TK
2160
2161#define SCALEBITS 10
2162#define ONE_HALF (1 << (SCALEBITS - 1))
bb270c08 2163#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
1ff93ffc
TK
2164
2165#define RGB_TO_Y(r, g, b) \
2166((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2167 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2168
2169#define RGB_TO_U(r1, g1, b1, shift)\
2170(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2171 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2172
2173#define RGB_TO_V(r1, g1, b1, shift)\
2174(((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2175 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2176
2177static void opt_pad_color(const char *arg) {
2178 /* Input is expected to be six hex digits similar to
2179 how colors are expressed in html tags (but without the #) */
2180 int rgb = strtol(arg, NULL, 16);
2181 int r,g,b;
115329f1
DB
2182
2183 r = (rgb >> 16);
1ff93ffc
TK
2184 g = ((rgb >> 8) & 255);
2185 b = (rgb & 255);
2186
2187 padcolor[0] = RGB_TO_Y(r,g,b);
2188 padcolor[1] = RGB_TO_U(r,g,b,0);
2189 padcolor[2] = RGB_TO_V(r,g,b,0);
2190}
2191
2192static void opt_frame_pad_top(const char *arg)
2193{
115329f1 2194 frame_padtop = atoi(arg);
1ff93ffc
TK
2195 if (frame_padtop < 0) {
2196 fprintf(stderr, "Incorrect top pad size\n");
2197 exit(1);
2198 }
2199 if ((frame_padtop % 2) != 0) {
2200 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2201 exit(1);
2202 }
2203}
2204
2205static void opt_frame_pad_bottom(const char *arg)
2206{
115329f1 2207 frame_padbottom = atoi(arg);
1ff93ffc
TK
2208 if (frame_padbottom < 0) {
2209 fprintf(stderr, "Incorrect bottom pad size\n");
2210 exit(1);
2211 }
2212 if ((frame_padbottom % 2) != 0) {
2213 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2214 exit(1);
2215 }
2216}
2217
2218
2219static void opt_frame_pad_left(const char *arg)
2220{
115329f1 2221 frame_padleft = atoi(arg);
1ff93ffc
TK
2222 if (frame_padleft < 0) {
2223 fprintf(stderr, "Incorrect left pad size\n");
2224 exit(1);
2225 }
2226 if ((frame_padleft % 2) != 0) {
2227 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2228 exit(1);
2229 }
2230}
2231
2232
2233static void opt_frame_pad_right(const char *arg)
2234{
115329f1 2235 frame_padright = atoi(arg);
1ff93ffc
TK
2236 if (frame_padright < 0) {
2237 fprintf(stderr, "Incorrect right pad size\n");
2238 exit(1);
2239 }
2240 if ((frame_padright % 2) != 0) {
2241 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2242 exit(1);
2243 }
2244}
2245
2246
63167088
RS
2247static void opt_frame_pix_fmt(const char *arg)
2248{
2249 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2250}
2251
5fe03e38
RS
2252static void opt_frame_aspect_ratio(const char *arg)
2253{
2254 int x = 0, y = 0;
2255 double ar = 0;
2256 const char *p;
115329f1 2257
5fe03e38
RS
2258 p = strchr(arg, ':');
2259 if (p) {
2260 x = strtol(arg, (char **)&arg, 10);
bb270c08
DB
2261 if (arg == p)
2262 y = strtol(arg+1, (char **)&arg, 10);
2263 if (x > 0 && y > 0)
2264 ar = (double)x / (double)y;
5fe03e38
RS
2265 } else
2266 ar = strtod(arg, (char **)&arg);
2267
2268 if (!ar) {
2269 fprintf(stderr, "Incorrect aspect ratio specification.\n");
bb270c08 2270 exit(1);
5fe03e38
RS
2271 }
2272 frame_aspect_ratio = ar;
2273}
2274
b29f97d1 2275static void opt_qscale(const char *arg)
85f07f22 2276{
158c7f05 2277 video_qscale = atof(arg);
4e64bead 2278 if (video_qscale <= 0 ||
158c7f05 2279 video_qscale > 255) {
4e64bead 2280 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
85f07f22
FB
2281 exit(1);
2282 }
2283}
2284
b29f97d1 2285static void opt_qdiff(const char *arg)
9cdd6a24
MN
2286{
2287 video_qdiff = atoi(arg);
2288 if (video_qdiff < 0 ||
2289 video_qdiff > 31) {
2290 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2291 exit(1);
2292 }
2293}
2294
b29f97d1 2295static void opt_strict(const char *arg)
f560dd82
MN
2296{
2297 strict= atoi(arg);
2298}
2299
bb198e19
MN
2300static void opt_top_field_first(const char *arg)
2301{
2302 top_field_first= atoi(arg);
2303}
2304
9c3d33d6
MN
2305static void opt_thread_count(const char *arg)
2306{
2307 thread_count= atoi(arg);
2450cff2 2308#if !defined(HAVE_THREADS)
d8019eb5
AD
2309 if (verbose >= 0)
2310 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
842b556a 2311#endif
9c3d33d6
MN
2312}
2313
b29f97d1 2314static void opt_audio_rate(const char *arg)
85f07f22
FB
2315{
2316 audio_sample_rate = atoi(arg);
2317}
2318
b29f97d1 2319static void opt_audio_channels(const char *arg)
85f07f22
FB
2320{
2321 audio_channels = atoi(arg);
2322}
2323
b29f97d1 2324static void opt_video_channel(const char *arg)
a5df11ab
FB
2325{
2326 video_channel = strtol(arg, NULL, 0);
2327}
2328
e3ee3283
AB
2329static void opt_video_standard(const char *arg)
2330{
2331 video_standard = av_strdup(arg);
2332}
2333
cf7fc795
FB
2334static void opt_codec(int *pstream_copy, int *pcodec_id,
2335 int codec_type, const char *arg)
85f07f22
FB
2336{
2337 AVCodec *p;
2338
1629626f 2339 if (!strcmp(arg, "copy")) {
cf7fc795 2340 *pstream_copy = 1;
85f07f22 2341 } else {
1629626f
FB
2342 p = first_avcodec;
2343 while (p) {
cf7fc795 2344 if (!strcmp(p->name, arg) && p->type == codec_type)
1629626f
FB
2345 break;
2346 p = p->next;
2347 }
2348 if (p == NULL) {
cf7fc795 2349 fprintf(stderr, "Unknown codec '%s'\n", arg);
1629626f
FB
2350 exit(1);
2351 } else {
cf7fc795 2352 *pcodec_id = p->id;
1629626f 2353 }
85f07f22
FB
2354 }
2355}
2356
cf7fc795
FB
2357static void opt_audio_codec(const char *arg)
2358{
2359 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2360}
2361
b2a2197e
MN
2362static void opt_audio_tag(const char *arg)
2363{
2364 char *tail;
2365 audio_codec_tag= strtol(arg, &tail, 0);
2366
2367 if(!tail || *tail)
2368 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2369}
2370
2371static void opt_video_tag(const char *arg)
2372{
2373 char *tail;
2374 video_codec_tag= strtol(arg, &tail, 0);
2375
2376 if(!tail || *tail)
2377 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2378}
2379
b29f97d1 2380static void add_frame_hooker(const char *arg)
10d104e4
PG
2381{
2382 int argc = 0;
2383 char *argv[64];
2384 int i;
e9a9e0c2 2385 char *args = av_strdup(arg);
10d104e4 2386
bee0d9e5
CY
2387 using_vhook = 1;
2388
10d104e4
PG
2389 argv[0] = strtok(args, " ");
2390 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2391 }
2392
2393 i = frame_hook_add(argc, argv);
2394
2395 if (i != 0) {
2396 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2397 exit(1);
2398 }
2399}
2400
85f07f22
FB
2401const char *motion_str[] = {
2402 "zero",
2403 "full",
2404 "log",
2405 "phods",
7084c149
MN
2406 "epzs",
2407 "x1",
51d6a3cf
MN
2408 "hex",
2409 "umh",
2410 "iter",
85f07f22
FB
2411 NULL,
2412};
2413
b29f97d1 2414static void opt_motion_estimation(const char *arg)
85f07f22
FB
2415{
2416 const char **p;
2417 p = motion_str;
2418 for(;;) {
2419 if (!*p) {
2420 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2421 exit(1);
2422 }
2423 if (!strcmp(*p, arg))
2424 break;
2425 p++;
2426 }
101bea5f 2427 me_method = (p - motion_str) + 1;
85f07f22
FB
2428}
2429
b29f97d1 2430static void opt_video_codec(const char *arg)
85f07f22 2431{
cf7fc795
FB
2432 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2433}
85f07f22 2434
cf7fc795
FB
2435static void opt_subtitle_codec(const char *arg)
2436{
2437 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
85f07f22
FB
2438}
2439
b29f97d1 2440static void opt_map(const char *arg)
85f07f22
FB
2441{
2442 AVStreamMap *m;
2443 const char *p;
2444
2445 p = arg;
2446 m = &stream_maps[nb_stream_maps++];
2447
2448 m->file_index = strtol(arg, (char **)&p, 0);
2449 if (*p)
2450 p++;
a5dc85ef
J
2451
2452 m->stream_index = strtol(p, (char **)&p, 0);
b4a3389e
WG
2453 if (*p) {
2454 p++;
2455 m->sync_file_index = strtol(p, (char **)&p, 0);
2456 if (*p)
2457 p++;
2458 m->sync_stream_index = strtol(p, (char **)&p, 0);
2459 } else {
2460 m->sync_file_index = m->file_index;
2461 m->sync_stream_index = m->stream_index;
2462 }
85f07f22
FB
2463}
2464
0a38bafd
PB
2465static void opt_map_meta_data(const char *arg)
2466{
2467 AVMetaDataMap *m;
2468 const char *p;
115329f1 2469
0a38bafd
PB
2470 p = arg;
2471 m = &meta_data_maps[nb_meta_data_maps++];
2472
2473 m->out_file = strtol(arg, (char **)&p, 0);
2474 if (*p)
2475 p++;
2476
2477 m->in_file = strtol(p, (char **)&p, 0);
2478}
2479
b29f97d1 2480static void opt_recording_time(const char *arg)
85f07f22
FB
2481{
2482 recording_time = parse_date(arg, 1);
2483}
2484
8831db5c
MN
2485static void opt_start_time(const char *arg)
2486{
2487 start_time = parse_date(arg, 1);
2488}
2489
4568325a
RS
2490static void opt_rec_timestamp(const char *arg)
2491{
2492 rec_timestamp = parse_date(arg, 0) / 1000000;
2493}
2494
a6a92a9a
WG
2495static void opt_input_ts_offset(const char *arg)
2496{
2497 input_ts_offset = parse_date(arg, 1);
2498}
2499
b29f97d1 2500static void opt_input_file(const char *filename)
85f07f22
FB
2501{
2502 AVFormatContext *ic;
2503 AVFormatParameters params, *ap = &params;
14bea432 2504 int err, i, ret, rfps, rfps_base;
bd1b79a1 2505 int64_t timestamp;
85f07f22 2506
b242baa4
FB
2507 if (!strcmp(filename, "-"))
2508 filename = "pipe:";
2509
115329f1 2510 using_stdin |= !strncmp(filename, "pipe:", 5) ||
d9a916e2
CY
2511 !strcmp( filename, "/dev/stdin" );
2512
85f07f22 2513 /* get default parameters from command line */
4eb72c6b
NS
2514 ic = av_alloc_format_context();
2515
79fdaa4c 2516 memset(ap, 0, sizeof(*ap));
4eb72c6b 2517 ap->prealloced_context = 1;
79fdaa4c
FB
2518 ap->sample_rate = audio_sample_rate;
2519 ap->channels = audio_channels;
c0df9d75
MN
2520 ap->time_base.den = frame_rate;
2521 ap->time_base.num = frame_rate_base;
1ff93ffc
TK
2522 ap->width = frame_width + frame_padleft + frame_padright;
2523 ap->height = frame_height + frame_padtop + frame_padbottom;
63167088 2524 ap->pix_fmt = frame_pix_fmt;
2639c651
RS
2525 ap->channel = video_channel;
2526 ap->standard = video_standard;
5b6d5596
MN
2527 ap->video_codec_id = video_codec_id;
2528 ap->audio_codec_id = audio_codec_id;
2529 if(pgmyuv_compatibility_hack)
2530 ap->video_codec_id= CODEC_ID_PGMYUV;
79fdaa4c 2531
4eb72c6b 2532 for(i=0; i<opt_name_count; i++){
bd31a388 2533 const AVOption *opt;
4eb72c6b
NS
2534 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2535 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2536 av_set_double(ic, opt_names[i], d);
2537 }
79fdaa4c
FB
2538 /* open the input file with generic libav function */
2539 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
85f07f22 2540 if (err < 0) {
79fdaa4c 2541 print_error(filename, err);
85f07f22
FB
2542 exit(1);
2543 }
30bc6613 2544
5894e1bb
VP
2545 ic->loop_input = loop_input;
2546
79fdaa4c
FB
2547 /* If not enough info to get the stream parameters, we decode the
2548 first frames to get it. (used in mpeg case for example) */
2549 ret = av_find_stream_info(ic);
d8019eb5 2550 if (ret < 0 && verbose >= 0) {
85f07f22
FB
2551 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2552 exit(1);
2553 }
2554
bd1b79a1
MN
2555 timestamp = start_time;
2556 /* add the stream start time */
2557 if (ic->start_time != AV_NOPTS_VALUE)
2558 timestamp += ic->start_time;
2559
254abc2e
FB
2560 /* if seeking requested, we execute it */
2561 if (start_time != 0) {
3ba1438d 2562 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
254abc2e 2563 if (ret < 0) {
115329f1 2564 fprintf(stderr, "%s: could not seek to position %0.3f\n",
254abc2e
FB
2565 filename, (double)timestamp / AV_TIME_BASE);
2566 }
2567 /* reset seek info */
2568 start_time = 0;
2569 }
2570
85f07f22
FB
2571 /* update the current parameters so that they match the one of the input stream */
2572 for(i=0;i<ic->nb_streams;i++) {
637b5326 2573 int j;
01f4895c 2574 AVCodecContext *enc = ic->streams[i]->codec;
c62c07d3
MN
2575 if(thread_count>1)
2576 avcodec_thread_init(enc, thread_count);
c62c07d3 2577 enc->thread_count= thread_count;
85f07f22
FB
2578 switch(enc->codec_type) {
2579 case CODEC_TYPE_AUDIO:
637b5326 2580 for(j=0; j<opt_name_count; j++){
bd31a388 2581 const AVOption *opt;
23b254fb 2582 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
637b5326
MN
2583 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2584 av_set_double(enc, opt_names[j], d);
2585 }
e0d2714a 2586 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
85f07f22
FB
2587 audio_channels = enc->channels;
2588 audio_sample_rate = enc->sample_rate;
b4aea108 2589 if(audio_disable)
f3356e9c 2590 ic->streams[i]->discard= AVDISCARD_ALL;
85f07f22
FB
2591 break;
2592 case CODEC_TYPE_VIDEO:
637b5326 2593 for(j=0; j<opt_name_count; j++){
bd31a388 2594 const AVOption *opt;
23b254fb 2595 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
637b5326
MN
2596 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2597 av_set_double(enc, opt_names[j], d);
2598 }
85f07f22
FB
2599 frame_height = enc->height;
2600 frame_width = enc->width;
bb270c08
DB
2601 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2602 frame_pix_fmt = enc->pix_fmt;
c0df9d75
MN
2603 rfps = ic->streams[i]->r_frame_rate.num;
2604 rfps_base = ic->streams[i]->r_frame_rate.den;
637b5326 2605 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
f4f3223f
MN
2606 if(me_threshold)
2607 enc->debug |= FF_DEBUG_MV;
d7425f59 2608
115329f1 2609 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
d8019eb5
AD
2610
2611 if (verbose >= 0)
386c88de 2612 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
c0df9d75 2613 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
d8019eb5 2614
15bc38e5 2615 (float)rfps / rfps_base, rfps, rfps_base);
79fdaa4c 2616 }
bf5af568 2617 /* update the current frame rate to match the stream frame rate */
14bea432
MN
2618 frame_rate = rfps;
2619 frame_rate_base = rfps_base;
bdfcbbed
MK
2620
2621 enc->rate_emu = rate_emu;
b4aea108 2622 if(video_disable)
f3356e9c
MN
2623 ic->streams[i]->discard= AVDISCARD_ALL;
2624 else if(video_discard)
2625 ic->streams[i]->discard= video_discard;
85f07f22 2626 break;
254abc2e
FB
2627 case CODEC_TYPE_DATA:
2628 break;
cf7fc795
FB
2629 case CODEC_TYPE_SUBTITLE:
2630 break;
ae38261e
MB
2631 case CODEC_TYPE_UNKNOWN:
2632 break;
51bd4565 2633 default:
c04643a2 2634 av_abort();
85f07f22
FB
2635 }
2636 }
115329f1 2637
85f07f22 2638 input_files[nb_input_files] = ic;
bd1b79a1 2639 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
85f07f22 2640 /* dump the file content */
d8019eb5
AD
2641 if (verbose >= 0)
2642 dump_format(ic, nb_input_files, filename, 0);
2643
85f07f22 2644 nb_input_files++;
79fdaa4c
FB
2645 file_iformat = NULL;
2646 file_oformat = NULL;
bdfcbbed 2647
2639c651 2648 video_channel = 0;
115329f1 2649
bdfcbbed 2650 rate_emu = 0;
85f07f22
FB
2651}
2652
b29f97d1 2653static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
919f448d
FB
2654{
2655 int has_video, has_audio, i, j;
2656 AVFormatContext *ic;
2657
2658 has_video = 0;
2659 has_audio = 0;
2660 for(j=0;j<nb_input_files;j++) {
2661 ic = input_files[j];
2662 for(i=0;i<ic->nb_streams;i++) {
01f4895c 2663 AVCodecContext *enc = ic->streams[i]->codec;
919f448d
FB
2664 switch(enc->codec_type) {
2665 case CODEC_TYPE_AUDIO:
2666 has_audio = 1;
2667 break;
2668 case CODEC_TYPE_VIDEO:
2669 has_video = 1;
2670 break;
6fb316d5 2671 case CODEC_TYPE_DATA:
ae38261e 2672 case CODEC_TYPE_UNKNOWN:
cf7fc795 2673 case CODEC_TYPE_SUBTITLE:
6fb316d5 2674 break;
51bd4565 2675 default:
c04643a2 2676 av_abort();
919f448d
FB
2677 }
2678 }
2679 }
2680 *has_video_ptr = has_video;
2681 *has_audio_ptr = has_audio;
2682}
2683
cf7fc795 2684static void new_video_stream(AVFormatContext *oc)
85f07f22
FB
2685{
2686 AVStream *st;
cf7fc795
FB
2687 AVCodecContext *video_enc;
2688 int codec_id;
115329f1 2689
cf7fc795
FB
2690 st = av_new_stream(oc, oc->nb_streams);
2691 if (!st) {
2692 fprintf(stderr, "Could not alloc stream\n");
2693 exit(1);
2694 }
54cc9c46 2695 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
748c2fca
MN
2696 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2697 video_bitstream_filters= NULL;
2698
cf7fc795 2699 if(thread_count>1)
01f4895c 2700 avcodec_thread_init(st->codec, thread_count);
115329f1 2701
01f4895c 2702 video_enc = st->codec;
115329f1 2703
cf7fc795
FB
2704 if(video_codec_tag)
2705 video_enc->codec_tag= video_codec_tag;
115329f1 2706
90ad92b3 2707 if( (video_global_header&1)
637b5326 2708 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
cf7fc795 2709 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
23b254fb 2710 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
637b5326
MN
2711 }
2712 if(video_global_header&2){
90ad92b3 2713 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
23b254fb 2714 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
637b5326 2715 }
90ad92b3 2716
cf7fc795
FB
2717 if (video_stream_copy) {
2718 st->stream_copy = 1;
2719 video_enc->codec_type = CODEC_TYPE_VIDEO;
2720 } else {
2721 char *p;
2722 int i;
2723 AVCodec *codec;
115329f1 2724
cf7fc795
FB
2725 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2726 if (video_codec_id != CODEC_ID_NONE)
2727 codec_id = video_codec_id;
115329f1 2728
cf7fc795
FB
2729 video_enc->codec_id = codec_id;
2730 codec = avcodec_find_encoder(codec_id);
115329f1 2731
8bbf6db9 2732 for(i=0; i<opt_name_count; i++){
bd31a388 2733 const AVOption *opt;
23b254fb 2734 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
8bbf6db9
MN
2735 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2736 av_set_double(video_enc, opt_names[i], d);
2737 }
115329f1 2738
115329f1
DB
2739 video_enc->time_base.den = frame_rate;
2740 video_enc->time_base.num = frame_rate_base;
cf7fc795
FB
2741 if(codec && codec->supported_framerates){
2742 const AVRational *p= codec->supported_framerates;
2743 AVRational req= (AVRational){frame_rate, frame_rate_base};
2744 const AVRational *best=NULL;
2745 AVRational best_error= (AVRational){INT_MAX, 1};
2746 for(; p->den!=0; p++){
2747 AVRational error= av_sub_q(req, *p);
2748 if(error.num <0) error.num *= -1;
2749 if(av_cmp_q(error, best_error) < 0){
2750 best_error= error;
2751 best= p;
2752 }
2753 }
2754 video_enc->time_base.den= best->num;
2755 video_enc->time_base.num= best->den;
2756 }
115329f1 2757
cf7fc795
FB
2758 video_enc->width = frame_width + frame_padright + frame_padleft;
2759 video_enc->height = frame_height + frame_padtop + frame_padbottom;
e7268d51 2760 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
cf7fc795
FB
2761 video_enc->pix_fmt = frame_pix_fmt;
2762
2763 if(codec && codec->pix_fmts){
2764 const enum PixelFormat *p= codec->pix_fmts;
2765 for(; *p!=-1; p++){
2766 if(*p == video_enc->pix_fmt)
2767 break;
2768 }
2769 if(*p == -1)
2770 video_enc->pix_fmt = codec->pix_fmts[0];
2771 }
2772
babe0e8c 2773 if (intra_only)
cf7fc795
FB
2774 video_enc->gop_size = 0;
2775 if (video_qscale || same_quality) {
2776 video_enc->flags |= CODEC_FLAG_QSCALE;
115329f1 2777 video_enc->global_quality=
cf7fc795
FB
2778 st->quality = FF_QP2LAMBDA * video_qscale;
2779 }
2780
2781 if(intra_matrix)
2782 video_enc->intra_matrix = intra_matrix;
2783 if(inter_matrix)
2784 video_enc->inter_matrix = inter_matrix;
2785
cf7fc795 2786 video_enc->max_qdiff = video_qdiff;
cf7fc795 2787 video_enc->rc_eq = video_rc_eq;
cf7fc795
FB
2788 video_enc->thread_count = thread_count;
2789 p= video_rc_override_string;
2790 for(i=0; p; i++){
2791 int start, end, q;
2792 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2793 if(e!=3){
2794 fprintf(stderr, "error parsing rc_override\n");
2795 exit(1);
2796 }
115329f1
DB
2797 video_enc->rc_override=
2798 av_realloc(video_enc->rc_override,
cf7fc795
FB
2799 sizeof(RcOverride)*(i+1));
2800 video_enc->rc_override[i].start_frame= start;
2801 video_enc->rc_override[i].end_frame = end;
2802 if(q>0){
2803 video_enc->rc_override[i].qscale= q;
2804 video_enc->rc_override[i].quality_factor= 1.0;
2805 }
2806 else{
2807 video_enc->rc_override[i].qscale= 0;
2808 video_enc->rc_override[i].quality_factor= -q/100.0;
2809 }
2810 p= strchr(p, '/');
2811 if(p) p++;
2812 }
2813 video_enc->rc_override_count=i;
079e8cb9
BC
2814 if (!video_enc->rc_initial_buffer_occupancy)
2815 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
cf7fc795 2816 video_enc->me_threshold= me_threshold;
cf7fc795
FB
2817 video_enc->intra_dc_precision= intra_dc_precision - 8;
2818 video_enc->strict_std_compliance = strict;
cf7fc795 2819
cf7fc795
FB
2820 if (do_psnr)
2821 video_enc->flags|= CODEC_FLAG_PSNR;
115329f1 2822
cf7fc795
FB
2823 video_enc->me_method = me_method;
2824
2825 /* two pass mode */
2826 if (do_pass) {
2827 if (do_pass == 1) {
2828 video_enc->flags |= CODEC_FLAG_PASS1;
2829 } else {
2830 video_enc->flags |= CODEC_FLAG_PASS2;
2831 }
2832 }
2833 }
2834
2835 /* reset some key parameters */
2836 video_disable = 0;
2837 video_codec_id = CODEC_ID_NONE;
2838 video_stream_copy = 0;
2839}
2840
2841static void new_audio_stream(AVFormatContext *oc)
2842{
2843 AVStream *st;
2844 AVCodecContext *audio_enc;
8bbf6db9 2845 int codec_id, i;
115329f1 2846
cf7fc795
FB
2847 st = av_new_stream(oc, oc->nb_streams);
2848 if (!st) {
2849 fprintf(stderr, "Could not alloc stream\n");
2850 exit(1);
2851 }
54cc9c46 2852 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
748c2fca
MN
2853
2854 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2855 audio_bitstream_filters= NULL;
2856
cf7fc795 2857 if(thread_count>1)
01f4895c 2858 avcodec_thread_init(st->codec, thread_count);
115329f1 2859
01f4895c 2860 audio_enc = st->codec;
cf7fc795 2861 audio_enc->codec_type = CODEC_TYPE_AUDIO;
f889d3f9 2862 audio_enc->strict_std_compliance = strict;
115329f1 2863
cf7fc795
FB
2864 if(audio_codec_tag)
2865 audio_enc->codec_tag= audio_codec_tag;
115329f1 2866
637b5326 2867 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
cf7fc795 2868 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
23b254fb 2869 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
637b5326 2870 }
cf7fc795
FB
2871 if (audio_stream_copy) {
2872 st->stream_copy = 1;
2873 audio_enc->channels = audio_channels;
2874 } else {
2875 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
115329f1 2876
8bbf6db9 2877 for(i=0; i<opt_name_count; i++){
bd31a388 2878 const AVOption *opt;
23b254fb 2879 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
8bbf6db9
MN
2880 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2881 av_set_double(audio_enc, opt_names[i], d);
2882 }
115329f1 2883
cf7fc795
FB
2884 if (audio_codec_id != CODEC_ID_NONE)
2885 codec_id = audio_codec_id;
2886 audio_enc->codec_id = codec_id;
115329f1 2887
c57c770d
JR
2888 if (audio_qscale > QSCALE_NONE) {
2889 audio_enc->flags |= CODEC_FLAG_QSCALE;
2890 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2891 }
cf7fc795 2892 audio_enc->thread_count = thread_count;
e3e3be53 2893 audio_enc->channels = audio_channels;
cf7fc795
FB
2894 }
2895 audio_enc->sample_rate = audio_sample_rate;
78e03516 2896 audio_enc->time_base= (AVRational){1, audio_sample_rate};
cf7fc795
FB
2897 if (audio_language) {
2898 pstrcpy(st->language, sizeof(st->language), audio_language);
2899 av_free(audio_language);
2900 audio_language = NULL;
2901 }
2902
2903 /* reset some key parameters */
2904 audio_disable = 0;
2905 audio_codec_id = CODEC_ID_NONE;
2906 audio_stream_copy = 0;
2907}
2908
2909static void opt_new_subtitle_stream(void)
2910{
2911 AVFormatContext *oc;
2912 AVStream *st;
2913 AVCodecContext *subtitle_enc;
8bbf6db9 2914 int i;
115329f1 2915
cf7fc795
FB
2916 if (nb_output_files <= 0) {
2917 fprintf(stderr, "At least one output file must be specified\n");
2918 exit(1);
2919 }
2920 oc = output_files[nb_output_files - 1];
2921
2922 st = av_new_stream(oc, oc->nb_streams);
2923 if (!st) {
2924 fprintf(stderr, "Could not alloc stream\n");
2925 exit(1);
2926 }
54cc9c46 2927 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
cf7fc795 2928
01f4895c 2929 subtitle_enc = st->codec;
cf7fc795
FB
2930 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2931 if (subtitle_stream_copy) {
2932 st->stream_copy = 1;
2933 } else {
8bbf6db9 2934 for(i=0; i<opt_name_count; i++){
bd31a388 2935 const AVOption *opt;
23b254fb 2936 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
8bbf6db9
MN
2937 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2938 av_set_double(subtitle_enc, opt_names[i], d);
2939 }
cf7fc795
FB
2940 subtitle_enc->codec_id = subtitle_codec_id;
2941 }
2942
2943 if (subtitle_language) {
2944 pstrcpy(st->language, sizeof(st->language), subtitle_language);
2945 av_free(subtitle_language);
2946 subtitle_language = NULL;
2947 }
2948
2949 subtitle_codec_id = CODEC_ID_NONE;
2950 subtitle_stream_copy = 0;
2951}
2952
2953static void opt_new_audio_stream(void)
2954{
2955 AVFormatContext *oc;
2956 if (nb_output_files <= 0) {
2957 fprintf(stderr, "At least one output file must be specified\n");
2958 exit(1);
2959 }
2960 oc = output_files[nb_output_files - 1];
2961 new_audio_stream(oc);
2962}
2963
2964static void opt_new_video_stream(void)
2965{
2966 AVFormatContext *oc;
2967 if (nb_output_files <= 0) {
2968 fprintf(stderr, "At least one output file must be specified\n");
2969 exit(1);
2970 }
2971 oc = output_files[nb_output_files - 1];
2972 new_video_stream(oc);
2973}
2974
2975static void opt_output_file(const char *filename)
2976{
2977 AVFormatContext *oc;
8e16b25c 2978 int use_video, use_audio, input_has_video, input_has_audio, i;
817b23ff 2979 AVFormatParameters params, *ap = &params;
85f07f22
FB
2980
2981 if (!strcmp(filename, "-"))
2982 filename = "pipe:";
2983
bc874dae 2984 oc = av_alloc_format_context();
85f07f22 2985
79fdaa4c
FB
2986 if (!file_oformat) {
2987 file_oformat = guess_format(NULL, filename, NULL);
2988 if (!file_oformat) {
2989 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2990 filename);
2991 exit(1);
2992 }
85f07f22 2993 }
115329f1 2994
79fdaa4c 2995 oc->oformat = file_oformat;
cf7fc795 2996 pstrcpy(oc->filename, sizeof(oc->filename), filename);
85f07f22 2997
115329f1 2998 if (!strcmp(file_oformat->name, "ffm") &&
85f07f22
FB
2999 strstart(filename, "http:", NULL)) {
3000 /* special case for files sent to ffserver: we get the stream
3001 parameters from ffserver */
3002 if (read_ffserver_streams(oc, filename) < 0) {
3003 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3004 exit(1);
3005 }
3006 } else {
f2d9a9f5
LA
3007 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3008 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
919f448d 3009
e30a2846
FB
3010 /* disable if no corresponding type found and at least one
3011 input file */
3012 if (nb_input_files > 0) {
3013 check_audio_video_inputs(&input_has_video, &input_has_audio);
3014 if (!input_has_video)
3015 use_video = 0;
3016 if (!input_has_audio)
3017 use_audio = 0;
3018 }
919f448d
FB
3019
3020 /* manual disable */
85f07f22
FB
3021 if (audio_disable) {
3022 use_audio = 0;
3023 }
3024 if (video_disable) {
3025 use_video = 0;
3026 }
115329f1 3027
85f07f22 3028 if (use_video) {
cf7fc795 3029 new_video_stream(oc);
85f07f22 3030 }
115329f1 3031
85f07f22 3032 if (use_audio) {
cf7fc795 3033 new_audio_stream(oc);
85f07f22
FB
3034 }
3035
4568325a 3036 oc->timestamp = rec_timestamp;
115329f1 3037
bb270c08 3038 if (str_title)
79fdaa4c 3039 pstrcpy(oc->title, sizeof(oc->title), str_title);
85f07f22 3040 if (str_author)
79fdaa4c 3041 pstrcpy(oc->author, sizeof(oc->author), str_author);
85f07f22 3042 if (str_copyright)
79fdaa4c 3043 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
85f07f22 3044 if (str_comment)
79fdaa4c 3045 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
63d5075c
PI
3046 if (str_album)
3047 pstrcpy(oc->album, sizeof(oc->album), str_album);
85f07f22
FB
3048 }
3049
1629626f 3050 output_files[nb_output_files++] = oc;
85f07f22 3051
919f448d 3052 /* check filename in case of an image number is expected */
79fdaa4c 3053 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5c07cf53 3054 if (!av_filename_number_test(oc->filename)) {
79fdaa4c 3055 print_error(oc->filename, AVERROR_NUMEXPECTED);
919f448d 3056 exit(1);
79fdaa4c 3057 }
919f448d
FB
3058 }
3059
79fdaa4c 3060 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
85f07f22 3061 /* test if it already exists to avoid loosing precious files */
115329f1 3062 if (!file_overwrite &&
85f07f22
FB
3063 (strchr(filename, ':') == NULL ||
3064 strstart(filename, "file:", NULL))) {
3065 if (url_exist(filename)) {
3066 int c;
115329f1 3067
d9a916e2
CY
3068 if ( !using_stdin ) {
3069 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3070 fflush(stderr);
3071 c = getchar();
3072 if (toupper(c) != 'Y') {
3073 fprintf(stderr, "Not overwriting - exiting\n");
3074 exit(1);
3075 }
bb270c08
DB
3076 }
3077 else {
d9a916e2 3078 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
85f07f22 3079 exit(1);
bb270c08 3080 }
85f07f22
FB
3081 }
3082 }
115329f1 3083
85f07f22
FB
3084 /* open the file */
3085 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3086 fprintf(stderr, "Could not open '%s'\n", filename);
3087 exit(1);
3088 }
3089 }
3090
817b23ff 3091 memset(ap, 0, sizeof(*ap));
817b23ff
FB
3092 if (av_set_parameters(oc, ap) < 0) {
3093 fprintf(stderr, "%s: Invalid encoding parameters\n",
3094 oc->filename);
3095 exit(1);
3096 }
3097
17c88cb0
MN
3098 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3099 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
8108551a 3100 oc->loop_output = loop_output;
2db3c638 3101
8e16b25c 3102 for(i=0; i<opt_name_count; i++){
bd31a388 3103 const AVOption *opt;
8e16b25c
PI
3104 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3105 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3106 av_set_double(oc, opt_names[i], d);
3107 }
3108
85f07f22 3109 /* reset some options */
79fdaa4c
FB
3110 file_oformat = NULL;
3111 file_iformat = NULL;
85f07f22
FB
3112}
3113
5abdb4b1 3114/* same option as mencoder */
b29f97d1 3115static void opt_pass(const char *pass_str)
5abdb4b1
FB
3116{
3117 int pass;
3118 pass = atoi(pass_str);
3119 if (pass != 1 && pass != 2) {
3120 fprintf(stderr, "pass number can be only 1 or 2\n");
3121 exit(1);
3122 }
3123 do_pass = pass;
3124}
a38469e1 3125
2f30a81d 3126#if defined(__MINGW32__) || defined(CONFIG_OS2)
0c1a9eda 3127static int64_t getutime(void)
5727b222 3128{
f3ec2d46 3129 return av_gettime();
5727b222 3130}
bdc4796f 3131#else
0c1a9eda 3132static int64_t getutime(void)
bdc4796f 3133{
f3ec2d46
SG
3134 struct rusage rusage;
3135
3136 getrusage(RUSAGE_SELF, &rusage);
3137 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
bdc4796f
FB
3138}
3139#endif
5727b222 3140
e8a42081 3141#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
79fdaa4c 3142extern int ffm_nopts;
e8a42081 3143#endif
79fdaa4c 3144
b29f97d1 3145static void show_formats(void)
85f07f22 3146{
79fdaa4c
FB
3147 AVInputFormat *ifmt;
3148 AVOutputFormat *ofmt;
85f07f22 3149 URLProtocol *up;
3738fe1a
MN
3150 AVCodec *p, *p2;
3151 const char **pp, *last_name;
3152
3153 printf("File formats:\n");
3154 last_name= "000";
3155 for(;;){
3156 int decode=0;
3157 int encode=0;
3158 const char *name=NULL;
92a80570 3159 const char *long_name=NULL;
3738fe1a
MN
3160
3161 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3162 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3163 strcmp(ofmt->name, last_name)>0){
3164 name= ofmt->name;
92a80570 3165 long_name= ofmt->long_name;
3738fe1a
MN
3166 encode=1;
3167 }
3168 }
3169 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3170 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3171 strcmp(ifmt->name, last_name)>0){
3172 name= ifmt->name;
92a80570 3173 long_name= ifmt->long_name;
3738fe1a
MN
3174 encode=0;
3175 }
3176 if(name && strcmp(ifmt->name, name)==0)
3177 decode=1;
3178 }
3179 if(name==NULL)
3180 break;
3181 last_name= name;
115329f1 3182
3738fe1a 3183 printf(
115329f1
DB
3184 " %s%s %-15s %s\n",
3185 decode ? "D":" ",
3186 encode ? "E":" ",
92a80570
MN
3187 name,
3188 long_name ? long_name:" ");
817b23ff
FB
3189 }
3190 printf("\n");
3191
85f07f22 3192 printf("Codecs:\n");
3738fe1a
MN
3193 last_name= "000";
3194 for(;;){
3195 int decode=0;
3196 int encode=0;
3197 int cap=0;
cf7fc795 3198 const char *type_str;
3738fe1a
MN
3199
3200 p2=NULL;
3201 for(p = first_avcodec; p != NULL; p = p->next) {
3202 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3203 strcmp(p->name, last_name)>0){
3204 p2= p;
3205 decode= encode= cap=0;
3206 }
3207 if(p2 && strcmp(p->name, p2->name)==0){
3208 if(p->decode) decode=1;
3209 if(p->encode) encode=1;
3210 cap |= p->capabilities;
3211 }
3212 }
3213 if(p2==NULL)
3214 break;
3215 last_name= p2->name;
115329f1 3216
cf7fc795
FB
3217 switch(p2->type) {
3218 case CODEC_TYPE_VIDEO:
3219 type_str = "V";
3220 break;
3221 case CODEC_TYPE_AUDIO:
3222 type_str = "A";
3223 break;
3224 case CODEC_TYPE_SUBTITLE:
3225 type_str = "S";
3226 break;
3227 default:
3228 type_str = "?";
3229 break;
3230 }
3738fe1a 3231 printf(
115329f1
DB
3232 " %s%s%s%s%s%s %s",
3233 decode ? "D": (/*p2->decoder ? "d":*/" "),
3234 encode ? "E":" ",
cf7fc795 3235 type_str,
3738fe1a
MN
3236 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3237 cap & CODEC_CAP_DR1 ? "D":" ",
3238 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3239 p2->name);
3240 /* if(p2->decoder && decode==0)
3241 printf(" use %s for decoding", p2->decoder->name);*/
3242 printf("\n");
85f07f22
FB
3243 }
3244 printf("\n");
3245
3738fe1a 3246 printf("Supported file protocols:\n");
85f07f22
FB
3247 for(up = first_protocol; up != NULL; up = up->next)
3248 printf(" %s:", up->name);
3249 printf("\n");
115329f1 3250
3738fe1a
MN
3251 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3252 printf("Motion estimation methods:\n");
85f07f22
FB
3253 pp = motion_str;
3254 while (*pp) {
3255 printf(" %s", *pp);
115329f1 3256 if ((pp - motion_str + 1) == ME_ZERO)
85f07f22 3257 printf("(fastest)");
115329f1 3258 else if ((pp - motion_str + 1) == ME_FULL)
85f07f22 3259 printf("(slowest)");
115329f1 3260 else if ((pp - motion_str + 1) == ME_EPZS)
85f07f22
FB
3261 printf("(default)");
3262 pp++;
3263 }
3738fe1a
MN
3264 printf("\n\n");
3265 printf(
3266"Note, the names of encoders and decoders dont always match, so there are\n"
3267"several cases where the above table shows encoder only or decoder only entries\n"
3268"even though both encoding and decoding are supported for example, the h263\n"
3269"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3270"worse\n");
85f07f22
FB
3271 exit(1);
3272}
3273
ceaf1909 3274static void parse_matrix_coeffs(uint16_t *dest, const char *str)
84f608f4
VM
3275{
3276 int i;
3277 const char *p = str;
3278 for(i = 0;; i++) {
3279 dest[i] = atoi(p);
3280 if(i == 63)
3281 break;
3282 p = strchr(p, ',');
3283 if(!p) {
3284 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3285 exit(1);
3286 }
3287 p++;
3288 }
3289}
3290
ceaf1909 3291static void opt_inter_matrix(const char *arg)
84f608f4
VM
3292{
3293 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3294 parse_matrix_coeffs(inter_matrix, arg);
3295}
3296
ceaf1909 3297static void opt_intra_matrix(const char *arg)
84f608f4
VM
3298{
3299 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3300 parse_matrix_coeffs(intra_matrix, arg);
3301}
3302
e0595741
VM
3303static void opt_target(const char *arg)
3304{
3305 int norm = -1;
88730be6 3306 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
e0595741
VM
3307
3308 if(!strncmp(arg, "pal-", 4)) {
3309 norm = 0;
3310 arg += 4;
3311 } else if(!strncmp(arg, "ntsc-", 5)) {
3312 norm = 1;
3313 arg += 5;
ed2d7a34
PI
3314 } else if(!strncmp(arg, "film-", 5)) {
3315 norm = 2;
3316 arg += 5;
e0595741
VM
3317 } else {
3318 int fr;
3319 /* Calculate FR via float to avoid int overflow */
3320 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3321 if(fr == 25000) {
3322 norm = 0;
3323 } else if((fr == 29970) || (fr == 23976)) {
3324 norm = 1;
3325 } else {
3326 /* Try to determine PAL/NTSC by peeking in the input files */
3327 if(nb_input_files) {
3328 int i, j;
3329 for(j = 0; j < nb_input_files; j++) {
3330 for(i = 0; i < input_files[j]->nb_streams; i++) {
01f4895c 3331 AVCodecContext *c = input_files[j]->streams[i]->codec;
e0595741
VM
3332 if(c->codec_type != CODEC_TYPE_VIDEO)
3333 continue;
c0df9d75 3334 fr = c->time_base.den * 1000 / c->time_base.num;
e0595741
VM
3335 if(fr == 25000) {
3336 norm = 0;
3337 break;
3338 } else if((fr == 29970) || (fr == 23976)) {
3339 norm = 1;
3340 break;
3341 }
3342 }
3343 if(norm >= 0)
3344 break;
3345 }
3346 }
3347 }
3348 if(verbose && norm >= 0)
ac930a99 3349 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
e0595741
VM
3350 }
3351
3352 if(norm < 0) {
ed2d7a34
PI
3353 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3354 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
e0595741
VM
3355 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3356 exit(1);
3357 }
3358
3359 if(!strcmp(arg, "vcd")) {
3360
3361 opt_video_codec("mpeg1video");
3362 opt_audio_codec("mp2");
3363 opt_format("vcd");
3364
3365 opt_frame_size(norm ? "352x240" : "352x288");
ed2d7a34 3366 opt_frame_rate(frame_rates[norm]);
babe0e8c 3367 opt_default("gop", norm ? "18" : "15");
e0595741 3368
3c0ba870 3369 opt_default("b", "1150000");
a5515106
PI
3370 opt_default("maxrate", "1150000");
3371 opt_default("minrate", "1150000");
81d0618f 3372 opt_default("bufsize", "327680"); // 40*1024*8;
e0595741 3373
066a81a8 3374 opt_default("ab", "224000");
e0595741 3375 audio_sample_rate = 44100;