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