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