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