Move av_exit() to before main()
[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 185static char *vstats_filename;
032aa7df 186static FILE *vstats_file;
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 */
032aa7df
SS
858 if (!vstats_file) {
859 vstats_file = fopen(vstats_filename, "w");
860 if (!vstats_file) {
4bd0c2b1
BF
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;
032aa7df 869 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
140cb663 870 if (enc->flags&CODEC_FLAG_PSNR)
032aa7df 871 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
115329f1 872
032aa7df 873 fprintf(vstats_file,"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;
032aa7df 881 fprintf(vstats_file, "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);
032aa7df 883 fprintf(vstats_file,"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
6d1ba1ac
LA
1342static void print_sdp(AVFormatContext **avc, int n)
1343{
1344 char sdp[2048];
1345
1346 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1347 printf("SDP:\n%s\n", sdp);
1348}
a700a6ae 1349
85f07f22
FB
1350/*
1351 * The following code is the main loop of the file converter
1352 */
1353static int av_encode(AVFormatContext **output_files,
1354 int nb_output_files,
1355 AVFormatContext **input_files,
1356 int nb_input_files,
1357 AVStreamMap *stream_maps, int nb_stream_maps)
1358{
445f1b83 1359 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
85f07f22
FB
1360 AVFormatContext *is, *os;
1361 AVCodecContext *codec, *icodec;
1362 AVOutputStream *ost, **ost_table = NULL;
1363 AVInputStream *ist, **ist_table = NULL;
bdc4796f 1364 AVInputFile *file_table;
cb09b2ed 1365 int key;
6d1ba1ac 1366 int want_sdp = 1;
bdc4796f 1367
51bd4565 1368 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
bdc4796f
FB
1369 if (!file_table)
1370 goto fail;
115329f1 1371
85f07f22
FB
1372 /* input stream init */
1373 j = 0;
1374 for(i=0;i<nb_input_files;i++) {
1375 is = input_files[i];
1376 file_table[i].ist_index = j;
79fdaa4c 1377 file_table[i].nb_streams = is->nb_streams;
85f07f22
FB
1378 j += is->nb_streams;
1379 }
1380 nb_istreams = j;
1381
1382 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1383 if (!ist_table)
bdc4796f 1384 goto fail;
115329f1 1385
85f07f22
FB
1386 for(i=0;i<nb_istreams;i++) {
1387 ist = av_mallocz(sizeof(AVInputStream));
1388 if (!ist)
1389 goto fail;
1390 ist_table[i] = ist;
1391 }
1392 j = 0;
1393 for(i=0;i<nb_input_files;i++) {
1394 is = input_files[i];
1395 for(k=0;k<is->nb_streams;k++) {
1396 ist = ist_table[j++];
1397 ist->st = is->streams[k];
1398 ist->file_index = i;
1399 ist->index = k;
1400 ist->discard = 1; /* the stream is discarded by default
1401 (changed later) */
bdfcbbed 1402
01f4895c 1403 if (ist->st->codec->rate_emu) {
bdfcbbed
MK
1404 ist->start = av_gettime();
1405 ist->frame = 0;
1406 }
85f07f22
FB
1407 }
1408 }
1409
1410 /* output stream init */
1411 nb_ostreams = 0;
1412 for(i=0;i<nb_output_files;i++) {
1413 os = output_files[i];
8a7bde1c
BC
1414 if (!os->nb_streams) {
1415 fprintf(stderr, "Output file does not contain any stream\n");
1416 exit(1);
1417 }
85f07f22
FB
1418 nb_ostreams += os->nb_streams;
1419 }
1420 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1421 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1422 exit(1);
1423 }
1424
bd073980
BF
1425 /* Sanity check the mapping args -- do the input files & streams exist? */
1426 for(i=0;i<nb_stream_maps;i++) {
1427 int fi = stream_maps[i].file_index;
1428 int si = stream_maps[i].stream_index;
115329f1 1429
bd073980
BF
1430 if (fi < 0 || fi > nb_input_files - 1 ||
1431 si < 0 || si > file_table[fi].nb_streams - 1) {
1432 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1433 exit(1);
1434 }
b4a3389e
WG
1435 fi = stream_maps[i].sync_file_index;
1436 si = stream_maps[i].sync_stream_index;
1437 if (fi < 0 || fi > nb_input_files - 1 ||
1438 si < 0 || si > file_table[fi].nb_streams - 1) {
1439 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1440 exit(1);
1441 }
bd073980 1442 }
115329f1 1443
85f07f22
FB
1444 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1445 if (!ost_table)
1446 goto fail;
1447 for(i=0;i<nb_ostreams;i++) {
1448 ost = av_mallocz(sizeof(AVOutputStream));
1449 if (!ost)
1450 goto fail;
1451 ost_table[i] = ost;
1452 }
115329f1 1453
85f07f22
FB
1454 n = 0;
1455 for(k=0;k<nb_output_files;k++) {
1456 os = output_files[k];
1457 for(i=0;i<os->nb_streams;i++) {
1458 int found;
1459 ost = ost_table[n++];
1460 ost->file_index = k;
1461 ost->index = i;
1462 ost->st = os->streams[i];
1463 if (nb_stream_maps > 0) {
115329f1 1464 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
85f07f22 1465 stream_maps[n-1].stream_index;
115329f1 1466
bd073980 1467 /* Sanity check that the stream types match */
01f4895c 1468 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
bd073980
BF
1469 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1470 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1471 ost->file_index, ost->index);
1472 exit(1);
1473 }
115329f1 1474
85f07f22
FB
1475 } else {
1476 /* get corresponding input stream index : we select the first one with the right type */
1477 found = 0;
1478 for(j=0;j<nb_istreams;j++) {
1479 ist = ist_table[j];
115329f1 1480 if (ist->discard &&
01f4895c 1481 ist->st->codec->codec_type == ost->st->codec->codec_type) {
85f07f22
FB
1482 ost->source_index = j;
1483 found = 1;
c19e76ce 1484 break;
85f07f22
FB
1485 }
1486 }
115329f1 1487
85f07f22
FB
1488 if (!found) {
1489 /* try again and reuse existing stream */
1490 for(j=0;j<nb_istreams;j++) {
1491 ist = ist_table[j];
01f4895c 1492 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
85f07f22
FB
1493 ost->source_index = j;
1494 found = 1;
1495 }
1496 }
1497 if (!found) {
1498 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1499 ost->file_index, ost->index);
1500 exit(1);
1501 }
1502 }
1503 }
1504 ist = ist_table[ost->source_index];
1505 ist->discard = 0;
b4a3389e
WG
1506 ost->sync_ist = (nb_stream_maps > 0) ?
1507 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1508 stream_maps[n-1].sync_stream_index] : ist;
85f07f22
FB
1509 }
1510 }
1511
85f07f22
FB
1512 /* for each output stream, we compute the right encoding parameters */
1513 for(i=0;i<nb_ostreams;i++) {
1514 ost = ost_table[i];
365515ac 1515 os = output_files[ost->file_index];
85f07f22
FB
1516 ist = ist_table[ost->source_index];
1517
01f4895c
MN
1518 codec = ost->st->codec;
1519 icodec = ist->st->codec;
85f07f22 1520
8e0d882b
AJ
1521 if (!ost->st->language[0])
1522 av_strlcpy(ost->st->language, ist->st->language,
1523 sizeof(ost->st->language));
1524
1629626f
FB
1525 if (ost->st->stream_copy) {
1526 /* if stream_copy is selected, no need to decode or encode */
1527 codec->codec_id = icodec->codec_id;
1528 codec->codec_type = icodec->codec_type;
365515ac
MN
1529
1530 if(!codec->codec_tag){
1531 if( !os->oformat->codec_tag
1532 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1533 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1534 codec->codec_tag = icodec->codec_tag;
1535 }
1536
1629626f 1537 codec->bit_rate = icodec->bit_rate;
dffbfd06
MN
1538 codec->extradata= icodec->extradata;
1539 codec->extradata_size= icodec->extradata_size;
4408e75e 1540 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
d29de719
MN
1541 codec->time_base = icodec->time_base;
1542 else
1543 codec->time_base = ist->st->time_base;
1629626f
FB
1544 switch(codec->codec_type) {
1545 case CODEC_TYPE_AUDIO:
1546 codec->sample_rate = icodec->sample_rate;
1547 codec->channels = icodec->channels;
0a3b0447 1548 codec->frame_size = icodec->frame_size;
c1344911 1549 codec->block_align= icodec->block_align;
4efd6f58
MN
1550 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1551 codec->block_align= 0;
1629626f
FB
1552 break;
1553 case CODEC_TYPE_VIDEO:
8d74e55b
MD
1554 if(using_vhook) {
1555 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1556 exit(1);
1557 }
9df3437f 1558 codec->pix_fmt = icodec->pix_fmt;
1629626f
FB
1559 codec->width = icodec->width;
1560 codec->height = icodec->height;
ff8cc24b 1561 codec->has_b_frames = icodec->has_b_frames;
1629626f 1562 break;
cf7fc795
FB
1563 case CODEC_TYPE_SUBTITLE:
1564 break;
1629626f 1565 default:
0f4e8165 1566 abort();
1629626f
FB
1567 }
1568 } else {
1569 switch(codec->codec_type) {
1570 case CODEC_TYPE_AUDIO:
f5a478f6 1571 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
85f07f22 1572 goto fail;
115329f1 1573
85f07f22
FB
1574 if (codec->channels == icodec->channels &&
1575 codec->sample_rate == icodec->sample_rate) {
1576 ost->audio_resample = 0;
1577 } else {
e0d2714a 1578 if (codec->channels != icodec->channels &&
23c99253
MN
1579 (icodec->codec_id == CODEC_ID_AC3 ||
1580 icodec->codec_id == CODEC_ID_DTS)) {
1581 /* Special case for 5:1 AC3 and DTS input */
e0d2714a 1582 /* and mono or stereo output */
6dc96cb0
J
1583 /* Request specific number of channels */
1584 icodec->channels = codec->channels;
1585 if (codec->sample_rate == icodec->sample_rate)
1586 ost->audio_resample = 0;
1587 else {
1588 ost->audio_resample = 1;
6dc96cb0 1589 }
e0d2714a 1590 } else {
115329f1 1591 ost->audio_resample = 1;
986ebcdb
MN
1592 }
1593 }
ff4905a5 1594 if(audio_sync_method>1)
986ebcdb
MN
1595 ost->audio_resample = 1;
1596
1597 if(ost->audio_resample){
1598 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1599 codec->sample_rate, icodec->sample_rate);
1600 if(!ost->resample){
1601 printf("Can't resample. Aborting.\n");
0f4e8165 1602 abort();
e0d2714a 1603 }
85f07f22
FB
1604 }
1605 ist->decoding_needed = 1;
1606 ost->encoding_needed = 1;
1629626f
FB
1607 break;
1608 case CODEC_TYPE_VIDEO:
c3f11d19
LA
1609 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1610 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1611 ost->video_resample = ((codec->width != icodec->width -
1612 (frame_leftBand + frame_rightBand) +
1613 (frame_padleft + frame_padright)) ||
1614 (codec->height != icodec->height -
1615 (frame_topBand + frame_bottomBand) +
18a54b04
LA
1616 (frame_padtop + frame_padbottom)) ||
1617 (codec->pix_fmt != icodec->pix_fmt));
c3f11d19 1618 if (ost->video_crop) {
34b10a57
D
1619 ost->topBand = frame_topBand;
1620 ost->leftBand = frame_leftBand;
c3f11d19
LA
1621 }
1622 if (ost->video_pad) {
1ff93ffc
TK
1623 ost->padtop = frame_padtop;
1624 ost->padleft = frame_padleft;
1625 ost->padbottom = frame_padbottom;
1626 ost->padright = frame_padright;
c3f11d19
LA
1627 if (!ost->video_resample) {
1628 avcodec_get_frame_defaults(&ost->pict_tmp);
1629 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1630 codec->width, codec->height ) )
1631 goto fail;
1632 }
1633 }
1634 if (ost->video_resample) {
2de28abb 1635 avcodec_get_frame_defaults(&ost->pict_tmp);
18a54b04 1636 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
eddc482d
BC
1637 codec->width, codec->height ) ) {
1638 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
7a168618 1639 exit(1);
eddc482d 1640 }
9de8e6ac 1641 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
18a54b04
LA
1642 ost->img_resample_ctx = sws_getContext(
1643 icodec->width - (frame_leftBand + frame_rightBand),
1644 icodec->height - (frame_topBand + frame_bottomBand),
1645 icodec->pix_fmt,
07d0cdfc
LA
1646 codec->width - (frame_padleft + frame_padright),
1647 codec->height - (frame_padtop + frame_padbottom),
18a54b04
LA
1648 codec->pix_fmt,
1649 sws_flags, NULL, NULL, NULL);
0b50ac8a
LA
1650 if (ost->img_resample_ctx == NULL) {
1651 fprintf(stderr, "Cannot get resampling context\n");
1652 exit(1);
1653 }
18a54b04 1654 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
85f07f22
FB
1655 }
1656 ost->encoding_needed = 1;
1657 ist->decoding_needed = 1;
1629626f 1658 break;
cf7fc795
FB
1659 case CODEC_TYPE_SUBTITLE:
1660 ost->encoding_needed = 1;
1661 ist->decoding_needed = 1;
1662 break;
1629626f 1663 default:
0f4e8165 1664 abort();
cf7fc795 1665 break;
85f07f22 1666 }
1629626f 1667 /* two pass mode */
115329f1 1668 if (ost->encoding_needed &&
1629626f
FB
1669 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1670 char logfilename[1024];
1671 FILE *f;
1672 int size;
1673 char *logbuffer;
115329f1
DB
1674
1675 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1676 pass_logfilename ?
1629626f
FB
1677 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1678 if (codec->flags & CODEC_FLAG_PASS1) {
1679 f = fopen(logfilename, "w");
1680 if (!f) {
1681 perror(logfilename);
1682 exit(1);
1683 }
1684 ost->logfile = f;
1685 } else {
1686 /* read the log file */
1687 f = fopen(logfilename, "r");
1688 if (!f) {
1689 perror(logfilename);
1690 exit(1);
1691 }
1692 fseek(f, 0, SEEK_END);
1693 size = ftell(f);
1694 fseek(f, 0, SEEK_SET);
1695 logbuffer = av_malloc(size + 1);
1696 if (!logbuffer) {
1697 fprintf(stderr, "Could not allocate log buffer\n");
1698 exit(1);
1699 }
4776fa92 1700 size = fread(logbuffer, 1, size, f);
1629626f
FB
1701 fclose(f);
1702 logbuffer[size] = '\0';
1703 codec->stats_in = logbuffer;
5abdb4b1 1704 }
5abdb4b1
FB
1705 }
1706 }
8a6cb114
MN
1707 if(codec->codec_type == CODEC_TYPE_VIDEO){
1708 int size= codec->width * codec->height;
1709 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1710 }
85f07f22
FB
1711 }
1712
8a6cb114
MN
1713 if (!bit_buffer)
1714 bit_buffer = av_malloc(bit_buffer_size);
1715 if (!bit_buffer)
1716 goto fail;
1717
1629626f
FB
1718 /* dump the file output parameters - cannot be done before in case
1719 of stream copy */
1720 for(i=0;i<nb_output_files;i++) {
1721 dump_format(output_files[i], i, output_files[i]->filename, 1);
1722 }
1723
1724 /* dump the stream mapping */
d8019eb5
AD
1725 if (verbose >= 0) {
1726 fprintf(stderr, "Stream mapping:\n");
1727 for(i=0;i<nb_ostreams;i++) {
1728 ost = ost_table[i];
b4a3389e 1729 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
d8019eb5
AD
1730 ist_table[ost->source_index]->file_index,
1731 ist_table[ost->source_index]->index,
115329f1 1732 ost->file_index,
d8019eb5 1733 ost->index);
b4a3389e
WG
1734 if (ost->sync_ist != ist_table[ost->source_index])
1735 fprintf(stderr, " [sync #%d.%d]",
1736 ost->sync_ist->file_index,
1737 ost->sync_ist->index);
1738 fprintf(stderr, "\n");
d8019eb5 1739 }
1629626f
FB
1740 }
1741
85f07f22
FB
1742 /* open each encoder */
1743 for(i=0;i<nb_ostreams;i++) {
1744 ost = ost_table[i];
1745 if (ost->encoding_needed) {
1746 AVCodec *codec;
01f4895c 1747 codec = avcodec_find_encoder(ost->st->codec->codec_id);
85f07f22 1748 if (!codec) {
115329f1 1749 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
85f07f22
FB
1750 ost->file_index, ost->index);
1751 exit(1);
1752 }
01f4895c 1753 if (avcodec_open(ost->st->codec, codec) < 0) {
115329f1 1754 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
1755 ost->file_index, ost->index);
1756 exit(1);
1757 }
01f4895c 1758 extra_size += ost->st->codec->extradata_size;
85f07f22
FB
1759 }
1760 }
1761
1762 /* open each decoder */
1763 for(i=0;i<nb_istreams;i++) {
1764 ist = ist_table[i];
1765 if (ist->decoding_needed) {
1766 AVCodec *codec;
01f4895c 1767 codec = avcodec_find_decoder(ist->st->codec->codec_id);
85f07f22 1768 if (!codec) {
115329f1 1769 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
01f4895c 1770 ist->st->codec->codec_id, ist->file_index, ist->index);
85f07f22
FB
1771 exit(1);
1772 }
01f4895c 1773 if (avcodec_open(ist->st->codec, codec) < 0) {
115329f1 1774 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
85f07f22
FB
1775 ist->file_index, ist->index);
1776 exit(1);
1777 }
01f4895c
MN
1778 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1779 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
85f07f22
FB
1780 }
1781 }
1782
1783 /* init pts */
1784 for(i=0;i<nb_istreams;i++) {
1785 ist = ist_table[i];
bb270c08 1786 is = input_files[ist->file_index];
e7d0374f 1787 ist->pts = 0;
fec401f7 1788 ist->next_pts=0;
de2aeaef
MN
1789 if( input_files_ts_offset[ist->file_index] != -is->start_time
1790 && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
fdb86eb1 1791 ist->next_pts= AV_NOPTS_VALUE;
ff4905a5 1792 ist->is_start = 1;
85f07f22 1793 }
bd1b79a1 1794
0a38bafd
PB
1795 /* set meta data information from input file if required */
1796 for (i=0;i<nb_meta_data_maps;i++) {
1797 AVFormatContext *out_file;
1798 AVFormatContext *in_file;
1799
1800 int out_file_index = meta_data_maps[i].out_file;
1801 int in_file_index = meta_data_maps[i].in_file;
1802 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1803 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
8fa36ae0 1804 ret = AVERROR(EINVAL);
0a38bafd
PB
1805 goto fail;
1806 }
1807 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1808 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
8fa36ae0 1809 ret = AVERROR(EINVAL);
0a38bafd 1810 goto fail;
115329f1
DB
1811 }
1812
0a38bafd
PB
1813 out_file = output_files[out_file_index];
1814 in_file = input_files[in_file_index];
1815
1816 strcpy(out_file->title, in_file->title);
1817 strcpy(out_file->author, in_file->author);
1818 strcpy(out_file->copyright, in_file->copyright);
1819 strcpy(out_file->comment, in_file->comment);
1820 strcpy(out_file->album, in_file->album);
1821 out_file->year = in_file->year;
1822 out_file->track = in_file->track;
1823 strcpy(out_file->genre, in_file->genre);
1824 }
115329f1 1825
85f07f22
FB
1826 /* open files and write file headers */
1827 for(i=0;i<nb_output_files;i++) {
1828 os = output_files[i];
79fdaa4c 1829 if (av_write_header(os) < 0) {
65bf3c53 1830 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
8fa36ae0 1831 ret = AVERROR(EINVAL);
a38469e1
FB
1832 goto fail;
1833 }
6d1ba1ac
LA
1834 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1835 want_sdp = 0;
1836 }
1837 }
1838 if (want_sdp) {
1839 print_sdp(output_files, nb_output_files);
85f07f22
FB
1840 }
1841
d8019eb5 1842 if ( !using_stdin && verbose >= 0) {
d9a916e2 1843 fprintf(stderr, "Press [q] to stop encoding\n");
b51469a0
LS
1844 url_set_interrupt_cb(decode_interrupt_cb);
1845 }
a38469e1
FB
1846 term_init();
1847
cb09b2ed 1848 key = -1;
7fc98937 1849 timer_start = av_gettime();
51bd4565 1850
d9a916e2 1851 for(; received_sigterm == 0;) {
85f07f22
FB
1852 int file_index, ist_index;
1853 AVPacket pkt;
a9aeda81
PB
1854 double ipts_min;
1855 double opts_min;
23ffe323 1856
85f07f22 1857 redo:
a9aeda81
PB
1858 ipts_min= 1e100;
1859 opts_min= 1e100;
a38469e1 1860 /* if 'q' pressed, exits */
d9a916e2 1861 if (!using_stdin) {
b51469a0
LS
1862 if (q_pressed)
1863 break;
cb09b2ed
PG
1864 /* read_key() returns 0 on EOF */
1865 key = read_key();
1866 if (key == 'q')
1867 break;
1868 }
a38469e1 1869
ec5517d5
FB
1870 /* select the stream that we must read now by looking at the
1871 smallest output pts */
85f07f22 1872 file_index = -1;
ec5517d5 1873 for(i=0;i<nb_ostreams;i++) {
23ffe323 1874 double ipts, opts;
ec5517d5
FB
1875 ost = ost_table[i];
1876 os = output_files[ost->file_index];
1877 ist = ist_table[ost->source_index];
01f4895c
MN
1878 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1879 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
23ffe323 1880 else
c0df9d75 1881 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
23ffe323
MN
1882 ipts = (double)ist->pts;
1883 if (!file_table[ist->file_index].eof_reached){
1884 if(ipts < ipts_min) {
1885 ipts_min = ipts;
1886 if(input_sync ) file_index = ist->file_index;
1887 }
1888 if(opts < opts_min) {
1889 opts_min = opts;
1890 if(!input_sync) file_index = ist->file_index;
1891 }
85f07f22 1892 }
01f4895c 1893 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
7ca60994
MN
1894 file_index= -1;
1895 break;
1896 }
85f07f22
FB
1897 }
1898 /* if none, if is finished */
51bd4565 1899 if (file_index < 0) {
85f07f22 1900 break;
ec5517d5
FB
1901 }
1902
85f07f22 1903 /* finish if recording time exhausted */
23ffe323 1904 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
85f07f22 1905 break;
ec5517d5 1906
b6e16b86 1907 /* finish if limit size exhausted */
f9645d7c 1908 if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
b6e16b86
C
1909 break;
1910
254abc2e 1911 /* read a frame from it and output it in the fifo */
85f07f22 1912 is = input_files[file_index];
254abc2e 1913 if (av_read_frame(is, &pkt) < 0) {
85f07f22 1914 file_table[file_index].eof_reached = 1;
d24ce947
AB
1915 if (opt_shortest)
1916 break;
1917 else
1918 continue;
85f07f22 1919 }
303e50e6 1920
254abc2e 1921 if (do_pkt_dump) {
750f0e1f 1922 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
817b23ff 1923 }
79fdaa4c
FB
1924 /* the following test is needed in case new streams appear
1925 dynamically in stream : we ignore them */
1926 if (pkt.stream_index >= file_table[file_index].nb_streams)
bf5af568 1927 goto discard_packet;
85f07f22
FB
1928 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1929 ist = ist_table[ist_index];
bf5af568
FB
1930 if (ist->discard)
1931 goto discard_packet;
85f07f22 1932
fec401f7
MN
1933 if (pkt.dts != AV_NOPTS_VALUE)
1934 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1935 if (pkt.pts != AV_NOPTS_VALUE)
1936 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1937
949b1a13 1938// 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 1939 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
81d6d520
MN
1940 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1941 int64_t delta= pkt_dts - ist->next_pts;
1942 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
72bd8100
MN
1943 input_files_ts_offset[ist->file_index]-= delta;
1944 if (verbose > 2)
4733abcb 1945 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
fec401f7
MN
1946 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1947 if(pkt.pts != AV_NOPTS_VALUE)
1948 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
72bd8100
MN
1949 }
1950 }
1951
8831db5c 1952 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
a700a6ae 1953 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
d8019eb5
AD
1954
1955 if (verbose >= 0)
1956 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1957 ist->file_index, ist->index);
1958
a700a6ae
FB
1959 av_free_packet(&pkt);
1960 goto redo;
fe08925f 1961 }
cf7fc795 1962
bf5af568 1963 discard_packet:
85f07f22 1964 av_free_packet(&pkt);
115329f1 1965
ec5517d5
FB
1966 /* dump report by using the output first video and audio streams */
1967 print_report(output_files, ost_table, nb_ostreams, 0);
85f07f22 1968 }
a700a6ae
FB
1969
1970 /* at the end of stream, we must flush the decoder buffers */
1971 for(i=0;i<nb_istreams;i++) {
1972 ist = ist_table[i];
1973 if (ist->decoding_needed) {
1974 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1975 }
1976 }
1977
a38469e1 1978 term_exit();
85f07f22 1979
c4e37247
MN
1980 /* write the trailer if needed and close file */
1981 for(i=0;i<nb_output_files;i++) {
1982 os = output_files[i];
1983 av_write_trailer(os);
1984 }
1985
37f5cd5a
MN
1986 /* dump report by using the first video and audio streams */
1987 print_report(output_files, ost_table, nb_ostreams, 1);
1988
85f07f22
FB
1989 /* close each encoder */
1990 for(i=0;i<nb_ostreams;i++) {
1991 ost = ost_table[i];
1992 if (ost->encoding_needed) {
01f4895c
MN
1993 av_freep(&ost->st->codec->stats_in);
1994 avcodec_close(ost->st->codec);
85f07f22
FB
1995 }
1996 }
115329f1 1997
85f07f22
FB
1998 /* close each decoder */
1999 for(i=0;i<nb_istreams;i++) {
2000 ist = ist_table[i];
2001 if (ist->decoding_needed) {
01f4895c 2002 avcodec_close(ist->st->codec);
85f07f22
FB
2003 }
2004 }
85f07f22 2005
85f07f22 2006 /* finished ! */
115329f1 2007
85f07f22
FB
2008 ret = 0;
2009 fail1:
83b07470 2010 av_freep(&bit_buffer);
0f1578af 2011 av_free(file_table);
bdc4796f 2012
85f07f22
FB
2013 if (ist_table) {
2014 for(i=0;i<nb_istreams;i++) {
2015 ist = ist_table[i];
0f1578af 2016 av_free(ist);
85f07f22 2017 }
0f1578af 2018 av_free(ist_table);
85f07f22
FB
2019 }
2020 if (ost_table) {
2021 for(i=0;i<nb_ostreams;i++) {
2022 ost = ost_table[i];
2023 if (ost) {
5abdb4b1
FB
2024 if (ost->logfile) {
2025 fclose(ost->logfile);
2026 ost->logfile = NULL;
2027 }
f5a478f6
RS
2028 av_fifo_free(&ost->fifo); /* works even if fifo is not
2029 initialized but set to zero */
0f1578af 2030 av_free(ost->pict_tmp.data[0]);
85f07f22 2031 if (ost->video_resample)
18a54b04 2032 sws_freeContext(ost->img_resample_ctx);
85f07f22
FB
2033 if (ost->audio_resample)
2034 audio_resample_close(ost->resample);
0f1578af 2035 av_free(ost);
85f07f22
FB
2036 }
2037 }
0f1578af 2038 av_free(ost_table);
85f07f22
FB
2039 }
2040 return ret;
2041 fail:
8fa36ae0 2042 ret = AVERROR(ENOMEM);
85f07f22
FB
2043 goto fail1;
2044}
2045
2046#if 0
2047int file_read(const char *filename)
2048{
2049 URLContext *h;
2050 unsigned char buffer[1024];
2051 int len, i;
2052
2053 if (url_open(&h, filename, O_RDONLY) < 0) {
2054 printf("could not open '%s'\n", filename);
2055 return -1;
2056 }
2057 for(;;) {
2058 len = url_read(h, buffer, sizeof(buffer));
2059 if (len <= 0)
2060 break;
2061 for(i=0;i<len;i++) putchar(buffer[i]);
2062 }
2063 url_close(h);
2064 return 0;
2065}
2066#endif
2067
b29f97d1 2068static void opt_format(const char *arg)
85f07f22 2069{
817b23ff
FB
2070 /* compatibility stuff for pgmyuv */
2071 if (!strcmp(arg, "pgmyuv")) {
5b6d5596 2072 pgmyuv_compatibility_hack=1;
9286699a 2073// opt_image_format(arg);
5b6d5596 2074 arg = "image2";
17ceb4f9 2075 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
817b23ff
FB
2076 }
2077
79fdaa4c
FB
2078 file_iformat = av_find_input_format(arg);
2079 file_oformat = guess_format(arg, NULL, NULL);
2080 if (!file_iformat && !file_oformat) {
2081 fprintf(stderr, "Unknown input or output format: %s\n", arg);
85f07f22
FB
2082 exit(1);
2083 }
85f07f22
FB
2084}
2085
b29f97d1 2086static void opt_video_rc_eq(char *arg)
3aa102be
MN
2087{
2088 video_rc_eq = arg;
2089}
2090
b29f97d1 2091static void opt_video_rc_override_string(char *arg)
ac2830ec
MN
2092{
2093 video_rc_override_string = arg;
2094}
2095
f4f3223f
MN
2096static void opt_me_threshold(const char *arg)
2097{
2098 me_threshold = atoi(arg);
2099}
2100
f068206e
BE
2101static void opt_verbose(const char *arg)
2102{
2103 verbose = atoi(arg);
ab1c6dc9 2104 av_log_level = atoi(arg);
f068206e
BE
2105}
2106
b29f97d1 2107static void opt_frame_rate(const char *arg)
85f07f22 2108{
b33ece16 2109 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
445f1b83 2110 fprintf(stderr, "Incorrect frame rate\n");
bb270c08 2111 exit(1);
445f1b83 2112 }
85f07f22
FB
2113}
2114
b29f97d1 2115static void opt_frame_crop_top(const char *arg)
ab6d194a 2116{
115329f1 2117 frame_topBand = atoi(arg);
ab6d194a
MN
2118 if (frame_topBand < 0) {
2119 fprintf(stderr, "Incorrect top crop size\n");
2120 exit(1);
2121 }
2122 if ((frame_topBand % 2) != 0) {
2123 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2124 exit(1);
2125 }
2126 if ((frame_topBand) >= frame_height){
bb270c08 2127 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2128 exit(1);
2129 }
2130 frame_height -= frame_topBand;
2131}
2132
b29f97d1 2133static void opt_frame_crop_bottom(const char *arg)
ab6d194a
MN
2134{
2135 frame_bottomBand = atoi(arg);
2136 if (frame_bottomBand < 0) {
2137 fprintf(stderr, "Incorrect bottom crop size\n");
2138 exit(1);
2139 }
2140 if ((frame_bottomBand % 2) != 0) {
2141 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
115329f1 2142 exit(1);
ab6d194a
MN
2143 }
2144 if ((frame_bottomBand) >= frame_height){
bb270c08 2145 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2146 exit(1);
2147 }
2148 frame_height -= frame_bottomBand;
2149}
2150
b29f97d1 2151static void opt_frame_crop_left(const char *arg)
ab6d194a
MN
2152{
2153 frame_leftBand = atoi(arg);
2154 if (frame_leftBand < 0) {
2155 fprintf(stderr, "Incorrect left crop size\n");
2156 exit(1);
2157 }
2158 if ((frame_leftBand % 2) != 0) {
2159 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2160 exit(1);
2161 }
2162 if ((frame_leftBand) >= frame_width){
bb270c08 2163 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2164 exit(1);
2165 }
2166 frame_width -= frame_leftBand;
2167}
2168
b29f97d1 2169static void opt_frame_crop_right(const char *arg)
ab6d194a
MN
2170{
2171 frame_rightBand = atoi(arg);
2172 if (frame_rightBand < 0) {
2173 fprintf(stderr, "Incorrect right crop size\n");
2174 exit(1);
2175 }
2176 if ((frame_rightBand % 2) != 0) {
2177 fprintf(stderr, "Right crop size must be a multiple of 2\n");
115329f1 2178 exit(1);
ab6d194a
MN
2179 }
2180 if ((frame_rightBand) >= frame_width){
bb270c08 2181 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2182 exit(1);
2183 }
2184 frame_width -= frame_rightBand;
2185}
2186
b29f97d1 2187static void opt_frame_size(const char *arg)
85f07f22 2188{
b33ece16 2189 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
85f07f22
FB
2190 fprintf(stderr, "Incorrect frame size\n");
2191 exit(1);
2192 }
2193 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2194 fprintf(stderr, "Frame size must be a multiple of 2\n");
2195 exit(1);
2196 }
2197}
2198
1ff93ffc
TK
2199
2200#define SCALEBITS 10
2201#define ONE_HALF (1 << (SCALEBITS - 1))
bb270c08 2202#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
1ff93ffc
TK
2203
2204#define RGB_TO_Y(r, g, b) \
2205((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2206 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2207
2208#define RGB_TO_U(r1, g1, b1, shift)\
2209(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2210 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2211
2212#define RGB_TO_V(r1, g1, b1, shift)\
2213(((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2214 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2215
2216static void opt_pad_color(const char *arg) {
2217 /* Input is expected to be six hex digits similar to
2218 how colors are expressed in html tags (but without the #) */
2219 int rgb = strtol(arg, NULL, 16);
2220 int r,g,b;
115329f1
DB
2221
2222 r = (rgb >> 16);
1ff93ffc
TK
2223 g = ((rgb >> 8) & 255);
2224 b = (rgb & 255);
2225
2226 padcolor[0] = RGB_TO_Y(r,g,b);
2227 padcolor[1] = RGB_TO_U(r,g,b,0);
2228 padcolor[2] = RGB_TO_V(r,g,b,0);
2229}
2230
2231static void opt_frame_pad_top(const char *arg)
2232{
115329f1 2233 frame_padtop = atoi(arg);
1ff93ffc
TK
2234 if (frame_padtop < 0) {
2235 fprintf(stderr, "Incorrect top pad size\n");
2236 exit(1);
2237 }
2238 if ((frame_padtop % 2) != 0) {
2239 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2240 exit(1);
2241 }
2242}
2243
2244static void opt_frame_pad_bottom(const char *arg)
2245{
115329f1 2246 frame_padbottom = atoi(arg);
1ff93ffc
TK
2247 if (frame_padbottom < 0) {
2248 fprintf(stderr, "Incorrect bottom pad size\n");
2249 exit(1);
2250 }
2251 if ((frame_padbottom % 2) != 0) {
2252 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2253 exit(1);
2254 }
2255}
2256
2257
2258static void opt_frame_pad_left(const char *arg)
2259{
115329f1 2260 frame_padleft = atoi(arg);
1ff93ffc
TK
2261 if (frame_padleft < 0) {
2262 fprintf(stderr, "Incorrect left pad size\n");
2263 exit(1);
2264 }
2265 if ((frame_padleft % 2) != 0) {
2266 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2267 exit(1);
2268 }
2269}
2270
2271
2272static void opt_frame_pad_right(const char *arg)
2273{
115329f1 2274 frame_padright = atoi(arg);
1ff93ffc
TK
2275 if (frame_padright < 0) {
2276 fprintf(stderr, "Incorrect right pad size\n");
2277 exit(1);
2278 }
2279 if ((frame_padright % 2) != 0) {
2280 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2281 exit(1);
2282 }
2283}
2284
c3b95b1d
SS
2285void list_pix_fmts(void)
2286{
2287 int i;
2288 char pix_fmt_str[128];
2289 for (i=-1; i < PIX_FMT_NB; i++) {
2290 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2291 fprintf(stdout, "%s\n", pix_fmt_str);
2292 }
2293}
1ff93ffc 2294
63167088
RS
2295static void opt_frame_pix_fmt(const char *arg)
2296{
c3b95b1d
SS
2297 if (strcmp(arg, "list"))
2298 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2299 else {
2300 list_pix_fmts();
2301 exit(0);
2302 }
63167088
RS
2303}
2304
5fe03e38
RS
2305static void opt_frame_aspect_ratio(const char *arg)
2306{
2307 int x = 0, y = 0;
2308 double ar = 0;
2309 const char *p;
115329f1 2310
5fe03e38
RS
2311 p = strchr(arg, ':');
2312 if (p) {
2313 x = strtol(arg, (char **)&arg, 10);
bb270c08
DB
2314 if (arg == p)
2315 y = strtol(arg+1, (char **)&arg, 10);
2316 if (x > 0 && y > 0)
2317 ar = (double)x / (double)y;
5fe03e38
RS
2318 } else
2319 ar = strtod(arg, (char **)&arg);
2320
2321 if (!ar) {
2322 fprintf(stderr, "Incorrect aspect ratio specification.\n");
bb270c08 2323 exit(1);
5fe03e38
RS
2324 }
2325 frame_aspect_ratio = ar;
2326}
2327
b29f97d1 2328static void opt_qscale(const char *arg)
85f07f22 2329{
158c7f05 2330 video_qscale = atof(arg);
4e64bead 2331 if (video_qscale <= 0 ||
158c7f05 2332 video_qscale > 255) {
4e64bead 2333 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
85f07f22
FB
2334 exit(1);
2335 }
2336}
2337
b29f97d1 2338static void opt_qdiff(const char *arg)
9cdd6a24
MN
2339{
2340 video_qdiff = atoi(arg);
2341 if (video_qdiff < 0 ||
2342 video_qdiff > 31) {
2343 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2344 exit(1);
2345 }
2346}
2347
b29f97d1 2348static void opt_strict(const char *arg)
f560dd82
MN
2349{
2350 strict= atoi(arg);
2351}
2352
bb198e19
MN
2353static void opt_top_field_first(const char *arg)
2354{
2355 top_field_first= atoi(arg);
2356}
2357
9c3d33d6
MN
2358static void opt_thread_count(const char *arg)
2359{
2360 thread_count= atoi(arg);
2450cff2 2361#if !defined(HAVE_THREADS)
d8019eb5
AD
2362 if (verbose >= 0)
2363 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
842b556a 2364#endif
9c3d33d6
MN
2365}
2366
b29f97d1 2367static void opt_audio_rate(const char *arg)
85f07f22
FB
2368{
2369 audio_sample_rate = atoi(arg);
2370}
2371
b29f97d1 2372static void opt_audio_channels(const char *arg)
85f07f22
FB
2373{
2374 audio_channels = atoi(arg);
2375}
2376
b29f97d1 2377static void opt_video_channel(const char *arg)
a5df11ab
FB
2378{
2379 video_channel = strtol(arg, NULL, 0);
2380}
2381
e3ee3283
AB
2382static void opt_video_standard(const char *arg)
2383{
2384 video_standard = av_strdup(arg);
2385}
2386
4a897224 2387static void opt_codec(int *pstream_copy, char **pcodec_name,
cf7fc795 2388 int codec_type, const char *arg)
85f07f22 2389{
4a897224 2390 av_freep(pcodec_name);
1629626f 2391 if (!strcmp(arg, "copy")) {
cf7fc795 2392 *pstream_copy = 1;
85f07f22 2393 } else {
4a897224 2394 *pcodec_name = av_strdup(arg);
85f07f22
FB
2395 }
2396}
2397
cf7fc795
FB
2398static void opt_audio_codec(const char *arg)
2399{
4a897224 2400 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
cf7fc795
FB
2401}
2402
b2a2197e
MN
2403static void opt_audio_tag(const char *arg)
2404{
2405 char *tail;
2406 audio_codec_tag= strtol(arg, &tail, 0);
2407
2408 if(!tail || *tail)
2409 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2410}
2411
2412static void opt_video_tag(const char *arg)
2413{
2414 char *tail;
2415 video_codec_tag= strtol(arg, &tail, 0);
2416
2417 if(!tail || *tail)
2418 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2419}
2420
d0f596b4 2421#ifdef CONFIG_VHOOK
b29f97d1 2422static void add_frame_hooker(const char *arg)
10d104e4
PG
2423{
2424 int argc = 0;
2425 char *argv[64];
2426 int i;
e9a9e0c2 2427 char *args = av_strdup(arg);
10d104e4 2428
bee0d9e5
CY
2429 using_vhook = 1;
2430
10d104e4
PG
2431 argv[0] = strtok(args, " ");
2432 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2433 }
2434
2435 i = frame_hook_add(argc, argv);
2436
2437 if (i != 0) {
2438 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2439 exit(1);
2440 }
2441}
d0f596b4 2442#endif
10d104e4 2443
b29f97d1 2444static void opt_video_codec(const char *arg)
85f07f22 2445{
4a897224 2446 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
cf7fc795 2447}
85f07f22 2448
cf7fc795
FB
2449static void opt_subtitle_codec(const char *arg)
2450{
4a897224 2451 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
85f07f22
FB
2452}
2453
b29f97d1 2454static void opt_map(const char *arg)
85f07f22
FB
2455{
2456 AVStreamMap *m;
2457 const char *p;
2458
2459 p = arg;
2460 m = &stream_maps[nb_stream_maps++];
2461
2462 m->file_index = strtol(arg, (char **)&p, 0);
2463 if (*p)
2464 p++;
a5dc85ef
J
2465
2466 m->stream_index = strtol(p, (char **)&p, 0);
b4a3389e
WG
2467 if (*p) {
2468 p++;
2469 m->sync_file_index = strtol(p, (char **)&p, 0);
2470 if (*p)
2471 p++;
2472 m->sync_stream_index = strtol(p, (char **)&p, 0);
2473 } else {
2474 m->sync_file_index = m->file_index;
2475 m->sync_stream_index = m->stream_index;
2476 }
85f07f22
FB
2477}
2478
0a38bafd
PB
2479static void opt_map_meta_data(const char *arg)
2480{
2481 AVMetaDataMap *m;
2482 const char *p;
115329f1 2483
0a38bafd
PB
2484 p = arg;
2485 m = &meta_data_maps[nb_meta_data_maps++];
2486
2487 m->out_file = strtol(arg, (char **)&p, 0);
2488 if (*p)
2489 p++;
2490
2491 m->in_file = strtol(p, (char **)&p, 0);
2492}
2493
b29f97d1 2494static void opt_recording_time(const char *arg)
85f07f22
FB
2495{
2496 recording_time = parse_date(arg, 1);
2497}
2498
8831db5c
MN
2499static void opt_start_time(const char *arg)
2500{
2501 start_time = parse_date(arg, 1);
2502}
2503
4568325a
RS
2504static void opt_rec_timestamp(const char *arg)
2505{
2506 rec_timestamp = parse_date(arg, 0) / 1000000;
2507}
2508
a6a92a9a
WG
2509static void opt_input_ts_offset(const char *arg)
2510{
2511 input_ts_offset = parse_date(arg, 1);
2512}
2513
4a897224
NG
2514static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2515{
4f489292 2516 char *codec_string = encoder ? "encoder" : "decoder";
4a897224
NG
2517 AVCodec *codec;
2518
2519 if(!name)
2520 return CODEC_ID_NONE;
2521 codec = encoder ?
2522 avcodec_find_encoder_by_name(name) :
2523 avcodec_find_decoder_by_name(name);
2524 if(!codec) {
4f489292 2525 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
4a897224
NG
2526 exit(1);
2527 }
2528 if(codec->type != type) {
4f489292 2529 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
4a897224
NG
2530 exit(1);
2531 }
2532 return codec->id;
2533}
2534
b29f97d1 2535static void opt_input_file(const char *filename)
85f07f22
FB
2536{
2537 AVFormatContext *ic;
2538 AVFormatParameters params, *ap = &params;
14bea432 2539 int err, i, ret, rfps, rfps_base;
bd1b79a1 2540 int64_t timestamp;
85f07f22 2541
b242baa4
FB
2542 if (!strcmp(filename, "-"))
2543 filename = "pipe:";
2544
115329f1 2545 using_stdin |= !strncmp(filename, "pipe:", 5) ||
d9a916e2
CY
2546 !strcmp( filename, "/dev/stdin" );
2547
85f07f22 2548 /* get default parameters from command line */
4eb72c6b
NS
2549 ic = av_alloc_format_context();
2550
79fdaa4c 2551 memset(ap, 0, sizeof(*ap));
4eb72c6b 2552 ap->prealloced_context = 1;
79fdaa4c
FB
2553 ap->sample_rate = audio_sample_rate;
2554 ap->channels = audio_channels;
b33ece16
SS
2555 ap->time_base.den = frame_rate.num;
2556 ap->time_base.num = frame_rate.den;
1ff93ffc
TK
2557 ap->width = frame_width + frame_padleft + frame_padright;
2558 ap->height = frame_height + frame_padtop + frame_padbottom;
63167088 2559 ap->pix_fmt = frame_pix_fmt;
2639c651
RS
2560 ap->channel = video_channel;
2561 ap->standard = video_standard;
4a897224
NG
2562 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2563 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
5b6d5596
MN
2564 if(pgmyuv_compatibility_hack)
2565 ap->video_codec_id= CODEC_ID_PGMYUV;
79fdaa4c 2566
4eb72c6b 2567 for(i=0; i<opt_name_count; i++){
bd31a388 2568 const AVOption *opt;
4eb72c6b 2569 double d= av_get_double(avformat_opts, opt_names[i], &opt);
e146ce52 2570 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
4eb72c6b
NS
2571 av_set_double(ic, opt_names[i], d);
2572 }
79fdaa4c
FB
2573 /* open the input file with generic libav function */
2574 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
85f07f22 2575 if (err < 0) {
79fdaa4c 2576 print_error(filename, err);
85f07f22
FB
2577 exit(1);
2578 }
30bc6613 2579
5894e1bb
VP
2580 ic->loop_input = loop_input;
2581
79fdaa4c
FB
2582 /* If not enough info to get the stream parameters, we decode the
2583 first frames to get it. (used in mpeg case for example) */
2584 ret = av_find_stream_info(ic);
d8019eb5 2585 if (ret < 0 && verbose >= 0) {
85f07f22
FB
2586 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2587 exit(1);
2588 }
2589
bd1b79a1
MN
2590 timestamp = start_time;
2591 /* add the stream start time */
2592 if (ic->start_time != AV_NOPTS_VALUE)
2593 timestamp += ic->start_time;
2594
254abc2e
FB
2595 /* if seeking requested, we execute it */
2596 if (start_time != 0) {
3ba1438d 2597 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
254abc2e 2598 if (ret < 0) {
115329f1 2599 fprintf(stderr, "%s: could not seek to position %0.3f\n",
254abc2e
FB
2600 filename, (double)timestamp / AV_TIME_BASE);
2601 }
2602 /* reset seek info */
2603 start_time = 0;
2604 }
2605
85f07f22
FB
2606 /* update the current parameters so that they match the one of the input stream */
2607 for(i=0;i<ic->nb_streams;i++) {
637b5326 2608 int j;
01f4895c 2609 AVCodecContext *enc = ic->streams[i]->codec;
c62c07d3
MN
2610 if(thread_count>1)
2611 avcodec_thread_init(enc, thread_count);
c62c07d3 2612 enc->thread_count= thread_count;
85f07f22
FB
2613 switch(enc->codec_type) {
2614 case CODEC_TYPE_AUDIO:
637b5326 2615 for(j=0; j<opt_name_count; j++){
bd31a388 2616 const AVOption *opt;
23b254fb 2617 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
e146ce52 2618 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
637b5326
MN
2619 av_set_double(enc, opt_names[j], d);
2620 }
e0d2714a 2621 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
85f07f22
FB
2622 audio_channels = enc->channels;
2623 audio_sample_rate = enc->sample_rate;
b4aea108 2624 if(audio_disable)
f3356e9c 2625 ic->streams[i]->discard= AVDISCARD_ALL;
85f07f22
FB
2626 break;
2627 case CODEC_TYPE_VIDEO:
637b5326 2628 for(j=0; j<opt_name_count; j++){
bd31a388 2629 const AVOption *opt;
23b254fb 2630 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
e146ce52 2631 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
637b5326
MN
2632 av_set_double(enc, opt_names[j], d);
2633 }
85f07f22
FB
2634 frame_height = enc->height;
2635 frame_width = enc->width;
bb270c08
DB
2636 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2637 frame_pix_fmt = enc->pix_fmt;
c0df9d75
MN
2638 rfps = ic->streams[i]->r_frame_rate.num;
2639 rfps_base = ic->streams[i]->r_frame_rate.den;
637b5326 2640 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
f4f3223f
MN
2641 if(me_threshold)
2642 enc->debug |= FF_DEBUG_MV;
d7425f59 2643
115329f1 2644 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
d8019eb5
AD
2645
2646 if (verbose >= 0)
386c88de 2647 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
c0df9d75 2648 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
d8019eb5 2649
15bc38e5 2650 (float)rfps / rfps_base, rfps, rfps_base);
79fdaa4c 2651 }
bf5af568 2652 /* update the current frame rate to match the stream frame rate */
b33ece16
SS
2653 frame_rate.num = rfps;
2654 frame_rate.den = rfps_base;
bdfcbbed
MK
2655
2656 enc->rate_emu = rate_emu;
b4aea108 2657 if(video_disable)
f3356e9c
MN
2658 ic->streams[i]->discard= AVDISCARD_ALL;
2659 else if(video_discard)
2660 ic->streams[i]->discard= video_discard;
85f07f22 2661 break;
254abc2e
FB
2662 case CODEC_TYPE_DATA:
2663 break;
cf7fc795 2664 case CODEC_TYPE_SUBTITLE:
11bf3847
AJ
2665 if(subtitle_disable)
2666 ic->streams[i]->discard = AVDISCARD_ALL;
cf7fc795 2667 break;
ae38261e
MB
2668 case CODEC_TYPE_UNKNOWN:
2669 break;
51bd4565 2670 default:
0f4e8165 2671 abort();
85f07f22
FB
2672 }
2673 }
115329f1 2674
85f07f22 2675 input_files[nb_input_files] = ic;
bd1b79a1 2676 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
85f07f22 2677 /* dump the file content */
d8019eb5
AD
2678 if (verbose >= 0)
2679 dump_format(ic, nb_input_files, filename, 0);
2680
85f07f22 2681 nb_input_files++;
79fdaa4c
FB
2682 file_iformat = NULL;
2683 file_oformat = NULL;
bdfcbbed 2684
2639c651 2685 video_channel = 0;
115329f1 2686
bdfcbbed 2687 rate_emu = 0;
85f07f22
FB
2688}
2689
11bf3847
AJ
2690static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2691 int *has_subtitle_ptr)
919f448d 2692{
11bf3847 2693 int has_video, has_audio, has_subtitle, i, j;
919f448d
FB
2694 AVFormatContext *ic;
2695
2696 has_video = 0;
2697 has_audio = 0;
11bf3847 2698 has_subtitle = 0;
919f448d
FB
2699 for(j=0;j<nb_input_files;j++) {
2700 ic = input_files[j];
2701 for(i=0;i<ic->nb_streams;i++) {
01f4895c 2702 AVCodecContext *enc = ic->streams[i]->codec;
919f448d
FB
2703 switch(enc->codec_type) {
2704 case CODEC_TYPE_AUDIO:
2705 has_audio = 1;
2706 break;
2707 case CODEC_TYPE_VIDEO:
2708 has_video = 1;
2709 break;
11bf3847
AJ
2710 case CODEC_TYPE_SUBTITLE:
2711 has_subtitle = 1;
2712 break;
6fb316d5 2713 case CODEC_TYPE_DATA:
ae38261e 2714 case CODEC_TYPE_UNKNOWN:
6fb316d5 2715 break;
51bd4565 2716 default:
0f4e8165 2717 abort();
919f448d
FB
2718 }
2719 }
2720 }
2721 *has_video_ptr = has_video;
2722 *has_audio_ptr = has_audio;
11bf3847 2723 *has_subtitle_ptr = has_subtitle;
919f448d
FB
2724}
2725
cf7fc795 2726static void new_video_stream(AVFormatContext *oc)
85f07f22
FB
2727{
2728 AVStream *st;
cf7fc795
FB
2729 AVCodecContext *video_enc;
2730 int codec_id;
115329f1 2731
cf7fc795
FB
2732 st = av_new_stream(oc, oc->nb_streams);
2733 if (!st) {
2734 fprintf(stderr, "Could not alloc stream\n");
2735 exit(1);
2736 }
54cc9c46 2737 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
748c2fca
MN
2738 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2739 video_bitstream_filters= NULL;
2740
cf7fc795 2741 if(thread_count>1)
01f4895c 2742 avcodec_thread_init(st->codec, thread_count);
115329f1 2743
01f4895c 2744 video_enc = st->codec;
115329f1 2745
cf7fc795
FB
2746 if(video_codec_tag)
2747 video_enc->codec_tag= video_codec_tag;
115329f1 2748
90ad92b3 2749 if( (video_global_header&1)
637b5326 2750 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
cf7fc795 2751 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
23b254fb 2752 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
637b5326
MN
2753 }
2754 if(video_global_header&2){
90ad92b3 2755 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
23b254fb 2756 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
637b5326 2757 }
90ad92b3 2758
cf7fc795
FB
2759 if (video_stream_copy) {
2760 st->stream_copy = 1;
2761 video_enc->codec_type = CODEC_TYPE_VIDEO;
2762 } else {
2763 char *p;
2764 int i;
2765 AVCodec *codec;
115329f1 2766
cf7fc795 2767 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
4a897224
NG
2768 if (video_codec_name)
2769 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
115329f1 2770
cf7fc795
FB
2771 video_enc->codec_id = codec_id;
2772 codec = avcodec_find_encoder(codec_id);
115329f1 2773
8bbf6db9 2774 for(i=0; i<opt_name_count; i++){
bd31a388 2775 const AVOption *opt;
23b254fb 2776 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
e146ce52 2777 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
8bbf6db9
MN
2778 av_set_double(video_enc, opt_names[i], d);
2779 }
115329f1 2780
b33ece16
SS
2781 video_enc->time_base.den = frame_rate.num;
2782 video_enc->time_base.num = frame_rate.den;
cf7fc795
FB
2783 if(codec && codec->supported_framerates){
2784 const AVRational *p= codec->supported_framerates;
b33ece16 2785 AVRational req= (AVRational){frame_rate.num, frame_rate.den};
cf7fc795
FB
2786 const AVRational *best=NULL;
2787 AVRational best_error= (AVRational){INT_MAX, 1};
2788 for(; p->den!=0; p++){
2789 AVRational error= av_sub_q(req, *p);
2790 if(error.num <0) error.num *= -1;
2791 if(av_cmp_q(error, best_error) < 0){
2792 best_error= error;
2793 best= p;
2794 }
2795 }
2796 video_enc->time_base.den= best->num;
2797 video_enc->time_base.num= best->den;
2798 }
115329f1 2799
cf7fc795
FB
2800 video_enc->width = frame_width + frame_padright + frame_padleft;
2801 video_enc->height = frame_height + frame_padtop + frame_padbottom;
e7268d51 2802 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
cf7fc795
FB
2803 video_enc->pix_fmt = frame_pix_fmt;
2804
2805 if(codec && codec->pix_fmts){
2806 const enum PixelFormat *p= codec->pix_fmts;
2807 for(; *p!=-1; p++){
2808 if(*p == video_enc->pix_fmt)
2809 break;
2810 }
2811 if(*p == -1)
2812 video_enc->pix_fmt = codec->pix_fmts[0];
2813 }
2814
babe0e8c 2815 if (intra_only)
cf7fc795
FB
2816 video_enc->gop_size = 0;
2817 if (video_qscale || same_quality) {
2818 video_enc->flags |= CODEC_FLAG_QSCALE;
115329f1 2819 video_enc->global_quality=
cf7fc795
FB
2820 st->quality = FF_QP2LAMBDA * video_qscale;
2821 }
2822
2823 if(intra_matrix)
2824 video_enc->intra_matrix = intra_matrix;
2825 if(inter_matrix)
2826 video_enc->inter_matrix = inter_matrix;
2827
cf7fc795 2828 video_enc->max_qdiff = video_qdiff;
cf7fc795 2829 video_enc->rc_eq = video_rc_eq;
cf7fc795
FB
2830 video_enc->thread_count = thread_count;
2831 p= video_rc_override_string;
2832 for(i=0; p; i++){
2833 int start, end, q;
2834 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2835 if(e!=3){
2836 fprintf(stderr, "error parsing rc_override\n");
2837 exit(1);
2838 }
115329f1
DB
2839 video_enc->rc_override=
2840 av_realloc(video_enc->rc_override,
cf7fc795
FB
2841 sizeof(RcOverride)*(i+1));
2842 video_enc->rc_override[i].start_frame= start;
2843 video_enc->rc_override[i].end_frame = end;
2844 if(q>0){
2845 video_enc->rc_override[i].qscale= q;
2846 video_enc->rc_override[i].quality_factor= 1.0;
2847 }
2848 else{
2849 video_enc->rc_override[i].qscale= 0;
2850 video_enc->rc_override[i].quality_factor= -q/100.0;
2851 }
2852 p= strchr(p, '/');
2853 if(p) p++;
2854 }
2855 video_enc->rc_override_count=i;
079e8cb9
BC
2856 if (!video_enc->rc_initial_buffer_occupancy)
2857 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
cf7fc795 2858 video_enc->me_threshold= me_threshold;
cf7fc795
FB
2859 video_enc->intra_dc_precision= intra_dc_precision - 8;
2860 video_enc->strict_std_compliance = strict;
cf7fc795 2861
cf7fc795
FB
2862 if (do_psnr)
2863 video_enc->flags|= CODEC_FLAG_PSNR;
115329f1 2864
cf7fc795
FB
2865 /* two pass mode */
2866 if (do_pass) {
2867 if (do_pass == 1) {
2868 video_enc->flags |= CODEC_FLAG_PASS1;
2869 } else {
2870 video_enc->flags |= CODEC_FLAG_PASS2;
2871 }
2872 }
2873 }
2874
2875 /* reset some key parameters */
2876 video_disable = 0;
4a897224 2877 av_freep(&video_codec_name);
cf7fc795
FB
2878 video_stream_copy = 0;
2879}
2880
2881static void new_audio_stream(AVFormatContext *oc)
2882{
2883 AVStream *st;
2884 AVCodecContext *audio_enc;
8bbf6db9 2885 int codec_id, i;
115329f1 2886
cf7fc795
FB
2887 st = av_new_stream(oc, oc->nb_streams);
2888 if (!st) {
2889 fprintf(stderr, "Could not alloc stream\n");
2890 exit(1);
2891 }
54cc9c46 2892 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
748c2fca
MN
2893
2894 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2895 audio_bitstream_filters= NULL;
2896
cf7fc795 2897 if(thread_count>1)
01f4895c 2898 avcodec_thread_init(st->codec, thread_count);
115329f1 2899
01f4895c 2900 audio_enc = st->codec;
cf7fc795 2901 audio_enc->codec_type = CODEC_TYPE_AUDIO;
f889d3f9 2902 audio_enc->strict_std_compliance = strict;
115329f1 2903
cf7fc795
FB
2904 if(audio_codec_tag)
2905 audio_enc->codec_tag= audio_codec_tag;
115329f1 2906
637b5326 2907 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
cf7fc795 2908 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
23b254fb 2909 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
637b5326 2910 }
cf7fc795
FB
2911 if (audio_stream_copy) {
2912 st->stream_copy = 1;
2913 audio_enc->channels = audio_channels;
2914 } else {
2915 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
115329f1 2916
8bbf6db9 2917 for(i=0; i<opt_name_count; i++){
bd31a388 2918 const AVOption *opt;
23b254fb 2919 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
e146ce52 2920 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
8bbf6db9
MN
2921 av_set_double(audio_enc, opt_names[i], d);
2922 }
115329f1 2923
4a897224
NG
2924 if (audio_codec_name)
2925 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
cf7fc795 2926 audio_enc->codec_id = codec_id;
115329f1 2927
c57c770d
JR
2928 if (audio_qscale > QSCALE_NONE) {
2929 audio_enc->flags |= CODEC_FLAG_QSCALE;
2930 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2931 }
cf7fc795 2932 audio_enc->thread_count = thread_count;
e3e3be53 2933 audio_enc->channels = audio_channels;
cf7fc795
FB
2934 }
2935 audio_enc->sample_rate = audio_sample_rate;
78e03516 2936 audio_enc->time_base= (AVRational){1, audio_sample_rate};
cf7fc795 2937 if (audio_language) {
f7d78f36 2938 av_strlcpy(st->language, audio_language, sizeof(st->language));
cf7fc795
FB
2939 av_free(audio_language);
2940 audio_language = NULL;
2941 }
2942
2943 /* reset some key parameters */
2944 audio_disable = 0;
4a897224 2945 av_freep(&audio_codec_name);
cf7fc795
FB
2946 audio_stream_copy = 0;
2947}
2948
11bf3847 2949static void new_subtitle_stream(AVFormatContext *oc)
cf7fc795 2950{
cf7fc795
FB
2951 AVStream *st;
2952 AVCodecContext *subtitle_enc;
8bbf6db9 2953 int i;
115329f1 2954
cf7fc795
FB
2955 st = av_new_stream(oc, oc->nb_streams);
2956 if (!st) {
2957 fprintf(stderr, "Could not alloc stream\n");
2958 exit(1);
2959 }
54cc9c46 2960 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
cf7fc795 2961
01f4895c 2962 subtitle_enc = st->codec;
cf7fc795
FB
2963 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2964 if (subtitle_stream_copy) {
2965 st->stream_copy = 1;
2966 } else {
8bbf6db9 2967 for(i=0; i<opt_name_count; i++){
bd31a388 2968 const AVOption *opt;
23b254fb 2969 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
e146ce52 2970 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
8bbf6db9
MN
2971 av_set_double(subtitle_enc, opt_names[i], d);
2972 }
4a897224 2973 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
cf7fc795
FB
2974 }
2975
2976 if (subtitle_language) {
f7d78f36 2977 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
cf7fc795
FB
2978 av_free(subtitle_language);
2979 subtitle_language = NULL;
2980 }
2981
11bf3847 2982 subtitle_disable = 0;
4a897224 2983 av_freep(&subtitle_codec_name);
cf7fc795
FB
2984 subtitle_stream_copy = 0;
2985}
2986
2987static void opt_new_audio_stream(void)
2988{
2989 AVFormatContext *oc;
2990 if (nb_output_files <= 0) {
2991 fprintf(stderr, "At least one output file must be specified\n");
2992 exit(1);
2993 }
2994 oc = output_files[nb_output_files - 1];
2995 new_audio_stream(oc);
2996}
2997
2998static void opt_new_video_stream(void)
2999{
3000 AVFormatContext *oc;
3001 if (nb_output_files <= 0) {
3002 fprintf(stderr, "At least one output file must be specified\n");
3003 exit(1);
3004 }
3005 oc = output_files[nb_output_files - 1];
3006 new_video_stream(oc);
3007}
3008
11bf3847
AJ
3009static void opt_new_subtitle_stream(void)
3010{
3011 AVFormatContext *oc;
3012 if (nb_output_files <= 0) {
3013 fprintf(stderr, "At least one output file must be specified\n");
3014 exit(1);
3015 }
3016 oc = output_files[nb_output_files - 1];
3017 new_subtitle_stream(oc);
3018}
3019
cf7fc795
FB
3020static void opt_output_file(const char *filename)
3021{
3022 AVFormatContext *oc;
11bf3847
AJ
3023 int use_video, use_audio, use_subtitle;
3024 int input_has_video, input_has_audio, input_has_subtitle, i;
817b23ff 3025 AVFormatParameters params, *ap = &params;
85f07f22
FB
3026
3027 if (!strcmp(filename, "-"))
3028 filename = "pipe:";
3029
bc874dae 3030 oc = av_alloc_format_context();
85f07f22 3031
79fdaa4c
FB
3032 if (!file_oformat) {
3033 file_oformat = guess_format(NULL, filename, NULL);
3034 if (!file_oformat) {
4021300c 3035 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
79fdaa4c
FB
3036 filename);
3037 exit(1);
3038 }
85f07f22 3039 }
115329f1 3040
79fdaa4c 3041 oc->oformat = file_oformat;
f7d78f36 3042 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
85f07f22 3043
115329f1 3044 if (!strcmp(file_oformat->name, "ffm") &&
f7d78f36 3045 av_strstart(filename, "http:", NULL)) {
85f07f22
FB
3046 /* special case for files sent to ffserver: we get the stream
3047 parameters from ffserver */
3048 if (read_ffserver_streams(oc, filename) < 0) {
3049 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3050 exit(1);
3051 }
3052 } else {
4a897224
NG
3053 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3054 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3055 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
919f448d 3056
e30a2846
FB
3057 /* disable if no corresponding type found and at least one
3058 input file */
3059 if (nb_input_files > 0) {
11bf3847
AJ
3060 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3061 &input_has_subtitle);
e30a2846
FB
3062 if (!input_has_video)
3063 use_video = 0;
3064 if (!input_has_audio)
3065 use_audio = 0;
11bf3847
AJ
3066 if (!input_has_subtitle)
3067 use_subtitle = 0;
e30a2846 3068 }
919f448d
FB
3069
3070 /* manual disable */
85f07f22
FB
3071 if (audio_disable) {
3072 use_audio = 0;
3073 }
3074 if (video_disable) {
3075 use_video = 0;
3076 }
11bf3847
AJ
3077 if (subtitle_disable) {
3078 use_subtitle = 0;
3079 }
115329f1 3080
85f07f22 3081 if (use_video) {
cf7fc795 3082 new_video_stream(oc);
85f07f22 3083 }
115329f1 3084
85f07f22 3085 if (use_audio) {
cf7fc795 3086 new_audio_stream(oc);
85f07f22
FB
3087 }
3088
11bf3847
AJ
3089 if (use_subtitle) {
3090 new_subtitle_stream(oc);
3091 }
3092
4568325a 3093 oc->timestamp = rec_timestamp;
115329f1 3094
bb270c08 3095 if (str_title)
f7d78f36 3096 av_strlcpy(oc->title, str_title, sizeof(oc->title));
85f07f22 3097 if (str_author)
f7d78f36 3098 av_strlcpy(oc->author, str_author, sizeof(oc->author));
85f07f22 3099 if (str_copyright)
f7d78f36 3100 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
85f07f22 3101 if (str_comment)
f7d78f36 3102 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
63d5075c 3103 if (str_album)
f7d78f36 3104 av_strlcpy(oc->album, str_album, sizeof(oc->album));
85f07f22
FB
3105 }
3106
1629626f 3107 output_files[nb_output_files++] = oc;
85f07f22 3108
919f448d 3109 /* check filename in case of an image number is expected */
79fdaa4c 3110 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5c07cf53 3111 if (!av_filename_number_test(oc->filename)) {
79fdaa4c 3112 print_error(oc->filename, AVERROR_NUMEXPECTED);
919f448d 3113 exit(1);
79fdaa4c 3114 }
919f448d
FB
3115 }
3116
79fdaa4c 3117 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
85f07f22 3118 /* test if it already exists to avoid loosing precious files */
115329f1 3119 if (!file_overwrite &&
85f07f22 3120 (strchr(filename, ':') == NULL ||
f7d78f36 3121 av_strstart(filename, "file:", NULL))) {
85f07f22
FB
3122 if (url_exist(filename)) {
3123 int c;
115329f1 3124
d9a916e2
CY
3125 if ( !using_stdin ) {
3126 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3127 fflush(stderr);
3128 c = getchar();
3129 if (toupper(c) != 'Y') {
3130 fprintf(stderr, "Not overwriting - exiting\n");
3131 exit(1);
3132 }
bb270c08
DB
3133 }
3134 else {
d9a916e2 3135 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
85f07f22 3136 exit(1);
bb270c08 3137 }
85f07f22
FB
3138 }
3139 }
115329f1 3140
85f07f22
FB
3141 /* open the file */
3142 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3143 fprintf(stderr, "Could not open '%s'\n", filename);
3144 exit(1);
3145 }
3146 }
3147
817b23ff 3148 memset(ap, 0, sizeof(*ap));
817b23ff
FB
3149 if (av_set_parameters(oc, ap) < 0) {
3150 fprintf(stderr, "%s: Invalid encoding parameters\n",
3151 oc->filename);
3152 exit(1);
3153 }
3154
17c88cb0
MN
3155 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3156 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
8108551a 3157 oc->loop_output = loop_output;
2db3c638 3158
8e16b25c 3159 for(i=0; i<opt_name_count; i++){
bd31a388 3160 const AVOption *opt;
8e16b25c 3161 double d = av_get_double(avformat_opts, opt_names[i], &opt);
e146ce52 3162 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
8e16b25c
PI
3163 av_set_double(oc, opt_names[i], d);
3164 }
3165
85f07f22 3166 /* reset some options */
79fdaa4c
FB
3167 file_oformat = NULL;
3168 file_iformat = NULL;
85f07f22
FB
3169}
3170
5abdb4b1 3171/* same option as mencoder */
b29f97d1 3172static void opt_pass(const char *pass_str)
5abdb4b1
FB
3173{
3174 int pass;
3175 pass = atoi(pass_str);
3176 if (pass != 1 && pass != 2) {
3177 fprintf(stderr, "pass number can be only 1 or 2\n");
3178 exit(1);
3179 }
3180 do_pass = pass;
3181}
a38469e1 3182
0c1a9eda 3183static int64_t getutime(void)
bdc4796f 3184{
66be5b45 3185#ifdef HAVE_GETRUSAGE
f3ec2d46
SG
3186 struct rusage rusage;
3187
3188 getrusage(RUSAGE_SELF, &rusage);
3189 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
7495c306
RP
3190#elif defined(HAVE_GETPROCESSTIMES)
3191 HANDLE proc;
3192 FILETIME c, e, k, u;
3193 proc = GetCurrentProcess();
3194 GetProcessTimes(proc, &c, &e, &k, &u);
3195 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3196#else
a9bb28a3 3197 return av_gettime();
66be5b45 3198#endif
bdc4796f 3199}
5727b222 3200
e8a42081 3201#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
79fdaa4c 3202extern int ffm_nopts;
e8a42081 3203#endif
79fdaa4c 3204
1af2ca78 3205static void opt_show_formats(void)
85f07f22 3206{
79fdaa4c
FB
3207 AVInputFormat *ifmt;
3208 AVOutputFormat *ofmt;
85f07f22 3209 URLProtocol *up;
3738fe1a 3210 AVCodec *p, *p2;
c0de00da 3211 const char *last_name;
3738fe1a
MN
3212
3213 printf("File formats:\n");
3214 last_name= "000";
3215 for(;;){
3216 int decode=0;
3217 int encode=0;
3218 const char *name=NULL;
92a80570 3219 const char *long_name=NULL;
3738fe1a
MN
3220
3221 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3222 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3223 strcmp(ofmt->name, last_name)>0){
3224 name= ofmt->name;
92a80570 3225 long_name= ofmt->long_name;
3738fe1a
MN
3226 encode=1;
3227 }
3228 }
3229 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3230 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3231 strcmp(ifmt->name, last_name)>0){
3232 name= ifmt->name;
92a80570 3233 long_name= ifmt->long_name;
3738fe1a
MN
3234 encode=0;
3235 }
3236 if(name && strcmp(ifmt->name, name)==0)
3237 decode=1;
3238 }
3239 if(name==NULL)
3240 break;
3241 last_name= name;
115329f1 3242
3738fe1a 3243 printf(
115329f1
DB
3244 " %s%s %-15s %s\n",
3245 decode ? "D":" ",
3246 encode ? "E":" ",
92a80570
MN
3247 name,
3248 long_name ? long_name:" ");
817b23ff
FB
3249 }
3250 printf("\n");
3251
85f07f22 3252 printf("Codecs:\n");
3738fe1a
MN
3253 last_name= "000";
3254 for(;;){
3255 int decode=0;
3256 int encode=0;
3257 int cap=0;
cf7fc795 3258 const char *type_str;
3738fe1a
MN
3259
3260 p2=NULL;
3261 for(p = first_avcodec; p != NULL; p = p->next) {
3262 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3263 strcmp(p->name, last_name)>0){
3264 p2= p;
3265 decode= encode= cap=0;
3266 }
3267 if(p2 && strcmp(p->name, p2->name)==0){
3268 if(p->decode) decode=1;
3269 if(p->encode) encode=1;
3270 cap |= p->capabilities;
3271 }
3272 }
3273 if(p2==NULL)
3274 break;
3275 last_name= p2->name;
115329f1 3276
cf7fc795
FB
3277 switch(p2->type) {
3278 case CODEC_TYPE_VIDEO:
3279 type_str = "V";
3280 break;
3281 case CODEC_TYPE_AUDIO:
3282 type_str = "A";
3283 break;
3284 case CODEC_TYPE_SUBTITLE:
3285 type_str = "S";
3286 break;
3287 default:
3288 type_str = "?";
3289 break;
3290 }
3738fe1a 3291 printf(
115329f1
DB
3292 " %s%s%s%s%s%s %s",
3293 decode ? "D": (/*p2->decoder ? "d":*/" "),
3294 encode ? "E":" ",
cf7fc795 3295 type_str,
3738fe1a
MN
3296 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3297 cap & CODEC_CAP_DR1 ? "D":" ",
3298 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3299 p2->name);
3300 /* if(p2->decoder && decode==0)
3301 printf(" use %s for decoding", p2->decoder->name);*/
3302 printf("\n");
85f07f22
FB
3303 }
3304 printf("\n");
3305
3738fe1a 3306 printf("Supported file protocols:\n");
85f07f22
FB
3307 for(up = first_protocol; up != NULL; up = up->next)
3308 printf(" %s:", up->name);
3309 printf("\n");
115329f1 3310
3738fe1a 3311 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
c0de00da 3312 printf("\n");
3738fe1a 3313 printf(
755bfeab 3314"Note, the names of encoders and decoders do not always match, so there are\n"
3738fe1a 3315"several cases where the above table shows encoder only or decoder only entries\n"
755bfeab
DB
3316"even though both encoding and decoding are supported. For example, the h263\n"
3317"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3318"worse.\n");
c20bd3e0 3319 exit(0);
85f07f22
FB
3320}
3321
ceaf1909 3322static void parse_matrix_coeffs(uint16_t *dest, const char *str)
84f608f4
VM
3323{