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