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