?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Dont loose user flags when passing calls from the new to the old seeking API.
[ffmpeg-lucabe.git] / ffmpeg.c
blobc95549a8caffa712bc091c8859a4806858c9c9aa
1 /*
2 * FFmpeg main
3 * Copyright (c) 2000-2003 Fabrice Bellard
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
24
25 #include "config.h"
26 #include <ctype.h>
27 #include <string.h>
28 #include <math.h>
29 #include <stdlib.h>
30 #include <errno.h>
31 #include <signal.h>
32 #include <limits.h>
33 #include <unistd.h>
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavutil/fifo.h"
40 #include "libavutil/avstring.h"
41 #include "libavformat/os_support.h"
42
43 #if HAVE_SYS_RESOURCE_H
44 #include <sys/types.h>
45 #include <sys/resource.h>
46 #elif HAVE_GETPROCESSTIMES
47 #include <windows.h>
48 #endif
49
50 #if HAVE_SYS_SELECT_H
51 #include <sys/select.h>
52 #endif
53
54 #if HAVE_TERMIOS_H
55 #include <fcntl.h>
56 #include <sys/ioctl.h>
57 #include <sys/time.h>
58 #include <termios.h>
59 #elif HAVE_CONIO_H
60 #include <conio.h>
61 #endif
62 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
63 #include <time.h>
64
65 #include "cmdutils.h"
66
67 #undef NDEBUG
68 #include <assert.h>
69
70 #undef exit
71
72 const char program_name[] = "FFmpeg";
73 const int program_birth_year = 2000;
74
75 /* select an input stream for an output stream */
76 typedef struct AVStreamMap {
77 int file_index;
78 int stream_index;
79 int sync_file_index;
80 int sync_stream_index;
81 } AVStreamMap;
82
83 /** select an input file for an output file */
84 typedef struct AVMetaDataMap {
85 int out_file;
86 int in_file;
87 } AVMetaDataMap;
88
89 static const OptionDef options[];
90
91 #define MAX_FILES 20
92
93 static AVFormatContext *input_files[MAX_FILES];
94 static int64_t input_files_ts_offset[MAX_FILES];
95 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
96 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
97 static int nb_input_files = 0;
98 static int nb_icodecs;
99
100 static AVFormatContext *output_files[MAX_FILES];
101 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
102 static int nb_output_files = 0;
103 static int nb_ocodecs;
104
105 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
106 static int nb_stream_maps;
107
108 static AVMetaDataMap meta_data_maps[MAX_FILES];
109 static int nb_meta_data_maps;
110
111 static AVInputFormat *file_iformat;
112 static AVOutputFormat *file_oformat;
113 static int frame_width = 0;
114 static int frame_height = 0;
115 static float frame_aspect_ratio = 0;
116 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
117 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
118 static int frame_padtop = 0;
119 static int frame_padbottom = 0;
120 static int frame_padleft = 0;
121 static int frame_padright = 0;
122 static int padcolor[3] = {16,128,128}; /* default to black */
123 static int frame_topBand = 0;
124 static int frame_bottomBand = 0;
125 static int frame_leftBand = 0;
126 static int frame_rightBand = 0;
127 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
128 static AVRational frame_rate;
129 static float video_qscale = 0;
130 static uint16_t *intra_matrix = NULL;
131 static uint16_t *inter_matrix = NULL;
132 #if 0 //experimental, (can be removed)
133 static float video_rc_qsquish=1.0;
134 static float video_rc_qmod_amp=0;
135 static int video_rc_qmod_freq=0;
136 #endif
137 static const char *video_rc_override_string=NULL;
138 static int video_disable = 0;
139 static int video_discard = 0;
140 static char *video_codec_name = NULL;
141 static int video_codec_tag = 0;
142 static int same_quality = 0;
143 static int do_deinterlace = 0;
144 static int top_field_first = -1;
145 static int me_threshold = 0;
146 static int intra_dc_precision = 8;
147 static int loop_input = 0;
148 static int loop_output = AVFMT_NOOUTPUTLOOP;
149 static int qp_hist = 0;
150
151 static int intra_only = 0;
152 static int audio_sample_rate = 44100;
153 static int64_t channel_layout = 0;
154 #define QSCALE_NONE -99999
155 static float audio_qscale = QSCALE_NONE;
156 static int audio_disable = 0;
157 static int audio_channels = 1;
158 static char *audio_codec_name = NULL;
159 static int audio_codec_tag = 0;
160 static char *audio_language = NULL;
161
162 static int subtitle_disable = 0;
163 static char *subtitle_codec_name = NULL;
164 static char *subtitle_language = NULL;
165 static int subtitle_codec_tag = 0;
166
167 static float mux_preload= 0.5;
168 static float mux_max_delay= 0.7;
169
170 static int64_t recording_time = INT64_MAX;
171 static int64_t start_time = 0;
172 static int64_t rec_timestamp = 0;
173 static int64_t input_ts_offset = 0;
174 static int file_overwrite = 0;
175 static int metadata_count;
176 static AVMetadataTag *metadata;
177 static int do_benchmark = 0;
178 static int do_hex_dump = 0;
179 static int do_pkt_dump = 0;
180 static int do_psnr = 0;
181 static int do_pass = 0;
182 static char *pass_logfilename_prefix = NULL;
183 static int audio_stream_copy = 0;
184 static int video_stream_copy = 0;
185 static int subtitle_stream_copy = 0;
186 static int video_sync_method= -1;
187 static int audio_sync_method= 0;
188 static float audio_drift_threshold= 0.1;
189 static int copy_ts= 0;
190 static int opt_shortest = 0;
191 static int video_global_header = 0;
192 static char *vstats_filename;
193 static FILE *vstats_file;
194 static int opt_programid = 0;
195 static int copy_initial_nonkeyframes = 0;
196
197 static int rate_emu = 0;
198
199 static int video_channel = 0;
200 static char *video_standard;
201
202 static int audio_volume = 256;
203
204 static int exit_on_error = 0;
205 static int using_stdin = 0;
206 static int verbose = 1;
207 static int thread_count= 1;
208 static int q_pressed = 0;
209 static int64_t video_size = 0;
210 static int64_t audio_size = 0;
211 static int64_t extra_size = 0;
212 static int nb_frames_dup = 0;
213 static int nb_frames_drop = 0;
214 static int input_sync;
215 static uint64_t limit_filesize = 0;
216 static int force_fps = 0;
217
218 static int pgmyuv_compatibility_hack=0;
219 static float dts_delta_threshold = 10;
220
221 static unsigned int sws_flags = SWS_BICUBIC;
222
223 static int64_t timer_start;
224
225 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
226 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
227 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
228 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
229
230 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
231
232 struct AVInputStream;
233
234 typedef struct AVOutputStream {
235 int file_index; /* file index */
236 int index; /* stream index in the output file */
237 int source_index; /* AVInputStream index */
238 AVStream *st; /* stream in the output file */
239 int encoding_needed; /* true if encoding needed for this stream */
240 int frame_number;
241 /* input pts and corresponding output pts
242 for A/V sync */
243 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
244 struct AVInputStream *sync_ist; /* input stream to sync against */
245 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
246 /* video only */
247 int video_resample;
248 AVFrame pict_tmp; /* temporary image for resampling */
249 struct SwsContext *img_resample_ctx; /* for image resampling */
250 int resample_height;
251
252 int video_crop;
253 int topBand; /* cropping area sizes */
254 int leftBand;
255
256 int video_pad;
257 int padtop; /* padding area sizes */
258 int padbottom;
259 int padleft;
260 int padright;
261
262 /* audio only */
263 int audio_resample;
264 ReSampleContext *resample; /* for audio resampling */
265 int reformat_pair;
266 AVAudioConvert *reformat_ctx;
267 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
268 FILE *logfile;
269 } AVOutputStream;
270
271 typedef struct AVInputStream {
272 int file_index;
273 int index;
274 AVStream *st;
275 int discard; /* true if stream data should be discarded */
276 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
277 int64_t sample_index; /* current sample */
278
279 int64_t start; /* time when read started */
280 int64_t next_pts; /* synthetic pts for cases where pkt.pts
281 is not defined */
282 int64_t pts; /* current pts */
283 int is_start; /* is 1 at the start and after a discontinuity */
284 } AVInputStream;
285
286 typedef struct AVInputFile {
287 int eof_reached; /* true if eof reached */
288 int ist_index; /* index of first stream in ist_table */
289 int buffer_size; /* current total buffer size */
290 int nb_streams; /* nb streams we are aware of */
291 } AVInputFile;
292
293 #if HAVE_TERMIOS_H
294
295 /* init terminal so that we can grab keys */
296 static struct termios oldtty;
297 #endif
298
299 static void term_exit(void)
300 {
301 #if HAVE_TERMIOS_H
302 tcsetattr (0, TCSANOW, &oldtty);
303 #endif
304 }
305
306 static volatile sig_atomic_t received_sigterm = 0;
307
308 static void
309 sigterm_handler(int sig)
310 {
311 received_sigterm = sig;
312 term_exit();
313 }
314
315 static void term_init(void)
316 {
317 #if HAVE_TERMIOS_H
318 struct termios tty;
319
320 tcgetattr (0, &tty);
321 oldtty = tty;
322
323 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
324 |INLCR|IGNCR|ICRNL|IXON);
325 tty.c_oflag |= OPOST;
326 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
327 tty.c_cflag &= ~(CSIZE|PARENB);
328 tty.c_cflag |= CS8;
329 tty.c_cc[VMIN] = 1;
330 tty.c_cc[VTIME] = 0;
331
332 tcsetattr (0, TCSANOW, &tty);
333 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
334 #endif
335
336 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
337 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
338 /*
339 register a function to be called at normal program termination
340 */
341 atexit(term_exit);
342 #if CONFIG_BEOS_NETSERVER
343 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
344 #endif
345 }
346
347 /* read a key without blocking */
348 static int read_key(void)
349 {
350 #if HAVE_TERMIOS_H
351 int n = 1;
352 unsigned char ch;
353 #if !CONFIG_BEOS_NETSERVER
354 struct timeval tv;
355 fd_set rfds;
356
357 FD_ZERO(&rfds);
358 FD_SET(0, &rfds);
359 tv.tv_sec = 0;
360 tv.tv_usec = 0;
361 n = select(1, &rfds, NULL, NULL, &tv);
362 #endif
363 if (n > 0) {
364 n = read(0, &ch, 1);
365 if (n == 1)
366 return ch;
367
368 return n;
369 }
370 #elif HAVE_CONIO_H
371 if(kbhit())
372 return(getch());
373 #endif
374 return -1;
375 }
376
377 static int decode_interrupt_cb(void)
378 {
379 return q_pressed || (q_pressed = read_key() == 'q');
380 }
381
382 static int av_exit(int ret)
383 {
384 int i;
385
386 /* close files */
387 for(i=0;i<nb_output_files;i++) {
388 /* maybe av_close_output_file ??? */
389 AVFormatContext *s = output_files[i];
390 int j;
391 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
392 url_fclose(s->pb);
393 for(j=0;j<s->nb_streams;j++) {
394 av_metadata_free(&s->streams[j]->metadata);
395 av_free(s->streams[j]->codec);
396 av_free(s->streams[j]);
397 }
398 for(j=0;j<s->nb_programs;j++) {
399 av_metadata_free(&s->programs[j]->metadata);
400 }
401 for(j=0;j<s->nb_chapters;j++) {
402 av_metadata_free(&s->chapters[j]->metadata);
403 }
404 av_metadata_free(&s->metadata);
405 av_free(s);
406 }
407 for(i=0;i<nb_input_files;i++)
408 av_close_input_file(input_files[i]);
409
410 av_free(intra_matrix);
411 av_free(inter_matrix);
412
413 if (vstats_file)
414 fclose(vstats_file);
415 av_free(vstats_filename);
416
417 av_free(opt_names);
418
419 av_free(video_codec_name);
420 av_free(audio_codec_name);
421 av_free(subtitle_codec_name);
422
423 av_free(video_standard);
424
425 #if CONFIG_POWERPC_PERF
426 void powerpc_display_perf_report(void);
427 powerpc_display_perf_report();
428 #endif /* CONFIG_POWERPC_PERF */
429
430 if (received_sigterm) {
431 fprintf(stderr,
432 "Received signal %d: terminating.\n",
433 (int) received_sigterm);
434 exit (255);
435 }
436
437 exit(ret); /* not all OS-es handle main() return value */
438 return ret;
439 }
440
441 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
442 {
443 int i, err;
444 AVFormatContext *ic;
445 int nopts = 0;
446
447 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
448 if (err < 0)
449 return err;
450 /* copy stream format */
451 s->nb_streams = ic->nb_streams;
452 for(i=0;i<ic->nb_streams;i++) {
453 AVStream *st;
454
455 // FIXME: a more elegant solution is needed
456 st = av_mallocz(sizeof(AVStream));
457 memcpy(st, ic->streams[i], sizeof(AVStream));
458 st->codec = avcodec_alloc_context();
459 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
460 s->streams[i] = st;
461
462 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
463 st->stream_copy = 1;
464 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
465 st->stream_copy = 1;
466
467 if(!st->codec->thread_count)
468 st->codec->thread_count = 1;
469 if(st->codec->thread_count>1)
470 avcodec_thread_init(st->codec, st->codec->thread_count);
471
472 if(st->codec->flags & CODEC_FLAG_BITEXACT)
473 nopts = 1;
474 }
475
476 if (!nopts)
477 s->timestamp = av_gettime();
478
479 av_close_input_file(ic);
480 return 0;
481 }
482
483 static double
484 get_sync_ipts(const AVOutputStream *ost)
485 {
486 const AVInputStream *ist = ost->sync_ist;
487 return (double)(ist->pts - start_time)/AV_TIME_BASE;
488 }
489
490 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
491 int ret;
492
493 while(bsfc){
494 AVPacket new_pkt= *pkt;
495 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
496 &new_pkt.data, &new_pkt.size,
497 pkt->data, pkt->size,
498 pkt->flags & PKT_FLAG_KEY);
499 if(a>0){
500 av_free_packet(pkt);
501 new_pkt.destruct= av_destruct_packet;
502 } else if(a<0){
503 fprintf(stderr, "%s failed for stream %d, codec %s",
504 bsfc->filter->name, pkt->stream_index,
505 avctx->codec ? avctx->codec->name : "copy");
506 print_error("", a);
507 if (exit_on_error)
508 av_exit(1);
509 }
510 *pkt= new_pkt;
511
512 bsfc= bsfc->next;
513 }
514
515 ret= av_interleaved_write_frame(s, pkt);
516 if(ret < 0){
517 print_error("av_interleaved_write_frame()", ret);
518 av_exit(1);
519 }
520 }
521
522 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
523
524 static void do_audio_out(AVFormatContext *s,
525 AVOutputStream *ost,
526 AVInputStream *ist,
527 unsigned char *buf, int size)
528 {
529 uint8_t *buftmp;
530 static uint8_t *audio_buf = NULL;
531 static uint8_t *audio_out = NULL;
532 static uint8_t *audio_out2 = NULL;
533 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
534
535 int size_out, frame_bytes, ret;
536 AVCodecContext *enc= ost->st->codec;
537 AVCodecContext *dec= ist->st->codec;
538 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
539 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
540
541 /* SC: dynamic allocation of buffers */
542 if (!audio_buf)
543 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
544 if (!audio_out)
545 audio_out = av_malloc(audio_out_size);
546 if (!audio_buf || !audio_out)
547 return; /* Should signal an error ! */
548
549 if (enc->channels != dec->channels)
550 ost->audio_resample = 1;
551
552 if (ost->audio_resample && !ost->resample) {
553 if (dec->sample_fmt != SAMPLE_FMT_S16)
554 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
555 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
556 enc->sample_rate, dec->sample_rate,
557 enc->sample_fmt, dec->sample_fmt,
558 16, 10, 0, 0.8);
559 if (!ost->resample) {
560 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
561 dec->channels, dec->sample_rate,
562 enc->channels, enc->sample_rate);
563 av_exit(1);
564 }
565 }
566
567 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
568 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
569 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
570 if (!audio_out2)
571 audio_out2 = av_malloc(audio_out_size);
572 if (!audio_out2)
573 av_exit(1);
574 if (ost->reformat_ctx)
575 av_audio_convert_free(ost->reformat_ctx);
576 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
577 dec->sample_fmt, 1, NULL, 0);
578 if (!ost->reformat_ctx) {
579 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
580 avcodec_get_sample_fmt_name(dec->sample_fmt),
581 avcodec_get_sample_fmt_name(enc->sample_fmt));
582 av_exit(1);
583 }
584 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
585 }
586
587 if(audio_sync_method){
588 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
589 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
590 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
591 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
592
593 //FIXME resample delay
594 if(fabs(delta) > 50){
595 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
596 if(byte_delta < 0){
597 byte_delta= FFMAX(byte_delta, -size);
598 size += byte_delta;
599 buf -= byte_delta;
600 if(verbose > 2)
601 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
602 if(!size)
603 return;
604 ist->is_start=0;
605 }else{
606 static uint8_t *input_tmp= NULL;
607 input_tmp= av_realloc(input_tmp, byte_delta + size);
608
609 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
610 ist->is_start=0;
611 else
612 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
613
614 memset(input_tmp, 0, byte_delta);
615 memcpy(input_tmp + byte_delta, buf, size);
616 buf= input_tmp;
617 size += byte_delta;
618 if(verbose > 2)
619 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
620 }
621 }else if(audio_sync_method>1){
622 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
623 assert(ost->audio_resample);
624 if(verbose > 2)
625 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
626 // 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));
627 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
628 }
629 }
630 }else
631 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
632 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
633
634 if (ost->audio_resample) {
635 buftmp = audio_buf;
636 size_out = audio_resample(ost->resample,
637 (short *)buftmp, (short *)buf,
638 size / (ist->st->codec->channels * isize));
639 size_out = size_out * enc->channels * osize;
640 } else {
641 buftmp = buf;
642 size_out = size;
643 }
644
645 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
646 const void *ibuf[6]= {buftmp};
647 void *obuf[6]= {audio_out2};
648 int istride[6]= {isize};
649 int ostride[6]= {osize};
650 int len= size_out/istride[0];
651 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
652 printf("av_audio_convert() failed\n");
653 if (exit_on_error)
654 av_exit(1);
655 return;
656 }
657 buftmp = audio_out2;
658 size_out = len*osize;
659 }
660
661 /* now encode as many frames as possible */
662 if (enc->frame_size > 1) {
663 /* output resampled raw samples */
664 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
665 fprintf(stderr, "av_fifo_realloc2() failed\n");
666 av_exit(1);
667 }
668 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
669
670 frame_bytes = enc->frame_size * osize * enc->channels;
671
672 while (av_fifo_size(ost->fifo) >= frame_bytes) {
673 AVPacket pkt;
674 av_init_packet(&pkt);
675
676 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
677
678 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
679
680 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
681 (short *)audio_buf);
682 if (ret < 0) {
683 fprintf(stderr, "Audio encoding failed\n");
684 av_exit(1);
685 }
686 audio_size += ret;
687 pkt.stream_index= ost->index;
688 pkt.data= audio_out;
689 pkt.size= ret;
690 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
691 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
692 pkt.flags |= PKT_FLAG_KEY;
693 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
694
695 ost->sync_opts += enc->frame_size;
696 }
697 } else {
698 AVPacket pkt;
699 int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
700 av_init_packet(&pkt);
701
702 ost->sync_opts += size_out / (osize * enc->channels);
703
704 /* output a pcm frame */
705 /* determine the size of the coded buffer */
706 size_out /= osize;
707 if (coded_bps)
708 size_out *= coded_bps;
709
710 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
711 ret = avcodec_encode_audio(enc, audio_out, size_out,
712 (short *)buftmp);
713 if (ret < 0) {
714 fprintf(stderr, "Audio encoding failed\n");
715 av_exit(1);
716 }
717 audio_size += ret;
718 pkt.stream_index= ost->index;
719 pkt.data= audio_out;
720 pkt.size= ret;
721 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
722 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
723 pkt.flags |= PKT_FLAG_KEY;
724 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
725 }
726 }
727
728 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
729 {
730 AVCodecContext *dec;
731 AVPicture *picture2;
732 AVPicture picture_tmp;
733 uint8_t *buf = 0;
734
735 dec = ist->st->codec;
736
737 /* deinterlace : must be done before any resize */
738 if (do_deinterlace) {
739 int size;
740
741 /* create temporary picture */
742 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
743 buf = av_malloc(size);
744 if (!buf)
745 return;
746
747 picture2 = &picture_tmp;
748 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
749
750 if (do_deinterlace){
751 if(avpicture_deinterlace(picture2, picture,
752 dec->pix_fmt, dec->width, dec->height) < 0) {
753 /* if error, do not deinterlace */
754 fprintf(stderr, "Deinterlacing failed\n");
755 av_free(buf);
756 buf = NULL;
757 picture2 = picture;
758 }
759 } else {
760 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
761 }
762 } else {
763 picture2 = picture;
764 }
765
766 if (picture != picture2)
767 *picture = *picture2;
768 *bufp = buf;
769 }
770
771 /* we begin to correct av delay at this threshold */
772 #define AV_DELAY_MAX 0.100
773
774 static void do_subtitle_out(AVFormatContext *s,
775 AVOutputStream *ost,
776 AVInputStream *ist,
777 AVSubtitle *sub,
778 int64_t pts)
779 {
780 static uint8_t *subtitle_out = NULL;
781 int subtitle_out_max_size = 65536;
782 int subtitle_out_size, nb, i;
783 AVCodecContext *enc;
784 AVPacket pkt;
785
786 if (pts == AV_NOPTS_VALUE) {
787 fprintf(stderr, "Subtitle packets must have a pts\n");
788 if (exit_on_error)
789 av_exit(1);
790 return;
791 }
792
793 enc = ost->st->codec;
794
795 if (!subtitle_out) {
796 subtitle_out = av_malloc(subtitle_out_max_size);
797 }
798
799 /* Note: DVB subtitle need one packet to draw them and one other
800 packet to clear them */
801 /* XXX: signal it in the codec context ? */
802 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
803 nb = 2;
804 else
805 nb = 1;
806
807 for(i = 0; i < nb; i++) {
808 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
809 subtitle_out_max_size, sub);
810
811 av_init_packet(&pkt);
812 pkt.stream_index = ost->index;
813 pkt.data = subtitle_out;
814 pkt.size = subtitle_out_size;
815 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
816 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
817 /* XXX: the pts correction is handled here. Maybe handling
818 it in the codec would be better */
819 if (i == 0)
820 pkt.pts += 90 * sub->start_display_time;
821 else
822 pkt.pts += 90 * sub->end_display_time;
823 }
824 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
825 }
826 }
827
828 static int bit_buffer_size= 1024*256;
829 static uint8_t *bit_buffer= NULL;
830
831 static void do_video_out(AVFormatContext *s,
832 AVOutputStream *ost,
833 AVInputStream *ist,
834 AVFrame *in_picture,
835 int *frame_size)
836 {
837 int nb_frames, i, ret;
838 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
839 AVFrame picture_crop_temp, picture_pad_temp;
840 AVCodecContext *enc, *dec;
841
842 avcodec_get_frame_defaults(&picture_crop_temp);
843 avcodec_get_frame_defaults(&picture_pad_temp);
844
845 enc = ost->st->codec;
846 dec = ist->st->codec;
847
848 /* by default, we output a single frame */
849 nb_frames = 1;
850
851 *frame_size = 0;
852
853 if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
854 double vdelta;
855 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
856 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
857 if (vdelta < -1.1)
858 nb_frames = 0;
859 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
860 if(vdelta<=-0.6){
861 nb_frames=0;
862 }else if(vdelta>0.6)
863 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
864 }else if (vdelta > 1.1)
865 nb_frames = lrintf(vdelta);
866 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
867 if (nb_frames == 0){
868 ++nb_frames_drop;
869 if (verbose>2)
870 fprintf(stderr, "*** drop!\n");
871 }else if (nb_frames > 1) {
872 nb_frames_dup += nb_frames;
873 if (verbose>2)
874 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
875 }
876 }else
877 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
878
879 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
880 if (nb_frames <= 0)
881 return;
882
883 if (ost->video_crop) {
884 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
885 fprintf(stderr, "error cropping picture\n");
886 if (exit_on_error)
887 av_exit(1);
888 return;
889 }
890 formatted_picture = &picture_crop_temp;
891 } else {
892 formatted_picture = in_picture;
893 }
894
895 final_picture = formatted_picture;
896 padding_src = formatted_picture;
897 resampling_dst = &ost->pict_tmp;
898 if (ost->video_pad) {
899 final_picture = &ost->pict_tmp;
900 if (ost->video_resample) {
901 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
902 fprintf(stderr, "error padding picture\n");
903 if (exit_on_error)
904 av_exit(1);
905 return;
906 }
907 resampling_dst = &picture_pad_temp;
908 }
909 }
910
911 if (ost->video_resample) {
912 padding_src = NULL;
913 final_picture = &ost->pict_tmp;
914 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
915 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
916 }
917
918 if (ost->video_pad) {
919 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
920 enc->height, enc->width, enc->pix_fmt,
921 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
922 }
923
924 /* duplicates frame if needed */
925 for(i=0;i<nb_frames;i++) {
926 AVPacket pkt;
927 av_init_packet(&pkt);
928 pkt.stream_index= ost->index;
929
930 if (s->oformat->flags & AVFMT_RAWPICTURE) {
931 /* raw pictures are written as AVPicture structure to
932 avoid any copies. We support temorarily the older
933 method. */
934 AVFrame* old_frame = enc->coded_frame;
935 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
936 pkt.data= (uint8_t *)final_picture;
937 pkt.size= sizeof(AVPicture);
938 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
939 pkt.flags |= PKT_FLAG_KEY;
940
941 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
942 enc->coded_frame = old_frame;
943 } else {
944 AVFrame big_picture;
945
946 big_picture= *final_picture;
947 /* better than nothing: use input picture interlaced
948 settings */
949 big_picture.interlaced_frame = in_picture->interlaced_frame;
950 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
951 if(top_field_first == -1)
952 big_picture.top_field_first = in_picture->top_field_first;
953 else
954 big_picture.top_field_first = top_field_first;
955 }
956
957 /* handles sameq here. This is not correct because it may
958 not be a global option */
959 if (same_quality) {
960 big_picture.quality = ist->st->quality;
961 }else
962 big_picture.quality = ost->st->quality;
963 if(!me_threshold)
964 big_picture.pict_type = 0;
965 // big_picture.pts = AV_NOPTS_VALUE;
966 big_picture.pts= ost->sync_opts;
967 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
968 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
969 ret = avcodec_encode_video(enc,
970 bit_buffer, bit_buffer_size,
971 &big_picture);
972 if (ret < 0) {
973 fprintf(stderr, "Video encoding failed\n");
974 av_exit(1);
975 }
976 //enc->frame_number = enc->real_pict_num;
977 if(ret>0){
978 pkt.data= bit_buffer;
979 pkt.size= ret;
980 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
981 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
982 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
983 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
984 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
985
986 if(enc->coded_frame->key_frame)
987 pkt.flags |= PKT_FLAG_KEY;
988 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
989 *frame_size = ret;
990 video_size += ret;
991 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
992 // enc->frame_number-1, enc->real_pict_num, ret,
993 // enc->pict_type);
994 /* if two pass, output log */
995 if (ost->logfile && enc->stats_out) {
996 fprintf(ost->logfile, "%s", enc->stats_out);
997 }
998 }
999 }
1000 ost->sync_opts++;
1001 ost->frame_number++;
1002 }
1003 }
1004
1005 static double psnr(double d){
1006 return -10.0*log(d)/log(10.0);
1007 }
1008
1009 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1010 int frame_size)
1011 {
1012 AVCodecContext *enc;
1013 int frame_number;
1014 double ti1, bitrate, avg_bitrate;
1015
1016 /* this is executed just the first time do_video_stats is called */
1017 if (!vstats_file) {
1018 vstats_file = fopen(vstats_filename, "w");
1019 if (!vstats_file) {
1020 perror("fopen");
1021 av_exit(1);
1022 }
1023 }
1024
1025 enc = ost->st->codec;
1026 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1027 frame_number = ost->frame_number;
1028 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1029 if (enc->flags&CODEC_FLAG_PSNR)
1030 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1031
1032 fprintf(vstats_file,"f_size= %6d ", frame_size);
1033 /* compute pts value */
1034 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1035 if (ti1 < 0.01)
1036 ti1 = 0.01;
1037
1038 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1039 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1040 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1041 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1042 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1043 }
1044 }
1045
1046 static void print_report(AVFormatContext **output_files,
1047 AVOutputStream **ost_table, int nb_ostreams,
1048 int is_last_report)
1049 {
1050 char buf[1024];
1051 AVOutputStream *ost;
1052 AVFormatContext *oc, *os;
1053 int64_t total_size;
1054 AVCodecContext *enc;
1055 int frame_number, vid, i;
1056 double bitrate, ti1, pts;
1057 static int64_t last_time = -1;
1058 static int qp_histogram[52];
1059
1060 if (!is_last_report) {
1061 int64_t cur_time;
1062 /* display the report every 0.5 seconds */
1063 cur_time = av_gettime();
1064 if (last_time == -1) {
1065 last_time = cur_time;
1066 return;
1067 }
1068 if ((cur_time - last_time) < 500000)
1069 return;
1070 last_time = cur_time;
1071 }
1072
1073
1074 oc = output_files[0];
1075
1076 total_size = url_fsize(oc->pb);
1077 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1078 total_size= url_ftell(oc->pb);
1079
1080 buf[0] = '\0';
1081 ti1 = 1e10;
1082 vid = 0;
1083 for(i=0;i<nb_ostreams;i++) {
1084 ost = ost_table[i];
1085 os = output_files[ost->file_index];
1086 enc = ost->st->codec;
1087 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1088 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1089 !ost->st->stream_copy ?
1090 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1091 }
1092 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1093 float t = (av_gettime()-timer_start) / 1000000.0;
1094
1095 frame_number = ost->frame_number;
1096 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1097 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1098 !ost->st->stream_copy ?
1099 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1100 if(is_last_report)
1101 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1102 if(qp_hist){
1103 int j;
1104 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1105 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1106 qp_histogram[qp]++;
1107 for(j=0; j<32; j++)
1108 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1109 }
1110 if (enc->flags&CODEC_FLAG_PSNR){
1111 int j;
1112 double error, error_sum=0;
1113 double scale, scale_sum=0;
1114 char type[3]= {'Y','U','V'};
1115 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1116 for(j=0; j<3; j++){
1117 if(is_last_report){
1118 error= enc->error[j];
1119 scale= enc->width*enc->height*255.0*255.0*frame_number;
1120 }else{
1121 error= enc->coded_frame->error[j];
1122 scale= enc->width*enc->height*255.0*255.0;
1123 }
1124 if(j) scale/=4;
1125 error_sum += error;
1126 scale_sum += scale;
1127 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1128 }
1129 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1130 }
1131 vid = 1;
1132 }
1133 /* compute min output value */
1134 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1135 if ((pts < ti1) && (pts > 0))
1136 ti1 = pts;
1137 }
1138 if (ti1 < 0.01)
1139 ti1 = 0.01;
1140
1141 if (verbose || is_last_report) {
1142 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1143
1144 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1145 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1146 (double)total_size / 1024, ti1, bitrate);
1147
1148 if (verbose > 1)
1149 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1150 nb_frames_dup, nb_frames_drop);
1151
1152 if (verbose >= 0)
1153 fprintf(stderr, "%s \r", buf);
1154
1155 fflush(stderr);
1156 }
1157
1158 if (is_last_report && verbose >= 0){
1159 int64_t raw= audio_size + video_size + extra_size;
1160 fprintf(stderr, "\n");
1161 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1162 video_size/1024.0,
1163 audio_size/1024.0,
1164 extra_size/1024.0,
1165 100.0*(total_size - raw)/raw
1166 );
1167 }
1168 }
1169
1170 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1171 static int output_packet(AVInputStream *ist, int ist_index,
1172 AVOutputStream **ost_table, int nb_ostreams,
1173 const AVPacket *pkt)
1174 {
1175 AVFormatContext *os;
1176 AVOutputStream *ost;
1177 uint8_t *ptr;
1178 int len, ret, i;
1179 uint8_t *data_buf;
1180 int data_size, got_picture;
1181 AVFrame picture;
1182 void *buffer_to_free;
1183 static unsigned int samples_size= 0;
1184 static short *samples= NULL;
1185 AVSubtitle subtitle, *subtitle_to_free;
1186 int got_subtitle;
1187
1188 if(ist->next_pts == AV_NOPTS_VALUE)
1189 ist->next_pts= ist->pts;
1190
1191 if (pkt == NULL) {
1192 /* EOF handling */
1193 ptr = NULL;
1194 len = 0;
1195 goto handle_eof;
1196 }
1197
1198 if(pkt->dts != AV_NOPTS_VALUE)
1199 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1200
1201 len = pkt->size;
1202 ptr = pkt->data;
1203
1204 //while we have more to decode or while the decoder did output something on EOF
1205 while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1206 handle_eof:
1207 ist->pts= ist->next_pts;
1208
1209 if(len && len != pkt->size && verbose>0)
1210 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1211
1212 /* decode the packet if needed */
1213 data_buf = NULL; /* fail safe */
1214 data_size = 0;
1215 subtitle_to_free = NULL;
1216 if (ist->decoding_needed) {
1217 switch(ist->st->codec->codec_type) {
1218 case CODEC_TYPE_AUDIO:{
1219 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1220 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1221 av_free(samples);
1222 samples= av_malloc(samples_size);
1223 }
1224 data_size= samples_size;
1225 /* XXX: could avoid copy if PCM 16 bits with same
1226 endianness as CPU */
1227 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1228 ptr, len);
1229 if (ret < 0)
1230 goto fail_decode;
1231 ptr += ret;
1232 len -= ret;
1233 /* Some bug in mpeg audio decoder gives */
1234 /* data_size < 0, it seems they are overflows */
1235 if (data_size <= 0) {
1236 /* no audio frame */
1237 continue;
1238 }
1239 data_buf = (uint8_t *)samples;
1240 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1241 (ist->st->codec->sample_rate * ist->st->codec->channels);
1242 break;}
1243 case CODEC_TYPE_VIDEO:
1244 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1245 /* XXX: allocate picture correctly */
1246 avcodec_get_frame_defaults(&picture);
1247
1248 ret = avcodec_decode_video(ist->st->codec,
1249 &picture, &got_picture, ptr, len);
1250 ist->st->quality= picture.quality;
1251 if (ret < 0)
1252 goto fail_decode;
1253 if (!got_picture) {
1254 /* no picture yet */
1255 goto discard_packet;
1256 }
1257 if (ist->st->codec->time_base.num != 0) {
1258 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1259 ist->next_pts += ((int64_t)AV_TIME_BASE *
1260 ist->st->codec->time_base.num * ticks) /
1261 ist->st->codec->time_base.den;
1262 }
1263 len = 0;
1264 break;
1265 case CODEC_TYPE_SUBTITLE:
1266 ret = avcodec_decode_subtitle(ist->st->codec,
1267 &subtitle, &got_subtitle, ptr, len);
1268 if (ret < 0)
1269 goto fail_decode;
1270 if (!got_subtitle) {
1271 goto discard_packet;
1272 }
1273 subtitle_to_free = &subtitle;
1274 len = 0;
1275 break;
1276 default:
1277 goto fail_decode;
1278 }
1279 } else {
1280 switch(ist->st->codec->codec_type) {
1281 case CODEC_TYPE_AUDIO:
1282 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1283 ist->st->codec->sample_rate;
1284 break;
1285 case CODEC_TYPE_VIDEO:
1286 if (ist->st->codec->time_base.num != 0) {
1287 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1288 ist->next_pts += ((int64_t)AV_TIME_BASE *
1289 ist->st->codec->time_base.num * ticks) /
1290 ist->st->codec->time_base.den;
1291 }
1292 break;
1293 }
1294 data_buf = ptr;
1295 data_size = len;
1296 ret = len;
1297 len = 0;
1298 }
1299
1300 buffer_to_free = NULL;
1301 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1302 pre_process_video_frame(ist, (AVPicture *)&picture,
1303 &buffer_to_free);
1304 }
1305
1306 // preprocess audio (volume)
1307 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1308 if (audio_volume != 256) {
1309 short *volp;
1310 volp = samples;
1311 for(i=0;i<(data_size / sizeof(short));i++) {
1312 int v = ((*volp) * audio_volume + 128) >> 8;
1313 if (v < -32768) v = -32768;
1314 if (v > 32767) v = 32767;
1315 *volp++ = v;
1316 }
1317 }
1318 }
1319
1320 /* frame rate emulation */
1321 if (rate_emu) {
1322 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1323 int64_t now = av_gettime() - ist->start;
1324 if (pts > now)
1325 usleep(pts - now);
1326 }
1327
1328 /* if output time reached then transcode raw format,
1329 encode packets and output them */
1330 if (start_time == 0 || ist->pts >= start_time)
1331 for(i=0;i<nb_ostreams;i++) {
1332 int frame_size;
1333
1334 ost = ost_table[i];
1335 if (ost->source_index == ist_index) {
1336 os = output_files[ost->file_index];
1337
1338 #if 0
1339 printf("%d: got pts=%0.3f %0.3f\n", i,
1340 (double)pkt->pts / AV_TIME_BASE,
1341 ((double)ist->pts / AV_TIME_BASE) -
1342 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1343 #endif
1344 /* set the input output pts pairs */
1345 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1346
1347 if (ost->encoding_needed) {
1348 switch(ost->st->codec->codec_type) {
1349 case CODEC_TYPE_AUDIO:
1350 do_audio_out(os, ost, ist, data_buf, data_size);
1351 break;
1352 case CODEC_TYPE_VIDEO:
1353 do_video_out(os, ost, ist, &picture, &frame_size);
1354 if (vstats_filename && frame_size)
1355 do_video_stats(os, ost, frame_size);
1356 break;
1357 case CODEC_TYPE_SUBTITLE:
1358 do_subtitle_out(os, ost, ist, &subtitle,
1359 pkt->pts);
1360 break;
1361 default:
1362 abort();
1363 }
1364 } else {
1365 AVFrame avframe; //FIXME/XXX remove this
1366 AVPacket opkt;
1367 av_init_packet(&opkt);
1368
1369 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1370 continue;
1371
1372 /* no reencoding needed : output the packet directly */
1373 /* force the input stream PTS */
1374
1375 avcodec_get_frame_defaults(&avframe);
1376 ost->st->codec->coded_frame= &avframe;
1377 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1378
1379 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1380 audio_size += data_size;
1381 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1382 video_size += data_size;
1383 ost->sync_opts++;
1384 }
1385
1386 opkt.stream_index= ost->index;
1387 if(pkt->pts != AV_NOPTS_VALUE)
1388 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1389 else
1390 opkt.pts= AV_NOPTS_VALUE;
1391
1392 if (pkt->dts == AV_NOPTS_VALUE)
1393 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1394 else
1395 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1396
1397 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1398 opkt.flags= pkt->flags;
1399
1400 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1401 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1402 opkt.destruct= av_destruct_packet;
1403
1404 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1405 ost->st->codec->frame_number++;
1406 ost->frame_number++;
1407 av_free_packet(&opkt);
1408 }
1409 }
1410 }
1411 av_free(buffer_to_free);
1412 /* XXX: allocate the subtitles in the codec ? */
1413 if (subtitle_to_free) {
1414 if (subtitle_to_free->rects != NULL) {
1415 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1416 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1417 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1418 av_freep(&subtitle_to_free->rects[i]);
1419 }
1420 av_freep(&subtitle_to_free->rects);
1421 }
1422 subtitle_to_free->num_rects = 0;
1423 subtitle_to_free = NULL;
1424 }
1425 }
1426 discard_packet:
1427 if (pkt == NULL) {
1428 /* EOF handling */
1429
1430 for(i=0;i<nb_ostreams;i++) {
1431 ost = ost_table[i];
1432 if (ost->source_index == ist_index) {
1433 AVCodecContext *enc= ost->st->codec;
1434 os = output_files[ost->file_index];
1435
1436 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1437 continue;
1438 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1439 continue;
1440
1441 if (ost->encoding_needed) {
1442 for(;;) {
1443 AVPacket pkt;
1444 int fifo_bytes;
1445 av_init_packet(&pkt);
1446 pkt.stream_index= ost->index;
1447
1448 switch(ost->st->codec->codec_type) {
1449 case CODEC_TYPE_AUDIO:
1450 fifo_bytes = av_fifo_size(ost->fifo);
1451 ret = 0;
1452 /* encode any samples remaining in fifo */
1453 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1454 int fs_tmp = enc->frame_size;
1455 enc->frame_size = fifo_bytes / (2 * enc->channels);
1456 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1457 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1458 enc->frame_size = fs_tmp;
1459 }
1460 if(ret <= 0) {
1461 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1462 }
1463 if (ret < 0) {
1464 fprintf(stderr, "Audio encoding failed\n");
1465 av_exit(1);
1466 }
1467 audio_size += ret;
1468 pkt.flags |= PKT_FLAG_KEY;
1469 break;
1470 case CODEC_TYPE_VIDEO:
1471 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1472 if (ret < 0) {
1473 fprintf(stderr, "Video encoding failed\n");
1474 av_exit(1);
1475 }
1476 video_size += ret;
1477 if(enc->coded_frame && enc->coded_frame->key_frame)
1478 pkt.flags |= PKT_FLAG_KEY;
1479 if (ost->logfile && enc->stats_out) {
1480 fprintf(ost->logfile, "%s", enc->stats_out);
1481 }
1482 break;
1483 default:
1484 ret=-1;
1485 }
1486
1487 if(ret<=0)
1488 break;
1489 pkt.data= bit_buffer;
1490 pkt.size= ret;
1491 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1492 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1493 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1494 }
1495 }
1496 }
1497 }
1498 }
1499
1500 return 0;
1501 fail_decode:
1502 return -1;
1503 }
1504
1505 static void print_sdp(AVFormatContext **avc, int n)
1506 {
1507 char sdp[2048];
1508
1509 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1510 printf("SDP:\n%s\n", sdp);
1511 fflush(stdout);
1512 }
1513
1514 static int stream_index_from_inputs(AVFormatContext **input_files,
1515 int nb_input_files,
1516 AVInputFile *file_table,
1517 AVInputStream **ist_table,
1518 enum CodecType type,
1519 int programid)
1520 {
1521 int p, q, z;
1522 for(z=0; z<nb_input_files; z++) {
1523 AVFormatContext *ic = input_files[z];
1524 for(p=0; p<ic->nb_programs; p++) {
1525 AVProgram *program = ic->programs[p];
1526 if(program->id != programid)
1527 continue;
1528 for(q=0; q<program->nb_stream_indexes; q++) {
1529 int sidx = program->stream_index[q];
1530 int ris = file_table[z].ist_index + sidx;
1531 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1532 return ris;
1533 }
1534 }
1535 }
1536
1537 return -1;
1538 }
1539
1540 /*
1541 * The following code is the main loop of the file converter
1542 */
1543 static int av_encode(AVFormatContext **output_files,
1544 int nb_output_files,
1545 AVFormatContext **input_files,
1546 int nb_input_files,
1547 AVStreamMap *stream_maps, int nb_stream_maps)
1548 {
1549 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1550 AVFormatContext *is, *os;
1551 AVCodecContext *codec, *icodec;
1552 AVOutputStream *ost, **ost_table = NULL;
1553 AVInputStream *ist, **ist_table = NULL;
1554 AVInputFile *file_table;
1555 char error[1024];
1556 int key;
1557 int want_sdp = 1;
1558 uint8_t no_packet[MAX_FILES]={0};
1559 int no_packet_count=0;
1560
1561 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1562 if (!file_table)
1563 goto fail;
1564
1565 /* input stream init */
1566 j = 0;
1567 for(i=0;i<nb_input_files;i++) {
1568 is = input_files[i];
1569 file_table[i].ist_index = j;
1570 file_table[i].nb_streams = is->nb_streams;
1571 j += is->nb_streams;
1572 }
1573 nb_istreams = j;
1574
1575 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1576 if (!ist_table)
1577 goto fail;
1578
1579 for(i=0;i<nb_istreams;i++) {
1580 ist = av_mallocz(sizeof(AVInputStream));
1581 if (!ist)
1582 goto fail;
1583 ist_table[i] = ist;
1584 }
1585 j = 0;
1586 for(i=0;i<nb_input_files;i++) {
1587 is = input_files[i];
1588 for(k=0;k<is->nb_streams;k++) {
1589 ist = ist_table[j++];
1590 ist->st = is->streams[k];
1591 ist->file_index = i;
1592 ist->index = k;
1593 ist->discard = 1; /* the stream is discarded by default
1594 (changed later) */
1595
1596 if (rate_emu) {
1597 ist->start = av_gettime();
1598 }
1599 }
1600 }
1601
1602 /* output stream init */
1603 nb_ostreams = 0;
1604 for(i=0;i<nb_output_files;i++) {
1605 os = output_files[i];
1606 if (!os->nb_streams) {
1607 dump_format(output_files[i], i, output_files[i]->filename, 1);
1608 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1609 av_exit(1);
1610 }
1611 nb_ostreams += os->nb_streams;
1612 }
1613 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1614 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1615 av_exit(1);
1616 }
1617
1618 /* Sanity check the mapping args -- do the input files & streams exist? */
1619 for(i=0;i<nb_stream_maps;i++) {
1620 int fi = stream_maps[i].file_index;
1621 int si = stream_maps[i].stream_index;
1622
1623 if (fi < 0 || fi > nb_input_files - 1 ||
1624 si < 0 || si > file_table[fi].nb_streams - 1) {
1625 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1626 av_exit(1);
1627 }
1628 fi = stream_maps[i].sync_file_index;
1629 si = stream_maps[i].sync_stream_index;
1630 if (fi < 0 || fi > nb_input_files - 1 ||
1631 si < 0 || si > file_table[fi].nb_streams - 1) {
1632 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1633 av_exit(1);
1634 }
1635 }
1636
1637 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1638 if (!ost_table)
1639 goto fail;
1640 for(i=0;i<nb_ostreams;i++) {
1641 ost = av_mallocz(sizeof(AVOutputStream));
1642 if (!ost)
1643 goto fail;
1644 ost_table[i] = ost;
1645 }
1646
1647 n = 0;
1648 for(k=0;k<nb_output_files;k++) {
1649 os = output_files[k];
1650 for(i=0;i<os->nb_streams;i++,n++) {
1651 int found;
1652 ost = ost_table[n];
1653 ost->file_index = k;
1654 ost->index = i;
1655 ost->st = os->streams[i];
1656 if (nb_stream_maps > 0) {
1657 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1658 stream_maps[n].stream_index;
1659
1660 /* Sanity check that the stream types match */
1661 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1662 int i= ost->file_index;
1663 dump_format(output_files[i], i, output_files[i]->filename, 1);
1664 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1665 stream_maps[n].file_index, stream_maps[n].stream_index,
1666 ost->file_index, ost->index);
1667 av_exit(1);
1668 }
1669
1670 } else {
1671 if(opt_programid) {
1672 found = 0;
1673 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1674 if(j != -1) {
1675 ost->source_index = j;
1676 found = 1;
1677 }
1678 } else {
1679 /* get corresponding input stream index : we select the first one with the right type */
1680 found = 0;
1681 for(j=0;j<nb_istreams;j++) {
1682 ist = ist_table[j];
1683 if (ist->discard &&
1684 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1685 ost->source_index = j;
1686 found = 1;
1687 break;
1688 }
1689 }
1690 }
1691
1692 if (!found) {
1693 if(! opt_programid) {
1694 /* try again and reuse existing stream */
1695 for(j=0;j<nb_istreams;j++) {
1696 ist = ist_table[j];
1697 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1698 ost->source_index = j;
1699 found = 1;
1700 }
1701 }
1702 }
1703 if (!found) {
1704 int i= ost->file_index;
1705 dump_format(output_files[i], i, output_files[i]->filename, 1);
1706 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1707 ost->file_index, ost->index);
1708 av_exit(1);
1709 }
1710 }
1711 }
1712 ist = ist_table[ost->source_index];
1713 ist->discard = 0;
1714 ost->sync_ist = (nb_stream_maps > 0) ?
1715 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1716 stream_maps[n].sync_stream_index] : ist;
1717 }
1718 }
1719
1720 /* for each output stream, we compute the right encoding parameters */
1721 for(i=0;i<nb_ostreams;i++) {
1722 AVMetadataTag *lang;
1723 ost = ost_table[i];
1724 os = output_files[ost->file_index];
1725 ist = ist_table[ost->source_index];
1726
1727 codec = ost->st->codec;
1728 icodec = ist->st->codec;
1729
1730 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1731 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1732 av_metadata_set(&ost->st->metadata, "language", lang->value);
1733
1734 ost->st->disposition = ist->st->disposition;
1735
1736 if (ost->st->stream_copy) {
1737 /* if stream_copy is selected, no need to decode or encode */
1738 codec->codec_id = icodec->codec_id;
1739 codec->codec_type = icodec->codec_type;
1740
1741 if(!codec->codec_tag){
1742 if( !os->oformat->codec_tag
1743 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1744 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1745 codec->codec_tag = icodec->codec_tag;
1746 }
1747
1748 codec->bit_rate = icodec->bit_rate;
1749 codec->extradata= icodec->extradata;
1750 codec->extradata_size= icodec->extradata_size;
1751 if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
1752 codec->time_base = icodec->time_base;
1753 codec->time_base.num *= icodec->ticks_per_frame;
1754 }else
1755 codec->time_base = ist->st->time_base;
1756 switch(codec->codec_type) {
1757 case CODEC_TYPE_AUDIO:
1758 if(audio_volume != 256) {
1759 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1760 av_exit(1);
1761 }
1762 codec->channel_layout = icodec->channel_layout;
1763 codec->sample_rate = icodec->sample_rate;
1764 codec->channels = icodec->channels;
1765 codec->frame_size = icodec->frame_size;
1766 codec->block_align= icodec->block_align;
1767 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1768 codec->block_align= 0;
1769 if(codec->codec_id == CODEC_ID_AC3)
1770 codec->block_align= 0;
1771 break;
1772 case CODEC_TYPE_VIDEO:
1773 codec->pix_fmt = icodec->pix_fmt;
1774 codec->width = icodec->width;
1775 codec->height = icodec->height;
1776 codec->has_b_frames = icodec->has_b_frames;
1777 break;
1778 case CODEC_TYPE_SUBTITLE:
1779 codec->width = icodec->width;
1780 codec->height = icodec->height;
1781 break;
1782 default:
1783 abort();
1784 }
1785 } else {
1786 switch(codec->codec_type) {
1787 case CODEC_TYPE_AUDIO:
1788 ost->fifo= av_fifo_alloc(1024);
1789 if(!ost->fifo)
1790 goto fail;
1791 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1792 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1793 icodec->request_channels = codec->channels;
1794 ist->decoding_needed = 1;
1795 ost->encoding_needed = 1;
1796 break;
1797 case CODEC_TYPE_VIDEO:
1798 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1799 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1800 ost->video_resample = ((codec->width != icodec->width -
1801 (frame_leftBand + frame_rightBand) +
1802 (frame_padleft + frame_padright)) ||
1803 (codec->height != icodec->height -
1804 (frame_topBand + frame_bottomBand) +
1805 (frame_padtop + frame_padbottom)) ||
1806 (codec->pix_fmt != icodec->pix_fmt));
1807 if (ost->video_crop) {
1808 ost->topBand = frame_topBand;
1809 ost->leftBand = frame_leftBand;
1810 }
1811 if (ost->video_pad) {
1812 ost->padtop = frame_padtop;
1813 ost->padleft = frame_padleft;
1814 ost->padbottom = frame_padbottom;
1815 ost->padright = frame_padright;
1816 if (!ost->video_resample) {
1817 avcodec_get_frame_defaults(&ost->pict_tmp);
1818 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1819 codec->width, codec->height))
1820 goto fail;
1821 }
1822 }
1823 if (ost->video_resample) {
1824 avcodec_get_frame_defaults(&ost->pict_tmp);
1825 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1826 codec->width, codec->height)) {
1827 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1828 av_exit(1);
1829 }
1830 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1831 ost->img_resample_ctx = sws_getContext(
1832 icodec->width - (frame_leftBand + frame_rightBand),
1833 icodec->height - (frame_topBand + frame_bottomBand),
1834 icodec->pix_fmt,
1835 codec->width - (frame_padleft + frame_padright),
1836 codec->height - (frame_padtop + frame_padbottom),
1837 codec->pix_fmt,
1838 sws_flags, NULL, NULL, NULL);
1839 if (ost->img_resample_ctx == NULL) {
1840 fprintf(stderr, "Cannot get resampling context\n");
1841 av_exit(1);
1842 }
1843 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1844 }
1845 ost->encoding_needed = 1;
1846 ist->decoding_needed = 1;
1847 break;
1848 case CODEC_TYPE_SUBTITLE:
1849 ost->encoding_needed = 1;
1850 ist->decoding_needed = 1;
1851 break;
1852 default:
1853 abort();
1854 break;
1855 }
1856 /* two pass mode */
1857 if (ost->encoding_needed &&
1858 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1859 char logfilename[1024];
1860 FILE *f;
1861 int size;
1862 char *logbuffer;
1863
1864 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1865 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1866 i);
1867 if (codec->flags & CODEC_FLAG_PASS1) {
1868 f = fopen(logfilename, "w");
1869 if (!f) {
1870 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1871 av_exit(1);
1872 }
1873 ost->logfile = f;
1874 } else {
1875 /* read the log file */
1876 f = fopen(logfilename, "r");
1877 if (!f) {
1878 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1879 av_exit(1);
1880 }
1881 fseek(f, 0, SEEK_END);
1882 size = ftell(f);
1883 fseek(f, 0, SEEK_SET);
1884 logbuffer = av_malloc(size + 1);
1885 if (!logbuffer) {
1886 fprintf(stderr, "Could not allocate log buffer\n");
1887 av_exit(1);
1888 }
1889 size = fread(logbuffer, 1, size, f);
1890 fclose(f);
1891 logbuffer[size] = '\0';
1892 codec->stats_in = logbuffer;
1893 }
1894 }
1895 }
1896 if(codec->codec_type == CODEC_TYPE_VIDEO){
1897 int size= codec->width * codec->height;
1898 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1899 }
1900 }
1901
1902 if (!bit_buffer)
1903 bit_buffer = av_malloc(bit_buffer_size);
1904 if (!bit_buffer) {
1905 ret = AVERROR(ENOMEM);
1906 goto fail;
1907 }
1908
1909 /* open each encoder */
1910 for(i=0;i<nb_ostreams;i++) {
1911 ost = ost_table[i];
1912 if (ost->encoding_needed) {
1913 AVCodec *codec = output_codecs[i];
1914 if (!codec)
1915 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1916 if (!codec) {
1917 snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1918 ost->file_index, ost->index);
1919 ret = AVERROR(EINVAL);
1920 goto dump_format;
1921 }
1922 if (avcodec_open(ost->st->codec, codec) < 0) {
1923 snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1924 ost->file_index, ost->index);
1925 ret = AVERROR(EINVAL);
1926 goto dump_format;
1927 }
1928 extra_size += ost->st->codec->extradata_size;
1929 }
1930 }
1931
1932 /* open each decoder */
1933 for(i=0;i<nb_istreams;i++) {
1934 ist = ist_table[i];
1935 if (ist->decoding_needed) {
1936 AVCodec *codec = input_codecs[i];
1937 if (!codec)
1938 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1939 if (!codec) {
1940 snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1941 ist->st->codec->codec_id, ist->file_index, ist->index);
1942 ret = AVERROR(EINVAL);
1943 goto dump_format;
1944 }
1945 if (avcodec_open(ist->st->codec, codec) < 0) {
1946 snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1947 ist->file_index, ist->index);
1948 ret = AVERROR(EINVAL);
1949 goto dump_format;
1950 }
1951 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1952 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1953 }
1954 }
1955
1956 /* init pts */
1957 for(i=0;i<nb_istreams;i++) {
1958 ist = ist_table[i];
1959 is = input_files[ist->file_index];
1960 ist->pts = 0;
1961 ist->next_pts = AV_NOPTS_VALUE;
1962 ist->is_start = 1;
1963 }
1964
1965 /* set meta data information from input file if required */
1966 for (i=0;i<nb_meta_data_maps;i++) {
1967 AVFormatContext *out_file;
1968 AVFormatContext *in_file;
1969 AVMetadataTag *mtag;
1970
1971 int out_file_index = meta_data_maps[i].out_file;
1972 int in_file_index = meta_data_maps[i].in_file;
1973 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1974 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1975 out_file_index, out_file_index, in_file_index);
1976 ret = AVERROR(EINVAL);
1977 goto dump_format;
1978 }
1979 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1980 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
1981 in_file_index, out_file_index, in_file_index);
1982 ret = AVERROR(EINVAL);
1983 goto dump_format;
1984 }
1985
1986 out_file = output_files[out_file_index];
1987 in_file = input_files[in_file_index];
1988
1989
1990 mtag=NULL;
1991 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
1992 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
1993 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
1994 in_file->iformat->metadata_conv);
1995 }
1996
1997 /* open files and write file headers */
1998 for(i=0;i<nb_output_files;i++) {
1999 os = output_files[i];
2000 if (av_write_header(os) < 0) {
2001 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2002 ret = AVERROR(EINVAL);
2003 goto dump_format;
2004 }
2005 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2006 want_sdp = 0;
2007 }
2008 }
2009
2010 dump_format:
2011 /* dump the file output parameters - cannot be done before in case
2012 of stream copy */
2013 for(i=0;i<nb_output_files;i++) {
2014 dump_format(output_files[i], i, output_files[i]->filename, 1);
2015 }
2016
2017 /* dump the stream mapping */
2018 if (verbose >= 0) {
2019 fprintf(stderr, "Stream mapping:\n");
2020 for(i=0;i<nb_ostreams;i++) {
2021 ost = ost_table[i];
2022 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2023 ist_table[ost->source_index]->file_index,
2024 ist_table[ost->source_index]->index,
2025 ost->file_index,
2026 ost->index);
2027 if (ost->sync_ist != ist_table[ost->source_index])
2028 fprintf(stderr, " [sync #%d.%d]",
2029 ost->sync_ist->file_index,
2030 ost->sync_ist->index);
2031 fprintf(stderr, "\n");
2032 }
2033 }
2034
2035 if (ret) {
2036 fprintf(stderr, "%s\n", error);
2037 goto fail;
2038 }
2039
2040 if (want_sdp) {
2041 print_sdp(output_files, nb_output_files);
2042 }
2043
2044 if (!using_stdin && verbose >= 0) {
2045 fprintf(stderr, "Press [q] to stop encoding\n");
2046 url_set_interrupt_cb(decode_interrupt_cb);
2047 }
2048 term_init();
2049
2050 key = -1;
2051 timer_start = av_gettime();
2052
2053 for(; received_sigterm == 0;) {
2054 int file_index, ist_index;
2055 AVPacket pkt;
2056 double ipts_min;
2057 double opts_min;
2058
2059 redo:
2060 ipts_min= 1e100;
2061 opts_min= 1e100;
2062 /* if 'q' pressed, exits */
2063 if (!using_stdin) {
2064 if (q_pressed)
2065 break;
2066 /* read_key() returns 0 on EOF */
2067 key = read_key();
2068 if (key == 'q')
2069 break;
2070 }
2071
2072 /* select the stream that we must read now by looking at the
2073 smallest output pts */
2074 file_index = -1;
2075 for(i=0;i<nb_ostreams;i++) {
2076 double ipts, opts;
2077 ost = ost_table[i];
2078 os = output_files[ost->file_index];
2079 ist = ist_table[ost->source_index];
2080 if(no_packet[ist->file_index])
2081 continue;
2082 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2083 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2084 else
2085 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2086 ipts = (double)ist->pts;
2087 if (!file_table[ist->file_index].eof_reached){
2088 if(ipts < ipts_min) {
2089 ipts_min = ipts;
2090 if(input_sync ) file_index = ist->file_index;
2091 }
2092 if(opts < opts_min) {
2093 opts_min = opts;
2094 if(!input_sync) file_index = ist->file_index;
2095 }
2096 }
2097 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2098 file_index= -1;
2099 break;
2100 }
2101 }
2102 /* if none, if is finished */
2103 if (file_index < 0) {
2104 if(no_packet_count){
2105 no_packet_count=0;
2106 memset(no_packet, 0, sizeof(no_packet));
2107 usleep(10000);
2108 continue;
2109 }
2110 break;
2111 }
2112
2113 /* finish if recording time exhausted */
2114 if (opts_min >= (recording_time / 1000000.0))
2115 break;
2116
2117 /* finish if limit size exhausted */
2118 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2119 break;
2120
2121 /* read a frame from it and output it in the fifo */
2122 is = input_files[file_index];
2123 ret= av_read_frame(is, &pkt);
2124 if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm")){
2125 no_packet[file_index]=1;
2126 no_packet_count++;
2127 continue;
2128 }
2129 if (ret < 0) {
2130 file_table[file_index].eof_reached = 1;
2131 if (opt_shortest)
2132 break;
2133 else
2134 continue;
2135 }
2136
2137 no_packet_count=0;
2138 memset(no_packet, 0, sizeof(no_packet));
2139
2140 if (do_pkt_dump) {
2141 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2142 }
2143 /* the following test is needed in case new streams appear
2144 dynamically in stream : we ignore them */
2145 if (pkt.stream_index >= file_table[file_index].nb_streams)
2146 goto discard_packet;
2147 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2148 ist = ist_table[ist_index];
2149 if (ist->discard)
2150 goto discard_packet;
2151
2152 if (pkt.dts != AV_NOPTS_VALUE)
2153 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2154 if (pkt.pts != AV_NOPTS_VALUE)
2155 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2156
2157 if(input_files_ts_scale[file_index][pkt.stream_index]){
2158 if(pkt.pts != AV_NOPTS_VALUE)
2159 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2160 if(pkt.dts != AV_NOPTS_VALUE)
2161 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2162 }
2163
2164 // 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);
2165 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2166 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2167 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2168 int64_t delta= pkt_dts - ist->next_pts;
2169 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2170 input_files_ts_offset[ist->file_index]-= delta;
2171 if (verbose > 2)
2172 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2173 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2174 if(pkt.pts != AV_NOPTS_VALUE)
2175 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2176 }
2177 }
2178
2179 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2180 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2181
2182 if (verbose >= 0)
2183 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2184 ist->file_index, ist->index);
2185 if (exit_on_error)
2186 av_exit(1);
2187 av_free_packet(&pkt);
2188 goto redo;
2189 }
2190
2191 discard_packet:
2192 av_free_packet(&pkt);
2193
2194 /* dump report by using the output first video and audio streams */
2195 print_report(output_files, ost_table, nb_ostreams, 0);
2196 }
2197
2198 /* at the end of stream, we must flush the decoder buffers */
2199 for(i=0;i<nb_istreams;i++) {
2200 ist = ist_table[i];
2201 if (ist->decoding_needed) {
2202 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2203 }
2204 }
2205
2206 term_exit();
2207
2208 /* write the trailer if needed and close file */
2209 for(i=0;i<nb_output_files;i++) {
2210 os = output_files[i];
2211 av_write_trailer(os);
2212 }
2213
2214 /* dump report by using the first video and audio streams */
2215 print_report(output_files, ost_table, nb_ostreams, 1);
2216
2217 /* close each encoder */
2218 for(i=0;i<nb_ostreams;i++) {
2219 ost = ost_table[i];
2220 if (ost->encoding_needed) {
2221 av_freep(&ost->st->codec->stats_in);
2222 avcodec_close(ost->st->codec);
2223 }
2224 }
2225
2226 /* close each decoder */
2227 for(i=0;i<nb_istreams;i++) {
2228 ist = ist_table[i];
2229 if (ist->decoding_needed) {
2230 avcodec_close(ist->st->codec);
2231 }
2232 }
2233
2234 /* finished ! */
2235 ret = 0;
2236
2237 fail:
2238 av_freep(&bit_buffer);
2239 av_free(file_table);
2240
2241 if (ist_table) {
2242 for(i=0;i<nb_istreams;i++) {
2243 ist = ist_table[i];
2244 av_free(ist);
2245 }
2246 av_free(ist_table);
2247 }
2248 if (ost_table) {
2249 for(i=0;i<nb_ostreams;i++) {
2250 ost = ost_table[i];
2251 if (ost) {
2252 if (ost->logfile) {
2253 fclose(ost->logfile);
2254 ost->logfile = NULL;
2255 }
2256 av_fifo_free(ost->fifo); /* works even if fifo is not
2257 initialized but set to zero */
2258 av_free(ost->pict_tmp.data[0]);
2259 if (ost->video_resample)
2260 sws_freeContext(ost->img_resample_ctx);
2261 if (ost->resample)
2262 audio_resample_close(ost->resample);
2263 if (ost->reformat_ctx)
2264 av_audio_convert_free(ost->reformat_ctx);
2265 av_free(ost);
2266 }
2267 }
2268 av_free(ost_table);
2269 }
2270 return ret;
2271 }
2272
2273 #if 0
2274 int file_read(const char *filename)
2275 {
2276 URLContext *h;
2277 unsigned char buffer[1024];
2278 int len, i;
2279
2280 if (url_open(&h, filename, O_RDONLY) < 0) {
2281 printf("could not open '%s'\n", filename);
2282 return -1;
2283 }
2284 for(;;) {
2285 len = url_read(h, buffer, sizeof(buffer));
2286 if (len <= 0)
2287 break;
2288 for(i=0;i<len;i++) putchar(buffer[i]);
2289 }
2290 url_close(h);
2291 return 0;
2292 }
2293 #endif
2294
2295 static void opt_format(const char *arg)
2296 {
2297 /* compatibility stuff for pgmyuv */
2298 if (!strcmp(arg, "pgmyuv")) {
2299 pgmyuv_compatibility_hack=1;
2300 // opt_image_format(arg);
2301 arg = "image2";
2302 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2303 }
2304
2305 file_iformat = av_find_input_format(arg);
2306 file_oformat = guess_format(arg, NULL, NULL);
2307 if (!file_iformat && !file_oformat) {
2308 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2309 av_exit(1);
2310 }
2311 }
2312
2313 static void opt_video_rc_override_string(const char *arg)
2314 {
2315 video_rc_override_string = arg;
2316 }
2317
2318 static int opt_me_threshold(const char *opt, const char *arg)
2319 {
2320 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2321 return 0;
2322 }
2323
2324 static int opt_verbose(const char *opt, const char *arg)
2325 {
2326 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2327 av_log_set_level(verbose);
2328 return 0;
2329 }
2330
2331 static int opt_frame_rate(const char *opt, const char *arg)
2332 {
2333 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2334 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2335 av_exit(1);
2336 }
2337 return 0;
2338 }
2339
2340 static int opt_bitrate(const char *opt, const char *arg)
2341 {
2342 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2343
2344 opt_default(opt, arg);
2345
2346 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2347 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2348
2349 return 0;
2350 }
2351
2352 static void opt_frame_crop_top(const char *arg)
2353 {
2354 frame_topBand = atoi(arg);
2355 if (frame_topBand < 0) {
2356 fprintf(stderr, "Incorrect top crop size\n");
2357 av_exit(1);
2358 }
2359 if ((frame_topBand % 2) != 0) {
2360 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2361 av_exit(1);
2362 }
2363 if ((frame_topBand) >= frame_height){
2364 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2365 av_exit(1);
2366 }
2367 frame_height -= frame_topBand;
2368 }
2369
2370 static void opt_frame_crop_bottom(const char *arg)
2371 {
2372 frame_bottomBand = atoi(arg);
2373 if (frame_bottomBand < 0) {
2374 fprintf(stderr, "Incorrect bottom crop size\n");
2375 av_exit(1);
2376 }
2377 if ((frame_bottomBand % 2) != 0) {
2378 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2379 av_exit(1);
2380 }
2381 if ((frame_bottomBand) >= frame_height){
2382 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2383 av_exit(1);
2384 }
2385 frame_height -= frame_bottomBand;
2386 }
2387
2388 static void opt_frame_crop_left(const char *arg)
2389 {
2390 frame_leftBand = atoi(arg);
2391 if (frame_leftBand < 0) {
2392 fprintf(stderr, "Incorrect left crop size\n");
2393 av_exit(1);
2394 }
2395 if ((frame_leftBand % 2) != 0) {
2396 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2397 av_exit(1);
2398 }
2399 if ((frame_leftBand) >= frame_width){
2400 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2401 av_exit(1);
2402 }
2403 frame_width -= frame_leftBand;
2404 }
2405
2406 static void opt_frame_crop_right(const char *arg)
2407 {
2408 frame_rightBand = atoi(arg);
2409 if (frame_rightBand < 0) {
2410 fprintf(stderr, "Incorrect right crop size\n");
2411 av_exit(1);
2412 }
2413 if ((frame_rightBand % 2) != 0) {
2414 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2415 av_exit(1);
2416 }
2417 if ((frame_rightBand) >= frame_width){
2418 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2419 av_exit(1);
2420 }
2421 frame_width -= frame_rightBand;
2422 }
2423
2424 static void opt_frame_size(const char *arg)
2425 {
2426 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2427 fprintf(stderr, "Incorrect frame size\n");
2428 av_exit(1);
2429 }
2430 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2431 fprintf(stderr, "Frame size must be a multiple of 2\n");
2432 av_exit(1);
2433 }
2434 }
2435
2436
2437 #define SCALEBITS 10
2438 #define ONE_HALF (1 << (SCALEBITS - 1))
2439 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2440
2441 #define RGB_TO_Y(r, g, b) \
2442 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2443 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2444
2445 #define RGB_TO_U(r1, g1, b1, shift)\
2446 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2447 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2448
2449 #define RGB_TO_V(r1, g1, b1, shift)\
2450 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2451 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2452
2453 static void opt_pad_color(const char *arg) {
2454 /* Input is expected to be six hex digits similar to
2455 how colors are expressed in html tags (but without the #) */
2456 int rgb = strtol(arg, NULL, 16);
2457 int r,g,b;
2458
2459 r = (rgb >> 16);
2460 g = ((rgb >> 8) & 255);
2461 b = (rgb & 255);
2462
2463 padcolor[0] = RGB_TO_Y(r,g,b);
2464 padcolor[1] = RGB_TO_U(r,g,b,0);
2465 padcolor[2] = RGB_TO_V(r,g,b,0);
2466 }
2467
2468 static void opt_frame_pad_top(const char *arg)
2469 {
2470 frame_padtop = atoi(arg);
2471 if (frame_padtop < 0) {
2472 fprintf(stderr, "Incorrect top pad size\n");
2473 av_exit(1);
2474 }
2475 if ((frame_padtop % 2) != 0) {
2476 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2477 av_exit(1);
2478 }
2479 }
2480
2481 static void opt_frame_pad_bottom(const char *arg)
2482 {
2483 frame_padbottom = atoi(arg);
2484 if (frame_padbottom < 0) {
2485 fprintf(stderr, "Incorrect bottom pad size\n");
2486 av_exit(1);
2487 }
2488 if ((frame_padbottom % 2) != 0) {
2489 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2490 av_exit(1);
2491 }
2492 }
2493
2494
2495 static void opt_frame_pad_left(const char *arg)
2496 {
2497 frame_padleft = atoi(arg);
2498 if (frame_padleft < 0) {
2499 fprintf(stderr, "Incorrect left pad size\n");
2500 av_exit(1);
2501 }
2502 if ((frame_padleft % 2) != 0) {
2503 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2504 av_exit(1);
2505 }
2506 }
2507
2508
2509 static void opt_frame_pad_right(const char *arg)
2510 {
2511 frame_padright = atoi(arg);
2512 if (frame_padright < 0) {
2513 fprintf(stderr, "Incorrect right pad size\n");
2514 av_exit(1);
2515 }
2516 if ((frame_padright % 2) != 0) {
2517 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2518 av_exit(1);
2519 }
2520 }
2521
2522 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2523 {
2524 int i;
2525 char fmt_str[128];
2526 for (i=-1; i < nb_fmts; i++) {
2527 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2528 fprintf(stdout, "%s\n", fmt_str);
2529 }
2530 }
2531
2532 static void opt_frame_pix_fmt(const char *arg)
2533 {
2534 if (strcmp(arg, "list"))
2535 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2536 else {
2537 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2538 av_exit(0);
2539 }
2540 }
2541
2542 static void opt_frame_aspect_ratio(const char *arg)
2543 {
2544 int x = 0, y = 0;
2545 double ar = 0;
2546 const char *p;
2547 char *end;
2548
2549 p = strchr(arg, ':');
2550 if (p) {
2551 x = strtol(arg, &end, 10);
2552 if (end == p)
2553 y = strtol(end+1, &end, 10);
2554 if (x > 0 && y > 0)
2555 ar = (double)x / (double)y;
2556 } else
2557 ar = strtod(arg, NULL);
2558
2559 if (!ar) {
2560 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2561 av_exit(1);
2562 }
2563 frame_aspect_ratio = ar;
2564 }
2565
2566 static int opt_metadata(const char *opt, const char *arg)
2567 {
2568 char *mid= strchr(arg, '=');
2569
2570 if(!mid){
2571 fprintf(stderr, "Missing =\n");
2572 av_exit(1);
2573 }
2574 *mid++= 0;
2575
2576 metadata_count++;
2577 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2578 metadata[metadata_count-1].key = av_strdup(arg);
2579 metadata[metadata_count-1].value= av_strdup(mid);
2580
2581 return 0;
2582 }
2583
2584 static void opt_qscale(const char *arg)
2585 {
2586 video_qscale = atof(arg);
2587 if (video_qscale <= 0 ||
2588 video_qscale > 255) {
2589 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2590 av_exit(1);
2591 }
2592 }
2593
2594 static void opt_top_field_first(const char *arg)
2595 {
2596 top_field_first= atoi(arg);
2597 }
2598
2599 static int opt_thread_count(const char *opt, const char *arg)
2600 {
2601 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2602 #if !HAVE_THREADS
2603 if (verbose >= 0)
2604 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2605 #endif
2606 return 0;
2607 }
2608
2609 static void opt_audio_sample_fmt(const char *arg)
2610 {
2611 if (strcmp(arg, "list"))
2612 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2613 else {
2614 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2615 av_exit(0);
2616 }
2617 }
2618
2619 static int opt_audio_rate(const char *opt, const char *arg)
2620 {
2621 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2622 return 0;
2623 }
2624
2625 static int opt_audio_channels(const char *opt, const char *arg)
2626 {
2627 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2628 return 0;
2629 }
2630
2631 static void opt_video_channel(const char *arg)
2632 {
2633 video_channel = strtol(arg, NULL, 0);
2634 }
2635
2636 static void opt_video_standard(const char *arg)
2637 {
2638 video_standard = av_strdup(arg);
2639 }
2640
2641 static void opt_codec(int *pstream_copy, char **pcodec_name,
2642 int codec_type, const char *arg)
2643 {
2644 av_freep(pcodec_name);
2645 if (!strcmp(arg, "copy")) {
2646 *pstream_copy = 1;
2647 } else {
2648 *pcodec_name = av_strdup(arg);
2649 }
2650 }
2651
2652 static void opt_audio_codec(const char *arg)
2653 {
2654 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2655 }
2656
2657 static void opt_audio_tag(const char *arg)
2658 {
2659 char *tail;
2660 audio_codec_tag= strtol(arg, &tail, 0);
2661
2662 if(!tail || *tail)
2663 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2664 }
2665
2666 static void opt_video_tag(const char *arg)
2667 {
2668 char *tail;
2669 video_codec_tag= strtol(arg, &tail, 0);
2670
2671 if(!tail || *tail)
2672 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2673 }
2674
2675 static void opt_video_codec(const char *arg)
2676 {
2677 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2678 }
2679
2680 static void opt_subtitle_codec(const char *arg)
2681 {
2682 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2683 }
2684
2685 static void opt_subtitle_tag(const char *arg)
2686 {
2687 char *tail;
2688 subtitle_codec_tag= strtol(arg, &tail, 0);
2689
2690 if(!tail || *tail)
2691 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2692 }
2693
2694 static void opt_map(const char *arg)
2695 {
2696 AVStreamMap *m;
2697 char *p;
2698
2699 m = &stream_maps[nb_stream_maps++];
2700
2701 m->file_index = strtol(arg, &p, 0);
2702 if (*p)
2703 p++;
2704
2705 m->stream_index = strtol(p, &p, 0);
2706 if (*p) {
2707 p++;
2708 m->sync_file_index = strtol(p, &p, 0);
2709 if (*p)
2710 p++;
2711 m->sync_stream_index = strtol(p, &p, 0);
2712 } else {
2713 m->sync_file_index = m->file_index;
2714 m->sync_stream_index = m->stream_index;
2715 }
2716 }
2717
2718 static void opt_map_meta_data(const char *arg)
2719 {
2720 AVMetaDataMap *m;
2721 char *p;
2722
2723 m = &meta_data_maps[nb_meta_data_maps++];
2724
2725 m->out_file = strtol(arg, &p, 0);
2726 if (*p)
2727 p++;
2728
2729 m->in_file = strtol(p, &p, 0);
2730 }
2731
2732 static void opt_input_ts_scale(const char *arg)
2733 {
2734 unsigned int stream;
2735 double scale;
2736 char *p;
2737
2738 stream = strtol(arg, &p, 0);
2739 if (*p)
2740 p++;
2741 scale= strtod(p, &p);
2742
2743 if(stream >= MAX_STREAMS)
2744 av_exit(1);
2745
2746 input_files_ts_scale[nb_input_files][stream]= scale;
2747 }
2748
2749 static int opt_recording_time(const char *opt, const char *arg)
2750 {
2751 recording_time = parse_time_or_die(opt, arg, 1);
2752 return 0;
2753 }
2754
2755 static int opt_start_time(const char *opt, const char *arg)
2756 {
2757 start_time = parse_time_or_die(opt, arg, 1);
2758 return 0;
2759 }
2760
2761 static int opt_rec_timestamp(const char *opt, const char *arg)
2762 {
2763 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2764 return 0;
2765 }
2766
2767 static int opt_input_ts_offset(const char *opt, const char *arg)
2768 {
2769 input_ts_offset = parse_time_or_die(opt, arg, 1);
2770 return 0;
2771 }
2772
2773 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2774 {
2775 const char *codec_string = encoder ? "encoder" : "decoder";
2776 AVCodec *codec;
2777
2778 if(!name)
2779 return CODEC_ID_NONE;
2780 codec = encoder ?
2781 avcodec_find_encoder_by_name(name) :
2782 avcodec_find_decoder_by_name(name);
2783 if(!codec) {
2784 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2785 av_exit(1);
2786 }
2787 if(codec->type != type) {
2788 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2789 av_exit(1);
2790 }
2791 return codec->id;
2792 }
2793
2794 static void opt_input_file(const char *filename)
2795 {
2796 AVFormatContext *ic;
2797 AVFormatParameters params, *ap = &params;
2798 int err, i, ret, rfps, rfps_base;
2799 int64_t timestamp;
2800
2801 if (!strcmp(filename, "-"))
2802 filename = "pipe:";
2803
2804 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2805 !strcmp(filename, "/dev/stdin");
2806
2807 /* get default parameters from command line */
2808 ic = avformat_alloc_context();
2809
2810 memset(ap, 0, sizeof(*ap));
2811 ap->prealloced_context = 1;
2812 ap->sample_rate = audio_sample_rate;
2813 ap->channels = audio_channels;
2814 ap->time_base.den = frame_rate.num;
2815 ap->time_base.num = frame_rate.den;
2816 ap->width = frame_width + frame_padleft + frame_padright;
2817 ap->height = frame_height + frame_padtop + frame_padbottom;
2818 ap->pix_fmt = frame_pix_fmt;
2819 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2820 ap->channel = video_channel;
2821 ap->standard = video_standard;
2822 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2823 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2824 if(pgmyuv_compatibility_hack)
2825 ap->video_codec_id= CODEC_ID_PGMYUV;
2826
2827 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2828
2829 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2830 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2831 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2832 ic->flags |= AVFMT_FLAG_NONBLOCK;
2833
2834 /* open the input file with generic libav function */
2835 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2836 if (err < 0) {
2837 print_error(filename, err);
2838 av_exit(1);
2839 }
2840 if(opt_programid) {
2841 int i;
2842 for(i=0; i<ic->nb_programs; i++)
2843 if(ic->programs[i]->id != opt_programid)
2844 ic->programs[i]->discard = AVDISCARD_ALL;
2845 }
2846
2847 ic->loop_input = loop_input;
2848
2849 /* If not enough info to get the stream parameters, we decode the
2850 first frames to get it. (used in mpeg case for example) */
2851 ret = av_find_stream_info(ic);
2852 if (ret < 0 && verbose >= 0) {
2853 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2854 av_exit(1);
2855 }
2856
2857 timestamp = start_time;
2858 /* add the stream start time */
2859 if (ic->start_time != AV_NOPTS_VALUE)
2860 timestamp += ic->start_time;
2861
2862 /* if seeking requested, we execute it */
2863 if (start_time != 0) {
2864 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2865 if (ret < 0) {
2866 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2867 filename, (double)timestamp / AV_TIME_BASE);
2868 }
2869 /* reset seek info */
2870 start_time = 0;
2871 }
2872
2873 /* update the current parameters so that they match the one of the input stream */
2874 for(i=0;i<ic->nb_streams;i++) {
2875 AVCodecContext *enc = ic->streams[i]->codec;
2876 if(thread_count>1)
2877 avcodec_thread_init(enc, thread_count);
2878 enc->thread_count= thread_count;
2879 switch(enc->codec_type) {
2880 case CODEC_TYPE_AUDIO:
2881 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2882 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2883 channel_layout = enc->channel_layout;
2884 audio_channels = enc->channels;
2885 audio_sample_rate = enc->sample_rate;
2886 audio_sample_fmt = enc->sample_fmt;
2887 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2888 if(audio_disable)
2889 ic->streams[i]->discard= AVDISCARD_ALL;
2890 break;
2891 case CODEC_TYPE_VIDEO:
2892 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2893 frame_height = enc->height;
2894 frame_width = enc->width;
2895 if(ic->streams[i]->sample_aspect_ratio.num)
2896 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2897 else
2898 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2899 frame_aspect_ratio *= (float) enc->width / enc->height;
2900 frame_pix_fmt = enc->pix_fmt;
2901 rfps = ic->streams[i]->r_frame_rate.num;
2902 rfps_base = ic->streams[i]->r_frame_rate.den;
2903 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2904 if(me_threshold)
2905 enc->debug |= FF_DEBUG_MV;
2906
2907 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2908
2909 if (verbose >= 0)
2910 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2911 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2912
2913 (float)rfps / rfps_base, rfps, rfps_base);
2914 }
2915 /* update the current frame rate to match the stream frame rate */
2916 frame_rate.num = rfps;
2917 frame_rate.den = rfps_base;
2918
2919 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2920 if(video_disable)
2921 ic->streams[i]->discard= AVDISCARD_ALL;
2922 else if(video_discard)
2923 ic->streams[i]->discard= video_discard;
2924 break;
2925 case CODEC_TYPE_DATA:
2926 break;
2927 case CODEC_TYPE_SUBTITLE:
2928 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2929 if(subtitle_disable)
2930 ic->streams[i]->discard = AVDISCARD_ALL;
2931 break;
2932 case CODEC_TYPE_ATTACHMENT:
2933 case CODEC_TYPE_UNKNOWN:
2934 nb_icodecs++;
2935 break;
2936 default:
2937 abort();
2938 }
2939 }
2940
2941 input_files[nb_input_files] = ic;
2942 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2943 /* dump the file content */
2944 if (verbose >= 0)
2945 dump_format(ic, nb_input_files, filename, 0);
2946
2947 nb_input_files++;
2948 file_iformat = NULL;
2949 file_oformat = NULL;
2950
2951 video_channel = 0;
2952
2953 av_freep(&video_codec_name);
2954 av_freep(&audio_codec_name);
2955 av_freep(&subtitle_codec_name);
2956 }
2957
2958 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2959 int *has_subtitle_ptr)
2960 {
2961 int has_video, has_audio, has_subtitle, i, j;
2962 AVFormatContext *ic;
2963
2964 has_video = 0;
2965 has_audio = 0;
2966 has_subtitle = 0;
2967 for(j=0;j<nb_input_files;j++) {
2968 ic = input_files[j];
2969 for(i=0;i<ic->nb_streams;i++) {
2970 AVCodecContext *enc = ic->streams[i]->codec;
2971 switch(enc->codec_type) {
2972 case CODEC_TYPE_AUDIO:
2973 has_audio = 1;
2974 break;
2975 case CODEC_TYPE_VIDEO:
2976 has_video = 1;
2977 break;
2978 case CODEC_TYPE_SUBTITLE:
2979 has_subtitle = 1;
2980 break;
2981 case CODEC_TYPE_DATA:
2982 case CODEC_TYPE_ATTACHMENT:
2983 case CODEC_TYPE_UNKNOWN:
2984 break;
2985 default:
2986 abort();
2987 }
2988 }
2989 }
2990 *has_video_ptr = has_video;
2991 *has_audio_ptr = has_audio;
2992 *has_subtitle_ptr = has_subtitle;
2993 }
2994
2995 static void new_video_stream(AVFormatContext *oc)
2996 {
2997 AVStream *st;
2998 AVCodecContext *video_enc;
2999 int codec_id;
3000
3001 st = av_new_stream(oc, oc->nb_streams);
3002 if (!st) {
3003 fprintf(stderr, "Could not alloc stream\n");
3004 av_exit(1);
3005 }
3006 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3007 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3008 video_bitstream_filters= NULL;
3009
3010 if(thread_count>1)
3011 avcodec_thread_init(st->codec, thread_count);
3012
3013 video_enc = st->codec;
3014
3015 if(video_codec_tag)
3016 video_enc->codec_tag= video_codec_tag;
3017
3018 if( (video_global_header&1)
3019 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3020 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3021 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3022 }
3023 if(video_global_header&2){
3024 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3025 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3026 }
3027
3028 if (video_stream_copy) {
3029 st->stream_copy = 1;
3030 video_enc->codec_type = CODEC_TYPE_VIDEO;
3031 video_enc->sample_aspect_ratio =
3032 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3033 } else {
3034 const char *p;
3035 int i;
3036 AVCodec *codec;
3037 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3038
3039 if (video_codec_name) {
3040 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3041 codec = avcodec_find_encoder_by_name(video_codec_name);
3042 output_codecs[nb_ocodecs] = codec;
3043 } else {
3044 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3045 codec = avcodec_find_encoder(codec_id);
3046 }
3047
3048 video_enc->codec_id = codec_id;
3049
3050 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3051
3052 if (codec && codec->supported_framerates && !force_fps)
3053 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3054 video_enc->time_base.den = fps.num;
3055 video_enc->time_base.num = fps.den;
3056
3057 video_enc->width = frame_width + frame_padright + frame_padleft;
3058 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3059 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3060 video_enc->pix_fmt = frame_pix_fmt;
3061 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3062
3063 if(codec && codec->pix_fmts){
3064 const enum PixelFormat *p= codec->pix_fmts;
3065 for(; *p!=-1; p++){
3066 if(*p == video_enc->pix_fmt)
3067 break;
3068 }
3069 if(*p == -1)
3070 video_enc->pix_fmt = codec->pix_fmts[0];
3071 }
3072
3073 if (intra_only)
3074 video_enc->gop_size = 0;
3075 if (video_qscale || same_quality) {
3076 video_enc->flags |= CODEC_FLAG_QSCALE;
3077 video_enc->global_quality=
3078 st->quality = FF_QP2LAMBDA * video_qscale;
3079 }
3080
3081 if(intra_matrix)
3082 video_enc->intra_matrix = intra_matrix;
3083 if(inter_matrix)
3084 video_enc->inter_matrix = inter_matrix;
3085
3086 video_enc->thread_count = thread_count;
3087 p= video_rc_override_string;
3088 for(i=0; p; i++){
3089 int start, end, q;
3090 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3091 if(e!=3){
3092 fprintf(stderr, "error parsing rc_override\n");
3093 av_exit(1);
3094 }
3095 video_enc->rc_override=
3096 av_realloc(video_enc->rc_override,
3097 sizeof(RcOverride)*(i+1));
3098 video_enc->rc_override[i].start_frame= start;
3099 video_enc->rc_override[i].end_frame = end;
3100 if(q>0){
3101 video_enc->rc_override[i].qscale= q;
3102 video_enc->rc_override[i].quality_factor= 1.0;
3103 }
3104 else{
3105 video_enc->rc_override[i].qscale= 0;
3106 video_enc->rc_override[i].quality_factor= -q/100.0;
3107 }
3108 p= strchr(p, '/');
3109 if(p) p++;
3110 }
3111 video_enc->rc_override_count=i;
3112 if (!video_enc->rc_initial_buffer_occupancy)
3113 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3114 video_enc->me_threshold= me_threshold;
3115 video_enc->intra_dc_precision= intra_dc_precision - 8;
3116
3117 if (do_psnr)
3118 video_enc->flags|= CODEC_FLAG_PSNR;
3119
3120 /* two pass mode */
3121 if (do_pass) {
3122 if (do_pass == 1) {
3123 video_enc->flags |= CODEC_FLAG_PASS1;
3124 } else {
3125 video_enc->flags |= CODEC_FLAG_PASS2;
3126 }
3127 }
3128 }
3129 nb_ocodecs++;
3130
3131 /* reset some key parameters */
3132 video_disable = 0;
3133 av_freep(&video_codec_name);
3134 video_stream_copy = 0;
3135 }
3136
3137 static void new_audio_stream(AVFormatContext *oc)
3138 {
3139 AVStream *st;
3140 AVCodecContext *audio_enc;
3141 int codec_id;
3142
3143 st = av_new_stream(oc, oc->nb_streams);
3144 if (!st) {
3145 fprintf(stderr, "Could not alloc stream\n");
3146 av_exit(1);
3147 }
3148 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3149
3150 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3151 audio_bitstream_filters= NULL;
3152
3153 if(thread_count>1)
3154 avcodec_thread_init(st->codec, thread_count);
3155
3156 audio_enc = st->codec;
3157 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3158
3159 if(audio_codec_tag)
3160 audio_enc->codec_tag= audio_codec_tag;
3161
3162 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3163 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3164 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3165 }
3166 if (audio_stream_copy) {
3167 st->stream_copy = 1;
3168 audio_enc->channels = audio_channels;
3169 } else {
3170 AVCodec *codec;
3171
3172 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3173
3174 if (audio_codec_name) {
3175 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3176 codec = avcodec_find_encoder_by_name(audio_codec_name);
3177 output_codecs[nb_ocodecs] = codec;
3178 } else {
3179 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3180 codec = avcodec_find_encoder(codec_id);
3181 }
3182 audio_enc->codec_id = codec_id;
3183
3184 if (audio_qscale > QSCALE_NONE) {
3185 audio_enc->flags |= CODEC_FLAG_QSCALE;
3186 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3187 }
3188 audio_enc->thread_count = thread_count;
3189 audio_enc->channels = audio_channels;
3190 audio_enc->sample_fmt = audio_sample_fmt;
3191 audio_enc->channel_layout = channel_layout;
3192
3193 if(codec && codec->sample_fmts){
3194 const enum SampleFormat *p= codec->sample_fmts;
3195 for(; *p!=-1; p++){
3196 if(*p == audio_enc->sample_fmt)
3197 break;
3198 }
3199 if(*p == -1)
3200 audio_enc->sample_fmt = codec->sample_fmts[0];
3201 }
3202 }
3203 nb_ocodecs++;
3204 audio_enc->sample_rate = audio_sample_rate;
3205 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3206 if (audio_language) {
3207 av_metadata_set(&st->metadata, "language", audio_language);
3208 av_free(audio_language);
3209 audio_language = NULL;
3210 }
3211
3212 /* reset some key parameters */
3213 audio_disable = 0;
3214 av_freep(&audio_codec_name);
3215 audio_stream_copy = 0;
3216 }
3217
3218 static void new_subtitle_stream(AVFormatContext *oc)
3219 {
3220 AVStream *st;
3221 AVCodecContext *subtitle_enc;
3222
3223 st = av_new_stream(oc, oc->nb_streams);
3224 if (!st) {
3225 fprintf(stderr, "Could not alloc stream\n");
3226 av_exit(1);
3227 }
3228 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3229
3230 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3231 subtitle_bitstream_filters= NULL;
3232
3233 subtitle_enc = st->codec;
3234 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3235
3236 if(subtitle_codec_tag)
3237 subtitle_enc->codec_tag= subtitle_codec_tag;
3238
3239 if (subtitle_stream_copy) {
3240 st->stream_copy = 1;
3241 } else {
3242 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3243 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3244 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3245 }
3246 nb_ocodecs++;
3247
3248 if (subtitle_language) {
3249 av_metadata_set(&st->metadata, "language", subtitle_language);
3250 av_free(subtitle_language);
3251 subtitle_language = NULL;
3252 }
3253
3254 subtitle_disable = 0;
3255 av_freep(&subtitle_codec_name);
3256 subtitle_stream_copy = 0;
3257 }
3258
3259 static void opt_new_audio_stream(void)
3260 {
3261 AVFormatContext *oc;
3262 if (nb_output_files <= 0) {
3263 fprintf(stderr, "At least one output file must be specified\n");
3264 av_exit(1);
3265 }
3266 oc = output_files[nb_output_files - 1];
3267 new_audio_stream(oc);
3268 }
3269
3270 static void opt_new_video_stream(void)
3271 {
3272 AVFormatContext *oc;
3273 if (nb_output_files <= 0) {
3274 fprintf(stderr, "At least one output file must be specified\n");
3275 av_exit(1);
3276 }
3277 oc = output_files[nb_output_files - 1];
3278 new_video_stream(oc);
3279 }
3280
3281 static void opt_new_subtitle_stream(void)
3282 {
3283 AVFormatContext *oc;
3284 if (nb_output_files <= 0) {
3285 fprintf(stderr, "At least one output file must be specified\n");
3286 av_exit(1);
3287 }
3288 oc = output_files[nb_output_files - 1];
3289 new_subtitle_stream(oc);
3290 }
3291
3292 static void opt_output_file(const char *filename)
3293 {
3294 AVFormatContext *oc;
3295 int use_video, use_audio, use_subtitle;
3296 int input_has_video, input_has_audio, input_has_subtitle;
3297 AVFormatParameters params, *ap = &params;
3298
3299 if (!strcmp(filename, "-"))
3300 filename = "pipe:";
3301
3302 oc = avformat_alloc_context();
3303
3304 if (!file_oformat) {
3305 file_oformat = guess_format(NULL, filename, NULL);
3306 if (!file_oformat) {
3307 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3308 filename);
3309 av_exit(1);
3310 }
3311 }
3312
3313 oc->oformat = file_oformat;
3314 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3315
3316 if (!strcmp(file_oformat->name, "ffm") &&
3317 av_strstart(filename, "http:", NULL)) {
3318 /* special case for files sent to ffserver: we get the stream
3319 parameters from ffserver */
3320 int err = read_ffserver_streams(oc, filename);
3321 if (err < 0) {
3322 print_error(filename, err);
3323 av_exit(1);
3324 }
3325 } else {
3326 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3327 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3328 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3329
3330 /* disable if no corresponding type found and at least one
3331 input file */
3332 if (nb_input_files > 0) {
3333 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3334 &input_has_subtitle);
3335 if (!input_has_video)
3336 use_video = 0;
3337 if (!input_has_audio)
3338 use_audio = 0;
3339 if (!input_has_subtitle)
3340 use_subtitle = 0;
3341 }
3342
3343 /* manual disable */
3344 if (audio_disable) {
3345 use_audio = 0;
3346 }
3347 if (video_disable) {
3348 use_video = 0;
3349 }
3350 if (subtitle_disable) {
3351 use_subtitle = 0;
3352 }
3353
3354 if (use_video) {
3355 new_video_stream(oc);
3356 }
3357
3358 if (use_audio) {
3359 new_audio_stream(oc);
3360 }
3361
3362 if (use_subtitle) {
3363 new_subtitle_stream(oc);
3364 }
3365
3366 oc->timestamp = rec_timestamp;
3367
3368 for(; metadata_count>0; metadata_count--){
3369 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3370 metadata[metadata_count-1].value);
3371 }
3372 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3373 }
3374
3375 output_files[nb_output_files++] = oc;
3376
3377 /* check filename in case of an image number is expected */
3378 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3379 if (!av_filename_number_test(oc->filename)) {
3380 print_error(oc->filename, AVERROR_NUMEXPECTED);
3381 av_exit(1);
3382 }
3383 }
3384
3385 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3386 /* test if it already exists to avoid loosing precious files */
3387 if (!file_overwrite &&
3388 (strchr(filename, ':') == NULL ||
3389 filename[1] == ':' ||
3390 av_strstart(filename, "file:", NULL))) {
3391 if (url_exist(filename)) {
3392 int c;
3393
3394 if (!using_stdin) {
3395 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3396 fflush(stderr);
3397 c = getchar();
3398 if (toupper(c) != 'Y') {
3399 fprintf(stderr, "Not overwriting - exiting\n");
3400 av_exit(1);
3401 }
3402 }
3403 else {
3404 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3405 av_exit(1);
3406 }
3407 }
3408 }
3409
3410 /* open the file */
3411 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3412 fprintf(stderr, "Could not open '%s'\n", filename);
3413 av_exit(1);
3414 }
3415 }
3416
3417 memset(ap, 0, sizeof(*ap));
3418 if (av_set_parameters(oc, ap) < 0) {
3419 fprintf(stderr, "%s: Invalid encoding parameters\n",
3420 oc->filename);
3421 av_exit(1);
3422 }
3423
3424 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3425 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3426 oc->loop_output = loop_output;
3427 oc->flags |= AVFMT_FLAG_NONBLOCK;
3428
3429 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3430
3431 /* reset some options */
3432 file_oformat = NULL;
3433 file_iformat = NULL;
3434 }
3435
3436 /* same option as mencoder */
3437 static void opt_pass(const char *pass_str)
3438 {
3439 int pass;
3440 pass = atoi(pass_str);
3441 if (pass != 1 && pass != 2) {
3442 fprintf(stderr, "pass number can be only 1 or 2\n");
3443 av_exit(1);
3444 }
3445 do_pass = pass;
3446 }
3447
3448 static int64_t getutime(void)
3449 {
3450 #if HAVE_GETRUSAGE
3451 struct rusage rusage;
3452
3453 getrusage(RUSAGE_SELF, &rusage);
3454 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3455 #elif HAVE_GETPROCESSTIMES
3456 HANDLE proc;
3457 FILETIME c, e, k, u;
3458 proc = GetCurrentProcess();
3459 GetProcessTimes(proc, &c, &e, &k, &u);
3460 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3461 #else
3462 return av_gettime();
3463 #endif
3464 }
3465
3466 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3467 {
3468 int i;
3469 const char *p = str;
3470 for(i = 0;; i++) {
3471 dest[i] = atoi(p);
3472 if(i == 63)
3473 break;
3474 p = strchr(p, ',');
3475 if(!p) {
3476 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3477 av_exit(1);
3478 }
3479 p++;
3480 }
3481 }
3482
3483 static void opt_inter_matrix(const char *arg)
3484 {
3485 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3486 parse_matrix_coeffs(inter_matrix, arg);
3487 }
3488
3489 static void opt_intra_matrix(const char *arg)
3490 {
3491 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3492 parse_matrix_coeffs(intra_matrix, arg);
3493 }
3494
3495 /**
3496 * Trivial log callback.
3497 * Only suitable for show_help and similar since it lacks prefix handling.
3498 */
3499 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3500 {
3501 vfprintf(stdout, fmt, vl);
3502 }
3503
3504 static void show_help(void)
3505 {
3506 av_log_set_callback(log_callback_help);
3507 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3508 "Hyper fast Audio and Video encoder\n");
3509 printf("\n");
3510 show_help_options(options, "Main options:\n",
3511 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3512 show_help_options(options, "\nAdvanced options:\n",
3513 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3514 OPT_EXPERT);
3515 show_help_options(options, "\nVideo options:\n",
3516 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3517 OPT_VIDEO);
3518 show_help_options(options, "\nAdvanced Video options:\n",
3519 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3520 OPT_VIDEO | OPT_EXPERT);
3521 show_help_options(options, "\nAudio options:\n",
3522 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3523 OPT_AUDIO);
3524 show_help_options(options, "\nAdvanced Audio options:\n",
3525 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3526 OPT_AUDIO | OPT_EXPERT);
3527 show_help_options(options, "\nSubtitle options:\n",
3528 OPT_SUBTITLE | OPT_GRAB,
3529 OPT_SUBTITLE);
3530 show_help_options(options, "\nAudio/Video grab options:\n",
3531 OPT_GRAB,
3532 OPT_GRAB);
3533 printf("\n");
3534 av_opt_show(avcodec_opts[0], NULL);
3535 printf("\n");
3536 av_opt_show(avformat_opts, NULL);
3537 printf("\n");
3538 av_opt_show(sws_opts, NULL);
3539 }
3540
3541 static void opt_target(const char *arg)
3542 {
3543 int norm = -1;
3544 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3545
3546 if(!strncmp(arg, "pal-", 4)) {
3547 norm = 0;
3548 arg += 4;
3549 } else if(!strncmp(arg, "ntsc-", 5)) {
3550 norm = 1;
3551 arg += 5;
3552 } else if(!strncmp(arg, "film-", 5)) {
3553 norm = 2;
3554 arg += 5;
3555 } else {
3556 int fr;
3557 /* Calculate FR via float to avoid int overflow */
3558 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3559 if(fr == 25000) {
3560 norm = 0;
3561 } else if((fr == 29970) || (fr == 23976)) {
3562 norm = 1;
3563 } else {
3564 /* Try to determine PAL/NTSC by peeking in the input files */
3565 if(nb_input_files) {
3566 int i, j;
3567 for(j = 0; j < nb_input_files; j++) {
3568 for(i = 0; i < input_files[j]->nb_streams; i++) {
3569 AVCodecContext *c = input_files[j]->streams[i]->codec;
3570 if(c->codec_type != CODEC_TYPE_VIDEO)
3571 continue;
3572 fr = c->time_base.den * 1000 / c->time_base.num;
3573 if(fr == 25000) {
3574 norm = 0;
3575 break;
3576 } else if((fr == 29970) || (fr == 23976)) {
3577 norm = 1;
3578 break;
3579 }
3580 }
3581 if(norm >= 0)
3582 break;
3583 }
3584 }
3585 }
3586 if(verbose && norm >= 0)
3587 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3588 }
3589
3590 if(norm < 0) {
3591 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3592 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3593 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3594 av_exit(1);
3595 }
3596
3597 if(!strcmp(arg, "vcd")) {
3598
3599 opt_video_codec("mpeg1video");
3600 opt_audio_codec("mp2");
3601 opt_format("vcd");
3602
3603 opt_frame_size(norm ? "352x240" : "352x288");
3604 opt_frame_rate(NULL, frame_rates[norm]);
3605 opt_default("gop", norm ? "18" : "15");
3606
3607 opt_default("b", "1150000");
3608 opt_default("maxrate", "1150000");
3609 opt_default("minrate", "1150000");
3610 opt_default("bufsize", "327680"); // 40*1024*8;
3611
3612 opt_default("ab", "224000");
3613 audio_sample_rate = 44100;
3614 audio_channels = 2;
3615
3616 opt_default("packetsize", "2324");
3617 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3618
3619 /* We have to offset the PTS, so that it is consistent with the SCR.
3620 SCR starts at 36000, but the first two packs contain only padding
3621 and the first pack from the other stream, respectively, may also have
3622 been written before.
3623 So the real data starts at SCR 36000+3*1200. */
3624 mux_preload= (36000+3*1200) / 90000.0; //0.44
3625 } else if(!strcmp(arg, "svcd")) {
3626
3627 opt_video_codec("mpeg2video");
3628 opt_audio_codec("mp2");
3629 opt_format("svcd");
3630
3631 opt_frame_size(norm ? "480x480" : "480x576");
3632 opt_frame_rate(NULL, frame_rates[norm]);
3633 opt_default("gop", norm ? "18" : "15");
3634
3635 opt_default("b", "2040000");
3636 opt_default("maxrate", "2516000");
3637 opt_default("minrate", "0"); //1145000;
3638 opt_default("bufsize", "1835008"); //224*1024*8;
3639 opt_default("flags", "+scan_offset");
3640
3641
3642 opt_default("ab", "224000");
3643 audio_sample_rate = 44100;
3644
3645 opt_default("packetsize", "2324");
3646
3647 } else if(!strcmp(arg, "dvd")) {
3648
3649 opt_video_codec("mpeg2video");
3650 opt_audio_codec("ac3");
3651 opt_format("dvd");
3652
3653 opt_frame_size(norm ? "720x480" : "720x576");
3654 opt_frame_rate(NULL, frame_rates[norm]);
3655 opt_default("gop", norm ? "18" : "15");
3656
3657 opt_default("b", "6000000");
3658 opt_default("maxrate", "9000000");
3659 opt_default("minrate", "0"); //1500000;
3660 opt_default("bufsize", "1835008"); //224*1024*8;
3661
3662 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3663 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3664
3665 opt_default("ab", "448000");
3666 audio_sample_rate = 48000;
3667
3668 } else if(!strncmp(arg, "dv", 2)) {
3669
3670 opt_format("dv");
3671
3672 opt_frame_size(norm ? "720x480" : "720x576");
3673 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3674 (norm ? "yuv411p" : "yuv420p"));
3675 opt_frame_rate(NULL, frame_rates[norm]);
3676
3677 audio_sample_rate = 48000;
3678 audio_channels = 2;
3679
3680 } else {
3681 fprintf(stderr, "Unknown target: %s\n", arg);
3682 av_exit(1);
3683 }
3684 }
3685
3686 static void opt_vstats_file (const char *arg)
3687 {
3688 av_free (vstats_filename);
3689 vstats_filename=av_strdup (arg);
3690 }
3691
3692 static void opt_vstats (void)
3693 {
3694 char filename[40];
3695 time_t today2 = time(NULL);
3696 struct tm *today = localtime(&today2);
3697
3698 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3699 today->tm_sec);
3700 opt_vstats_file(filename);
3701 }
3702
3703 static int opt_bsf(const char *opt, const char *arg)
3704 {
3705 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3706 AVBitStreamFilterContext **bsfp;
3707
3708 if(!bsfc){
3709 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3710 av_exit(1);
3711 }
3712
3713 bsfp= *opt == 'v' ? &video_bitstream_filters :
3714 *opt == 'a' ? &audio_bitstream_filters :
3715 &subtitle_bitstream_filters;
3716 while(*bsfp)
3717 bsfp= &(*bsfp)->next;
3718
3719 *bsfp= bsfc;
3720
3721 return 0;
3722 }
3723
3724 static int opt_preset(const char *opt, const char *arg)
3725 {
3726 FILE *f=NULL;
3727 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3728 int i;
3729 const char *base[2]= { getenv("HOME"),
3730 FFMPEG_DATADIR,
3731 };
3732
3733 for(i=!base[0]; i<2 && !f; i++){
3734 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3735 f= fopen(filename, "r");
3736 if(!f){
3737 char *codec_name= *opt == 'v' ? video_codec_name :
3738 *opt == 'a' ? audio_codec_name :
3739 subtitle_codec_name;
3740 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3741 f= fopen(filename, "r");
3742 }
3743 }
3744 if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3745 is_dos_path(arg))){
3746 av_strlcpy(filename, arg, sizeof(filename));
3747 f= fopen(filename, "r");
3748 }
3749
3750 if(!f){
3751 fprintf(stderr, "File for preset '%s' not found\n", arg);
3752 av_exit(1);
3753 }
3754
3755 while(!feof(f)){
3756 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3757 if(line[0] == '#' && !e)
3758 continue;
3759 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3760 if(e){
3761 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3762 av_exit(1);
3763 }
3764 if(!strcmp(tmp, "acodec")){
3765 opt_audio_codec(tmp2);
3766 }else if(!strcmp(tmp, "vcodec")){
3767 opt_video_codec(tmp2);
3768 }else if(!strcmp(tmp, "scodec")){
3769 opt_subtitle_codec(tmp2);
3770 }else if(opt_default(tmp, tmp2) < 0){
3771 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3772 av_exit(1);
3773 }
3774 }
3775
3776 fclose(f);
3777
3778 return 0;
3779 }
3780
3781 static const OptionDef options[] = {
3782 /* main options */
3783 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3784 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3785 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3786 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3787 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3788 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3789 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3790 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3791 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3792 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3793 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3794 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3795 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3796 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3797 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3798 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)&opt_metadata}, "add metadata", "string=string" },
3799 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3800 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3801 "add timings for benchmarking" },
3802 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3803 "dump each input packet" },
3804 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3805 "when dumping packets, also dump the payload" },
3806 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3807 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3808 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3809 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3810 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3811 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3812 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3813 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3814 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3815 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3816 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3817 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3818 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3819 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3820 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3821 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3822
3823 /* video options */
3824 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3825 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3826 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3827 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3828 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3829 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3830 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3831 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3832 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3833 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3834 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3835 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3836 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3837 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3838 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3839 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3840 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3841 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3842 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3843 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3844 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3845 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3846 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3847 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3848 "use same video quality as source (implies VBR)" },
3849 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3850 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3851 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3852 "deinterlace pictures" },
3853 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3854 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3855 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3856 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3857 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3858 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3859 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3860 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3861 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3862 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3863 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3864
3865 /* audio options */
3866 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3867 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3868 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3869 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3870 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3871 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3872 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3873 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3874 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3875 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3876 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3877 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3878
3879 /* subtitle options */
3880 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3881 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3882 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3883 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3884 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3885
3886 /* grab options */
3887 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3888 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3889 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3890
3891 /* muxer options */
3892 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3893 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3894
3895 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3896 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3897 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3898
3899 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3900 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3901 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3902
3903 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3904 { NULL, },
3905 };
3906
3907 int main(int argc, char **argv)
3908 {
3909 int i;
3910 int64_t ti;
3911
3912 avcodec_register_all();
3913 avdevice_register_all();
3914 av_register_all();
3915
3916 if(isatty(STDIN_FILENO))
3917 url_set_interrupt_cb(decode_interrupt_cb);
3918
3919 for(i=0; i<CODEC_TYPE_NB; i++){
3920 avcodec_opts[i]= avcodec_alloc_context2(i);
3921 }
3922 avformat_opts = avformat_alloc_context();
3923 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3924
3925 show_banner();
3926
3927 /* parse options */
3928 parse_options(argc, argv, options, opt_output_file);
3929
3930 /* file converter / grab */
3931 if (nb_output_files <= 0) {
3932 fprintf(stderr, "At least one output file must be specified\n");
3933 av_exit(1);
3934 }
3935
3936 if (nb_input_files == 0) {
3937 fprintf(stderr, "At least one input file must be specified\n");
3938 av_exit(1);
3939 }
3940
3941 ti = getutime();
3942 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3943 stream_maps, nb_stream_maps) < 0)
3944 av_exit(1);
3945 ti = getutime() - ti;
3946 if (do_benchmark) {
3947 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3948 }
3949
3950 return av_exit(0);
3951 }
lucabe's unfinished and experimental patches for ffmpeg