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