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