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