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