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