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