?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cosmetics: vertical alignment
[FFMpeg-mirror/lagarith.git] / ffmpeg.c
blobcb15120eee193ddc89588108dbb0d2436d3ce418
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)){
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 if (frame_pix_fmt == PIX_FMT_NONE) {
2542 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2543 av_exit(1);
2544 }
2545 } else {
2546 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2547 av_exit(0);
2548 }
2549 }
2550
2551 static void opt_frame_aspect_ratio(const char *arg)
2552 {
2553 int x = 0, y = 0;
2554 double ar = 0;
2555 const char *p;
2556 char *end;
2557
2558 p = strchr(arg, ':');
2559 if (p) {
2560 x = strtol(arg, &end, 10);
2561 if (end == p)
2562 y = strtol(end+1, &end, 10);
2563 if (x > 0 && y > 0)
2564 ar = (double)x / (double)y;
2565 } else
2566 ar = strtod(arg, NULL);
2567
2568 if (!ar) {
2569 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2570 av_exit(1);
2571 }
2572 frame_aspect_ratio = ar;
2573 }
2574
2575 static int opt_metadata(const char *opt, const char *arg)
2576 {
2577 char *mid= strchr(arg, '=');
2578
2579 if(!mid){
2580 fprintf(stderr, "Missing =\n");
2581 av_exit(1);
2582 }
2583 *mid++= 0;
2584
2585 metadata_count++;
2586 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2587 metadata[metadata_count-1].key = av_strdup(arg);
2588 metadata[metadata_count-1].value= av_strdup(mid);
2589
2590 return 0;
2591 }
2592
2593 static void opt_qscale(const char *arg)
2594 {
2595 video_qscale = atof(arg);
2596 if (video_qscale <= 0 ||
2597 video_qscale > 255) {
2598 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2599 av_exit(1);
2600 }
2601 }
2602
2603 static void opt_top_field_first(const char *arg)
2604 {
2605 top_field_first= atoi(arg);
2606 }
2607
2608 static int opt_thread_count(const char *opt, const char *arg)
2609 {
2610 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2611 #if !HAVE_THREADS
2612 if (verbose >= 0)
2613 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2614 #endif
2615 return 0;
2616 }
2617
2618 static void opt_audio_sample_fmt(const char *arg)
2619 {
2620 if (strcmp(arg, "list"))
2621 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2622 else {
2623 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2624 av_exit(0);
2625 }
2626 }
2627
2628 static int opt_audio_rate(const char *opt, const char *arg)
2629 {
2630 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2631 return 0;
2632 }
2633
2634 static int opt_audio_channels(const char *opt, const char *arg)
2635 {
2636 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2637 return 0;
2638 }
2639
2640 static void opt_video_channel(const char *arg)
2641 {
2642 video_channel = strtol(arg, NULL, 0);
2643 }
2644
2645 static void opt_video_standard(const char *arg)
2646 {
2647 video_standard = av_strdup(arg);
2648 }
2649
2650 static void opt_codec(int *pstream_copy, char **pcodec_name,
2651 int codec_type, const char *arg)
2652 {
2653 av_freep(pcodec_name);
2654 if (!strcmp(arg, "copy")) {
2655 *pstream_copy = 1;
2656 } else {
2657 *pcodec_name = av_strdup(arg);
2658 }
2659 }
2660
2661 static void opt_audio_codec(const char *arg)
2662 {
2663 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2664 }
2665
2666 static void opt_audio_tag(const char *arg)
2667 {
2668 char *tail;
2669 audio_codec_tag= strtol(arg, &tail, 0);
2670
2671 if(!tail || *tail)
2672 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2673 }
2674
2675 static void opt_video_tag(const char *arg)
2676 {
2677 char *tail;
2678 video_codec_tag= strtol(arg, &tail, 0);
2679
2680 if(!tail || *tail)
2681 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2682 }
2683
2684 static void opt_video_codec(const char *arg)
2685 {
2686 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2687 }
2688
2689 static void opt_subtitle_codec(const char *arg)
2690 {
2691 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2692 }
2693
2694 static void opt_subtitle_tag(const char *arg)
2695 {
2696 char *tail;
2697 subtitle_codec_tag= strtol(arg, &tail, 0);
2698
2699 if(!tail || *tail)
2700 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2701 }
2702
2703 static void opt_map(const char *arg)
2704 {
2705 AVStreamMap *m;
2706 char *p;
2707
2708 m = &stream_maps[nb_stream_maps++];
2709
2710 m->file_index = strtol(arg, &p, 0);
2711 if (*p)
2712 p++;
2713
2714 m->stream_index = strtol(p, &p, 0);
2715 if (*p) {
2716 p++;
2717 m->sync_file_index = strtol(p, &p, 0);
2718 if (*p)
2719 p++;
2720 m->sync_stream_index = strtol(p, &p, 0);
2721 } else {
2722 m->sync_file_index = m->file_index;
2723 m->sync_stream_index = m->stream_index;
2724 }
2725 }
2726
2727 static void opt_map_meta_data(const char *arg)
2728 {
2729 AVMetaDataMap *m;
2730 char *p;
2731
2732 m = &meta_data_maps[nb_meta_data_maps++];
2733
2734 m->out_file = strtol(arg, &p, 0);
2735 if (*p)
2736 p++;
2737
2738 m->in_file = strtol(p, &p, 0);
2739 }
2740
2741 static void opt_input_ts_scale(const char *arg)
2742 {
2743 unsigned int stream;
2744 double scale;
2745 char *p;
2746
2747 stream = strtol(arg, &p, 0);
2748 if (*p)
2749 p++;
2750 scale= strtod(p, &p);
2751
2752 if(stream >= MAX_STREAMS)
2753 av_exit(1);
2754
2755 input_files_ts_scale[nb_input_files][stream]= scale;
2756 }
2757
2758 static int opt_recording_time(const char *opt, const char *arg)
2759 {
2760 recording_time = parse_time_or_die(opt, arg, 1);
2761 return 0;
2762 }
2763
2764 static int opt_start_time(const char *opt, const char *arg)
2765 {
2766 start_time = parse_time_or_die(opt, arg, 1);
2767 return 0;
2768 }
2769
2770 static int opt_rec_timestamp(const char *opt, const char *arg)
2771 {
2772 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2773 return 0;
2774 }
2775
2776 static int opt_input_ts_offset(const char *opt, const char *arg)
2777 {
2778 input_ts_offset = parse_time_or_die(opt, arg, 1);
2779 return 0;
2780 }
2781
2782 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2783 {
2784 const char *codec_string = encoder ? "encoder" : "decoder";
2785 AVCodec *codec;
2786
2787 if(!name)
2788 return CODEC_ID_NONE;
2789 codec = encoder ?
2790 avcodec_find_encoder_by_name(name) :
2791 avcodec_find_decoder_by_name(name);
2792 if(!codec) {
2793 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2794 av_exit(1);
2795 }
2796 if(codec->type != type) {
2797 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2798 av_exit(1);
2799 }
2800 return codec->id;
2801 }
2802
2803 static void opt_input_file(const char *filename)
2804 {
2805 AVFormatContext *ic;
2806 AVFormatParameters params, *ap = &params;
2807 int err, i, ret, rfps, rfps_base;
2808 int64_t timestamp;
2809
2810 if (!strcmp(filename, "-"))
2811 filename = "pipe:";
2812
2813 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2814 !strcmp(filename, "/dev/stdin");
2815
2816 /* get default parameters from command line */
2817 ic = avformat_alloc_context();
2818
2819 memset(ap, 0, sizeof(*ap));
2820 ap->prealloced_context = 1;
2821 ap->sample_rate = audio_sample_rate;
2822 ap->channels = audio_channels;
2823 ap->time_base.den = frame_rate.num;
2824 ap->time_base.num = frame_rate.den;
2825 ap->width = frame_width + frame_padleft + frame_padright;
2826 ap->height = frame_height + frame_padtop + frame_padbottom;
2827 ap->pix_fmt = frame_pix_fmt;
2828 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2829 ap->channel = video_channel;
2830 ap->standard = video_standard;
2831 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2832 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2833 if(pgmyuv_compatibility_hack)
2834 ap->video_codec_id= CODEC_ID_PGMYUV;
2835
2836 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2837
2838 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2839 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2840 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2841 ic->flags |= AVFMT_FLAG_NONBLOCK;
2842
2843 /* open the input file with generic libav function */
2844 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2845 if (err < 0) {
2846 print_error(filename, err);
2847 av_exit(1);
2848 }
2849 if(opt_programid) {
2850 int i;
2851 for(i=0; i<ic->nb_programs; i++)
2852 if(ic->programs[i]->id != opt_programid)
2853 ic->programs[i]->discard = AVDISCARD_ALL;
2854 }
2855
2856 ic->loop_input = loop_input;
2857
2858 /* If not enough info to get the stream parameters, we decode the
2859 first frames to get it. (used in mpeg case for example) */
2860 ret = av_find_stream_info(ic);
2861 if (ret < 0 && verbose >= 0) {
2862 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2863 av_exit(1);
2864 }
2865
2866 timestamp = start_time;
2867 /* add the stream start time */
2868 if (ic->start_time != AV_NOPTS_VALUE)
2869 timestamp += ic->start_time;
2870
2871 /* if seeking requested, we execute it */
2872 if (start_time != 0) {
2873 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2874 if (ret < 0) {
2875 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2876 filename, (double)timestamp / AV_TIME_BASE);
2877 }
2878 /* reset seek info */
2879 start_time = 0;
2880 }
2881
2882 /* update the current parameters so that they match the one of the input stream */
2883 for(i=0;i<ic->nb_streams;i++) {
2884 AVCodecContext *enc = ic->streams[i]->codec;
2885 if(thread_count>1)
2886 avcodec_thread_init(enc, thread_count);
2887 enc->thread_count= thread_count;
2888 switch(enc->codec_type) {
2889 case CODEC_TYPE_AUDIO:
2890 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2891 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2892 channel_layout = enc->channel_layout;
2893 audio_channels = enc->channels;
2894 audio_sample_rate = enc->sample_rate;
2895 audio_sample_fmt = enc->sample_fmt;
2896 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2897 if(audio_disable)
2898 ic->streams[i]->discard= AVDISCARD_ALL;
2899 break;
2900 case CODEC_TYPE_VIDEO:
2901 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2902 frame_height = enc->height;
2903 frame_width = enc->width;
2904 if(ic->streams[i]->sample_aspect_ratio.num)
2905 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2906 else
2907 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2908 frame_aspect_ratio *= (float) enc->width / enc->height;
2909 frame_pix_fmt = enc->pix_fmt;
2910 rfps = ic->streams[i]->r_frame_rate.num;
2911 rfps_base = ic->streams[i]->r_frame_rate.den;
2912 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2913 if(me_threshold)
2914 enc->debug |= FF_DEBUG_MV;
2915
2916 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2917
2918 if (verbose >= 0)
2919 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2920 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2921
2922 (float)rfps / rfps_base, rfps, rfps_base);
2923 }
2924 /* update the current frame rate to match the stream frame rate */
2925 frame_rate.num = rfps;
2926 frame_rate.den = rfps_base;
2927
2928 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2929 if(video_disable)
2930 ic->streams[i]->discard= AVDISCARD_ALL;
2931 else if(video_discard)
2932 ic->streams[i]->discard= video_discard;
2933 break;
2934 case CODEC_TYPE_DATA:
2935 break;
2936 case CODEC_TYPE_SUBTITLE:
2937 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2938 if(subtitle_disable)
2939 ic->streams[i]->discard = AVDISCARD_ALL;
2940 break;
2941 case CODEC_TYPE_ATTACHMENT:
2942 case CODEC_TYPE_UNKNOWN:
2943 nb_icodecs++;
2944 break;
2945 default:
2946 abort();
2947 }
2948 }
2949
2950 input_files[nb_input_files] = ic;
2951 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2952 /* dump the file content */
2953 if (verbose >= 0)
2954 dump_format(ic, nb_input_files, filename, 0);
2955
2956 nb_input_files++;
2957 file_iformat = NULL;
2958 file_oformat = NULL;
2959
2960 video_channel = 0;
2961
2962 av_freep(&video_codec_name);
2963 av_freep(&audio_codec_name);
2964 av_freep(&subtitle_codec_name);
2965 }
2966
2967 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2968 int *has_subtitle_ptr)
2969 {
2970 int has_video, has_audio, has_subtitle, i, j;
2971 AVFormatContext *ic;
2972
2973 has_video = 0;
2974 has_audio = 0;
2975 has_subtitle = 0;
2976 for(j=0;j<nb_input_files;j++) {
2977 ic = input_files[j];
2978 for(i=0;i<ic->nb_streams;i++) {
2979 AVCodecContext *enc = ic->streams[i]->codec;
2980 switch(enc->codec_type) {
2981 case CODEC_TYPE_AUDIO:
2982 has_audio = 1;
2983 break;
2984 case CODEC_TYPE_VIDEO:
2985 has_video = 1;
2986 break;
2987 case CODEC_TYPE_SUBTITLE:
2988 has_subtitle = 1;
2989 break;
2990 case CODEC_TYPE_DATA:
2991 case CODEC_TYPE_ATTACHMENT:
2992 case CODEC_TYPE_UNKNOWN:
2993 break;
2994 default:
2995 abort();
2996 }
2997 }
2998 }
2999 *has_video_ptr = has_video;
3000 *has_audio_ptr = has_audio;
3001 *has_subtitle_ptr = has_subtitle;
3002 }
3003
3004 static void new_video_stream(AVFormatContext *oc)
3005 {
3006 AVStream *st;
3007 AVCodecContext *video_enc;
3008 int codec_id;
3009
3010 st = av_new_stream(oc, oc->nb_streams);
3011 if (!st) {
3012 fprintf(stderr, "Could not alloc stream\n");
3013 av_exit(1);
3014 }
3015 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3016 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3017 video_bitstream_filters= NULL;
3018
3019 if(thread_count>1)
3020 avcodec_thread_init(st->codec, thread_count);
3021
3022 video_enc = st->codec;
3023
3024 if(video_codec_tag)
3025 video_enc->codec_tag= video_codec_tag;
3026
3027 if( (video_global_header&1)
3028 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3029 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3030 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3031 }
3032 if(video_global_header&2){
3033 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3034 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3035 }
3036
3037 if (video_stream_copy) {
3038 st->stream_copy = 1;
3039 video_enc->codec_type = CODEC_TYPE_VIDEO;
3040 video_enc->sample_aspect_ratio =
3041 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3042 } else {
3043 const char *p;
3044 int i;
3045 AVCodec *codec;
3046 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3047
3048 if (video_codec_name) {
3049 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3050 codec = avcodec_find_encoder_by_name(video_codec_name);
3051 output_codecs[nb_ocodecs] = codec;
3052 } else {
3053 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3054 codec = avcodec_find_encoder(codec_id);
3055 }
3056
3057 video_enc->codec_id = codec_id;
3058
3059 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3060
3061 if (codec && codec->supported_framerates && !force_fps)
3062 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3063 video_enc->time_base.den = fps.num;
3064 video_enc->time_base.num = fps.den;
3065
3066 video_enc->width = frame_width + frame_padright + frame_padleft;
3067 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3068 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3069 video_enc->pix_fmt = frame_pix_fmt;
3070 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3071
3072 if(codec && codec->pix_fmts){
3073 const enum PixelFormat *p= codec->pix_fmts;
3074 for(; *p!=-1; p++){
3075 if(*p == video_enc->pix_fmt)
3076 break;
3077 }
3078 if(*p == -1)
3079 video_enc->pix_fmt = codec->pix_fmts[0];
3080 }
3081
3082 if (intra_only)
3083 video_enc->gop_size = 0;
3084 if (video_qscale || same_quality) {
3085 video_enc->flags |= CODEC_FLAG_QSCALE;
3086 video_enc->global_quality=
3087 st->quality = FF_QP2LAMBDA * video_qscale;
3088 }
3089
3090 if(intra_matrix)
3091 video_enc->intra_matrix = intra_matrix;
3092 if(inter_matrix)
3093 video_enc->inter_matrix = inter_matrix;
3094
3095 video_enc->thread_count = thread_count;
3096 p= video_rc_override_string;
3097 for(i=0; p; i++){
3098 int start, end, q;
3099 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3100 if(e!=3){
3101 fprintf(stderr, "error parsing rc_override\n");
3102 av_exit(1);
3103 }
3104 video_enc->rc_override=
3105 av_realloc(video_enc->rc_override,
3106 sizeof(RcOverride)*(i+1));
3107 video_enc->rc_override[i].start_frame= start;
3108 video_enc->rc_override[i].end_frame = end;
3109 if(q>0){
3110 video_enc->rc_override[i].qscale= q;
3111 video_enc->rc_override[i].quality_factor= 1.0;
3112 }
3113 else{
3114 video_enc->rc_override[i].qscale= 0;
3115 video_enc->rc_override[i].quality_factor= -q/100.0;
3116 }
3117 p= strchr(p, '/');
3118 if(p) p++;
3119 }
3120 video_enc->rc_override_count=i;
3121 if (!video_enc->rc_initial_buffer_occupancy)
3122 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3123 video_enc->me_threshold= me_threshold;
3124 video_enc->intra_dc_precision= intra_dc_precision - 8;
3125
3126 if (do_psnr)
3127 video_enc->flags|= CODEC_FLAG_PSNR;
3128
3129 /* two pass mode */
3130 if (do_pass) {
3131 if (do_pass == 1) {
3132 video_enc->flags |= CODEC_FLAG_PASS1;
3133 } else {
3134 video_enc->flags |= CODEC_FLAG_PASS2;
3135 }
3136 }
3137 }
3138 nb_ocodecs++;
3139
3140 /* reset some key parameters */
3141 video_disable = 0;
3142 av_freep(&video_codec_name);
3143 video_stream_copy = 0;
3144 }
3145
3146 static void new_audio_stream(AVFormatContext *oc)
3147 {
3148 AVStream *st;
3149 AVCodecContext *audio_enc;
3150 int codec_id;
3151
3152 st = av_new_stream(oc, oc->nb_streams);
3153 if (!st) {
3154 fprintf(stderr, "Could not alloc stream\n");
3155 av_exit(1);
3156 }
3157 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3158
3159 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3160 audio_bitstream_filters= NULL;
3161
3162 if(thread_count>1)
3163 avcodec_thread_init(st->codec, thread_count);
3164
3165 audio_enc = st->codec;
3166 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3167
3168 if(audio_codec_tag)
3169 audio_enc->codec_tag= audio_codec_tag;
3170
3171 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3172 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3173 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3174 }
3175 if (audio_stream_copy) {
3176 st->stream_copy = 1;
3177 audio_enc->channels = audio_channels;
3178 } else {
3179 AVCodec *codec;
3180
3181 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3182
3183 if (audio_codec_name) {
3184 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3185 codec = avcodec_find_encoder_by_name(audio_codec_name);
3186 output_codecs[nb_ocodecs] = codec;
3187 } else {
3188 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3189 codec = avcodec_find_encoder(codec_id);
3190 }
3191 audio_enc->codec_id = codec_id;
3192
3193 if (audio_qscale > QSCALE_NONE) {
3194 audio_enc->flags |= CODEC_FLAG_QSCALE;
3195 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3196 }
3197 audio_enc->thread_count = thread_count;
3198 audio_enc->channels = audio_channels;
3199 audio_enc->sample_fmt = audio_sample_fmt;
3200 audio_enc->channel_layout = channel_layout;
3201
3202 if(codec && codec->sample_fmts){
3203 const enum SampleFormat *p= codec->sample_fmts;
3204 for(; *p!=-1; p++){
3205 if(*p == audio_enc->sample_fmt)
3206 break;
3207 }
3208 if(*p == -1)
3209 audio_enc->sample_fmt = codec->sample_fmts[0];
3210 }
3211 }
3212 nb_ocodecs++;
3213 audio_enc->sample_rate = audio_sample_rate;
3214 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3215 if (audio_language) {
3216 av_metadata_set(&st->metadata, "language", audio_language);
3217 av_free(audio_language);
3218 audio_language = NULL;
3219 }
3220
3221 /* reset some key parameters */
3222 audio_disable = 0;
3223 av_freep(&audio_codec_name);
3224 audio_stream_copy = 0;
3225 }
3226
3227 static void new_subtitle_stream(AVFormatContext *oc)
3228 {
3229 AVStream *st;
3230 AVCodecContext *subtitle_enc;
3231
3232 st = av_new_stream(oc, oc->nb_streams);
3233 if (!st) {
3234 fprintf(stderr, "Could not alloc stream\n");
3235 av_exit(1);
3236 }
3237 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3238
3239 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3240 subtitle_bitstream_filters= NULL;
3241
3242 subtitle_enc = st->codec;
3243 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3244
3245 if(subtitle_codec_tag)
3246 subtitle_enc->codec_tag= subtitle_codec_tag;
3247
3248 if (subtitle_stream_copy) {
3249 st->stream_copy = 1;
3250 } else {
3251 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3252 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3253 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3254 }
3255 nb_ocodecs++;
3256
3257 if (subtitle_language) {
3258 av_metadata_set(&st->metadata, "language", subtitle_language);
3259 av_free(subtitle_language);
3260 subtitle_language = NULL;
3261 }
3262
3263 subtitle_disable = 0;
3264 av_freep(&subtitle_codec_name);
3265 subtitle_stream_copy = 0;
3266 }
3267
3268 static void opt_new_audio_stream(void)
3269 {
3270 AVFormatContext *oc;
3271 if (nb_output_files <= 0) {
3272 fprintf(stderr, "At least one output file must be specified\n");
3273 av_exit(1);
3274 }
3275 oc = output_files[nb_output_files - 1];
3276 new_audio_stream(oc);
3277 }
3278
3279 static void opt_new_video_stream(void)
3280 {
3281 AVFormatContext *oc;
3282 if (nb_output_files <= 0) {
3283 fprintf(stderr, "At least one output file must be specified\n");
3284 av_exit(1);
3285 }
3286 oc = output_files[nb_output_files - 1];
3287 new_video_stream(oc);
3288 }
3289
3290 static void opt_new_subtitle_stream(void)
3291 {
3292 AVFormatContext *oc;
3293 if (nb_output_files <= 0) {
3294 fprintf(stderr, "At least one output file must be specified\n");
3295 av_exit(1);
3296 }
3297 oc = output_files[nb_output_files - 1];
3298 new_subtitle_stream(oc);
3299 }
3300
3301 static void opt_output_file(const char *filename)
3302 {
3303 AVFormatContext *oc;
3304 int use_video, use_audio, use_subtitle;
3305 int input_has_video, input_has_audio, input_has_subtitle;
3306 AVFormatParameters params, *ap = &params;
3307
3308 if (!strcmp(filename, "-"))
3309 filename = "pipe:";
3310
3311 oc = avformat_alloc_context();
3312
3313 if (!file_oformat) {
3314 file_oformat = guess_format(NULL, filename, NULL);
3315 if (!file_oformat) {
3316 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3317 filename);
3318 av_exit(1);
3319 }
3320 }
3321
3322 oc->oformat = file_oformat;
3323 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3324
3325 if (!strcmp(file_oformat->name, "ffm") &&
3326 av_strstart(filename, "http:", NULL)) {
3327 /* special case for files sent to ffserver: we get the stream
3328 parameters from ffserver */
3329 int err = read_ffserver_streams(oc, filename);
3330 if (err < 0) {
3331 print_error(filename, err);
3332 av_exit(1);
3333 }
3334 } else {
3335 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3336 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3337 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3338
3339 /* disable if no corresponding type found and at least one
3340 input file */
3341 if (nb_input_files > 0) {
3342 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3343 &input_has_subtitle);
3344 if (!input_has_video)
3345 use_video = 0;
3346 if (!input_has_audio)
3347 use_audio = 0;
3348 if (!input_has_subtitle)
3349 use_subtitle = 0;
3350 }
3351
3352 /* manual disable */
3353 if (audio_disable) {
3354 use_audio = 0;
3355 }
3356 if (video_disable) {
3357 use_video = 0;
3358 }
3359 if (subtitle_disable) {
3360 use_subtitle = 0;
3361 }
3362
3363 if (use_video) {
3364 new_video_stream(oc);
3365 }
3366
3367 if (use_audio) {
3368 new_audio_stream(oc);
3369 }
3370
3371 if (use_subtitle) {
3372 new_subtitle_stream(oc);
3373 }
3374
3375 oc->timestamp = rec_timestamp;
3376
3377 for(; metadata_count>0; metadata_count--){
3378 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3379 metadata[metadata_count-1].value);
3380 }
3381 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3382 }
3383
3384 output_files[nb_output_files++] = oc;
3385
3386 /* check filename in case of an image number is expected */
3387 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3388 if (!av_filename_number_test(oc->filename)) {
3389 print_error(oc->filename, AVERROR_NUMEXPECTED);
3390 av_exit(1);
3391 }
3392 }
3393
3394 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3395 /* test if it already exists to avoid loosing precious files */
3396 if (!file_overwrite &&
3397 (strchr(filename, ':') == NULL ||
3398 filename[1] == ':' ||
3399 av_strstart(filename, "file:", NULL))) {
3400 if (url_exist(filename)) {
3401 if (!using_stdin) {
3402 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3403 fflush(stderr);
3404 if (!read_yesno()) {
3405 fprintf(stderr, "Not overwriting - exiting\n");
3406 av_exit(1);
3407 }
3408 }
3409 else {
3410 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3411 av_exit(1);
3412 }
3413 }
3414 }
3415
3416 /* open the file */
3417 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3418 fprintf(stderr, "Could not open '%s'\n", filename);
3419 av_exit(1);
3420 }
3421 }
3422
3423 memset(ap, 0, sizeof(*ap));
3424 if (av_set_parameters(oc, ap) < 0) {
3425 fprintf(stderr, "%s: Invalid encoding parameters\n",
3426 oc->filename);
3427 av_exit(1);
3428 }
3429
3430 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3431 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3432 oc->loop_output = loop_output;
3433 oc->flags |= AVFMT_FLAG_NONBLOCK;
3434
3435 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3436
3437 /* reset some options */
3438 file_oformat = NULL;
3439 file_iformat = NULL;
3440 }
3441
3442 /* same option as mencoder */
3443 static void opt_pass(const char *pass_str)
3444 {
3445 int pass;
3446 pass = atoi(pass_str);
3447 if (pass != 1 && pass != 2) {
3448 fprintf(stderr, "pass number can be only 1 or 2\n");
3449 av_exit(1);
3450 }
3451 do_pass = pass;
3452 }
3453
3454 static int64_t getutime(void)
3455 {
3456 #if HAVE_GETRUSAGE
3457 struct rusage rusage;
3458
3459 getrusage(RUSAGE_SELF, &rusage);
3460 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3461 #elif HAVE_GETPROCESSTIMES
3462 HANDLE proc;
3463 FILETIME c, e, k, u;
3464 proc = GetCurrentProcess();
3465 GetProcessTimes(proc, &c, &e, &k, &u);
3466 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3467 #else
3468 return av_gettime();
3469 #endif
3470 }
3471
3472 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3473 {
3474 int i;
3475 const char *p = str;
3476 for(i = 0;; i++) {
3477 dest[i] = atoi(p);
3478 if(i == 63)
3479 break;
3480 p = strchr(p, ',');
3481 if(!p) {
3482 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3483 av_exit(1);
3484 }
3485 p++;
3486 }
3487 }
3488
3489 static void opt_inter_matrix(const char *arg)
3490 {
3491 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3492 parse_matrix_coeffs(inter_matrix, arg);
3493 }
3494
3495 static void opt_intra_matrix(const char *arg)
3496 {
3497 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3498 parse_matrix_coeffs(intra_matrix, arg);
3499 }
3500
3501 /**
3502 * Trivial log callback.
3503 * Only suitable for show_help and similar since it lacks prefix handling.
3504 */
3505 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3506 {
3507 vfprintf(stdout, fmt, vl);
3508 }
3509
3510 static void show_help(void)
3511 {
3512 av_log_set_callback(log_callback_help);
3513 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3514 "Hyper fast Audio and Video encoder\n");
3515 printf("\n");
3516 show_help_options(options, "Main options:\n",
3517 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3518 show_help_options(options, "\nAdvanced options:\n",
3519 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3520 OPT_EXPERT);
3521 show_help_options(options, "\nVideo options:\n",
3522 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3523 OPT_VIDEO);
3524 show_help_options(options, "\nAdvanced Video options:\n",
3525 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3526 OPT_VIDEO | OPT_EXPERT);
3527 show_help_options(options, "\nAudio options:\n",
3528 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3529 OPT_AUDIO);
3530 show_help_options(options, "\nAdvanced Audio options:\n",
3531 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3532 OPT_AUDIO | OPT_EXPERT);
3533 show_help_options(options, "\nSubtitle options:\n",
3534 OPT_SUBTITLE | OPT_GRAB,
3535 OPT_SUBTITLE);
3536 show_help_options(options, "\nAudio/Video grab options:\n",
3537 OPT_GRAB,
3538 OPT_GRAB);
3539 printf("\n");
3540 av_opt_show(avcodec_opts[0], NULL);
3541 printf("\n");
3542 av_opt_show(avformat_opts, NULL);
3543 printf("\n");
3544 av_opt_show(sws_opts, NULL);
3545 }
3546
3547 static void opt_target(const char *arg)
3548 {
3549 int norm = -1;
3550 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3551
3552 if(!strncmp(arg, "pal-", 4)) {
3553 norm = 0;
3554 arg += 4;
3555 } else if(!strncmp(arg, "ntsc-", 5)) {
3556 norm = 1;
3557 arg += 5;
3558 } else if(!strncmp(arg, "film-", 5)) {
3559 norm = 2;
3560 arg += 5;
3561 } else {
3562 int fr;
3563 /* Calculate FR via float to avoid int overflow */
3564 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3565 if(fr == 25000) {
3566 norm = 0;
3567 } else if((fr == 29970) || (fr == 23976)) {
3568 norm = 1;
3569 } else {
3570 /* Try to determine PAL/NTSC by peeking in the input files */
3571 if(nb_input_files) {
3572 int i, j;
3573 for(j = 0; j < nb_input_files; j++) {
3574 for(i = 0; i < input_files[j]->nb_streams; i++) {
3575 AVCodecContext *c = input_files[j]->streams[i]->codec;
3576 if(c->codec_type != CODEC_TYPE_VIDEO)
3577 continue;
3578 fr = c->time_base.den * 1000 / c->time_base.num;
3579 if(fr == 25000) {
3580 norm = 0;
3581 break;
3582 } else if((fr == 29970) || (fr == 23976)) {
3583 norm = 1;
3584 break;
3585 }
3586 }
3587 if(norm >= 0)
3588 break;
3589 }
3590 }
3591 }
3592 if(verbose && norm >= 0)
3593 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3594 }
3595
3596 if(norm < 0) {
3597 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3598 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3599 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3600 av_exit(1);
3601 }
3602
3603 if(!strcmp(arg, "vcd")) {
3604
3605 opt_video_codec("mpeg1video");
3606 opt_audio_codec("mp2");
3607 opt_format("vcd");
3608
3609 opt_frame_size(norm ? "352x240" : "352x288");
3610 opt_frame_rate(NULL, frame_rates[norm]);
3611 opt_default("gop", norm ? "18" : "15");
3612
3613 opt_default("b", "1150000");
3614 opt_default("maxrate", "1150000");
3615 opt_default("minrate", "1150000");
3616 opt_default("bufsize", "327680"); // 40*1024*8;
3617
3618 opt_default("ab", "224000");
3619 audio_sample_rate = 44100;
3620 audio_channels = 2;
3621
3622 opt_default("packetsize", "2324");
3623 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3624
3625 /* We have to offset the PTS, so that it is consistent with the SCR.
3626 SCR starts at 36000, but the first two packs contain only padding
3627 and the first pack from the other stream, respectively, may also have
3628 been written before.
3629 So the real data starts at SCR 36000+3*1200. */
3630 mux_preload= (36000+3*1200) / 90000.0; //0.44
3631 } else if(!strcmp(arg, "svcd")) {
3632
3633 opt_video_codec("mpeg2video");
3634 opt_audio_codec("mp2");
3635 opt_format("svcd");
3636
3637 opt_frame_size(norm ? "480x480" : "480x576");
3638 opt_frame_rate(NULL, frame_rates[norm]);
3639 opt_default("gop", norm ? "18" : "15");
3640
3641 opt_default("b", "2040000");
3642 opt_default("maxrate", "2516000");
3643 opt_default("minrate", "0"); //1145000;
3644 opt_default("bufsize", "1835008"); //224*1024*8;
3645 opt_default("flags", "+scan_offset");
3646
3647
3648 opt_default("ab", "224000");
3649 audio_sample_rate = 44100;
3650
3651 opt_default("packetsize", "2324");
3652
3653 } else if(!strcmp(arg, "dvd")) {
3654
3655 opt_video_codec("mpeg2video");
3656 opt_audio_codec("ac3");
3657 opt_format("dvd");
3658
3659 opt_frame_size(norm ? "720x480" : "720x576");
3660 opt_frame_rate(NULL, frame_rates[norm]);
3661 opt_default("gop", norm ? "18" : "15");
3662
3663 opt_default("b", "6000000");
3664 opt_default("maxrate", "9000000");
3665 opt_default("minrate", "0"); //1500000;
3666 opt_default("bufsize", "1835008"); //224*1024*8;
3667
3668 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3669 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3670
3671 opt_default("ab", "448000");
3672 audio_sample_rate = 48000;
3673
3674 } else if(!strncmp(arg, "dv", 2)) {
3675
3676 opt_format("dv");
3677
3678 opt_frame_size(norm ? "720x480" : "720x576");
3679 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3680 (norm ? "yuv411p" : "yuv420p"));
3681 opt_frame_rate(NULL, frame_rates[norm]);
3682
3683 audio_sample_rate = 48000;
3684 audio_channels = 2;
3685
3686 } else {
3687 fprintf(stderr, "Unknown target: %s\n", arg);
3688 av_exit(1);
3689 }
3690 }
3691
3692 static void opt_vstats_file (const char *arg)
3693 {
3694 av_free (vstats_filename);
3695 vstats_filename=av_strdup (arg);
3696 }
3697
3698 static void opt_vstats (void)
3699 {
3700 char filename[40];
3701 time_t today2 = time(NULL);
3702 struct tm *today = localtime(&today2);
3703
3704 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3705 today->tm_sec);
3706 opt_vstats_file(filename);
3707 }
3708
3709 static int opt_bsf(const char *opt, const char *arg)
3710 {
3711 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3712 AVBitStreamFilterContext **bsfp;
3713
3714 if(!bsfc){
3715 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3716 av_exit(1);
3717 }
3718
3719 bsfp= *opt == 'v' ? &video_bitstream_filters :
3720 *opt == 'a' ? &audio_bitstream_filters :
3721 &subtitle_bitstream_filters;
3722 while(*bsfp)
3723 bsfp= &(*bsfp)->next;
3724
3725 *bsfp= bsfc;
3726
3727 return 0;
3728 }
3729
3730 static int opt_preset(const char *opt, const char *arg)
3731 {
3732 FILE *f=NULL;
3733 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3734 int i;
3735 const char *base[2]= { getenv("HOME"),
3736 FFMPEG_DATADIR,
3737 };
3738
3739 for(i=!base[0]; i<2 && !f; i++){
3740 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3741 f= fopen(filename, "r");
3742 if(!f){
3743 char *codec_name= *opt == 'v' ? video_codec_name :
3744 *opt == 'a' ? audio_codec_name :
3745 subtitle_codec_name;
3746 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3747 f= fopen(filename, "r");
3748 }
3749 }
3750 if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3751 is_dos_path(arg))){
3752 av_strlcpy(filename, arg, sizeof(filename));
3753 f= fopen(filename, "r");
3754 }
3755
3756 if(!f){
3757 fprintf(stderr, "File for preset '%s' not found\n", arg);
3758 av_exit(1);
3759 }
3760
3761 while(!feof(f)){
3762 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3763 if(line[0] == '#' && !e)
3764 continue;
3765 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3766 if(e){
3767 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3768 av_exit(1);
3769 }
3770 if(!strcmp(tmp, "acodec")){
3771 opt_audio_codec(tmp2);
3772 }else if(!strcmp(tmp, "vcodec")){
3773 opt_video_codec(tmp2);
3774 }else if(!strcmp(tmp, "scodec")){
3775 opt_subtitle_codec(tmp2);
3776 }else if(opt_default(tmp, tmp2) < 0){
3777 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3778 av_exit(1);
3779 }
3780 }
3781
3782 fclose(f);
3783
3784 return 0;
3785 }
3786
3787 static const OptionDef options[] = {
3788 /* main options */
3789 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3790 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3791 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3792 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3793 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3794 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3795 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3796 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3797 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3798 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3799 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3800 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3801 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3802 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3803 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3804 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)&opt_metadata}, "add metadata", "string=string" },
3805 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3806 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3807 "add timings for benchmarking" },
3808 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3809 "dump each input packet" },
3810 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3811 "when dumping packets, also dump the payload" },
3812 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3813 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3814 { "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)", "" },
3815 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3816 { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "number" },
3817 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3818 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3819 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3820 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3821 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3822 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3823 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3824 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3825 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3826 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3827 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3828 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3829
3830 /* video options */
3831 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3832 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3833 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3834 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3835 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3836 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3837 { "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" },
3838 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3839 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3840 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3841 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3842 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3843 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3844 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3845 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3846 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3847 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3848 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3849 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3850 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3851 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3852 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3853 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3854 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3855 "use same video quality as source (implies VBR)" },
3856 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3857 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3858 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3859 "deinterlace pictures" },
3860 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3861 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3862 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3863 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3864 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3865 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3866 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3867 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3868 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3869 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3870 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3871
3872 /* audio options */
3873 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3874 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3875 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3876 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3877 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3878 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3879 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3880 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3881 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3882 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3883 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3884 { "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" },
3885
3886 /* subtitle options */
3887 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3888 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3889 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3890 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3891 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3892
3893 /* grab options */
3894 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3895 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3896 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3897
3898 /* muxer options */
3899 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3900 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3901
3902 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3903 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3904 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3905
3906 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3907 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3908 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3909
3910 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3911 { NULL, },
3912 };
3913
3914 int main(int argc, char **argv)
3915 {
3916 int i;
3917 int64_t ti;
3918
3919 avcodec_register_all();
3920 avdevice_register_all();
3921 av_register_all();
3922
3923 if(isatty(STDIN_FILENO))
3924 url_set_interrupt_cb(decode_interrupt_cb);
3925
3926 for(i=0; i<CODEC_TYPE_NB; i++){
3927 avcodec_opts[i]= avcodec_alloc_context2(i);
3928 }
3929 avformat_opts = avformat_alloc_context();
3930 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3931
3932 show_banner();
3933
3934 /* parse options */
3935 parse_options(argc, argv, options, opt_output_file);
3936
3937 /* file converter / grab */
3938 if (nb_output_files <= 0) {
3939 fprintf(stderr, "At least one output file must be specified\n");
3940 av_exit(1);
3941 }
3942
3943 if (nb_input_files == 0) {
3944 fprintf(stderr, "At least one input file must be specified\n");
3945 av_exit(1);
3946 }
3947
3948 ti = getutime();
3949 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3950 stream_maps, nb_stream_maps) < 0)
3951 av_exit(1);
3952 ti = getutime() - ti;
3953 if (do_benchmark) {
3954 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3955 }
3956
3957 return av_exit(0);
3958 }
ffmpeg Lagarith lossless decoder