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