#include "libswscale/swscale.h"
#include "libavcodec/opt.h"
#include "libavcodec/audioconvert.h"
-#include "libavcodec/colorspace.h"
+#include "libavcore/parseutils.h"
+#include "libavutil/colorspace.h"
#include "libavutil/fifo.h"
#include "libavutil/pixdesc.h"
#include "libavutil/avstring.h"
#include "cmdutils.h"
-#undef NDEBUG
-#include <assert.h>
+#include "libavutil/avassert.h"
const char program_name[] = "FFmpeg";
const int program_birth_year = 2000;
int sync_stream_index;
} AVStreamMap;
-/** select an input file for an output file */
+/**
+ * select an input file for an output file
+ */
typedef struct AVMetaDataMap {
int out_file;
int in_file;
static const OptionDef options[];
#define MAX_FILES 100
+#if !FF_API_MAX_STREAMS
+#define MAX_STREAMS 1024 /* arbitrary sanity check value */
+#endif
static const char *last_asked_format = NULL;
static AVFormatContext *input_files[MAX_FILES];
static int64_t input_files_ts_offset[MAX_FILES];
-static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
-static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
+static double *input_files_ts_scale[MAX_FILES] = {NULL};
+static AVCodec **input_codecs = NULL;
static int nb_input_files = 0;
-static int nb_icodecs;
+static int nb_input_codecs = 0;
+static int nb_input_files_ts_scale[MAX_FILES] = {0};
static AVFormatContext *output_files[MAX_FILES];
-static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
+static AVCodec **output_codecs = NULL;
static int nb_output_files = 0;
-static int nb_ocodecs;
+static int nb_output_codecs = 0;
-static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
+static AVStreamMap *stream_maps = NULL;
static int nb_stream_maps;
static AVMetaDataMap meta_data_maps[MAX_FILES];
static int nb_meta_data_maps;
+/* indexed by output file stream index */
+static int *streamid_map = NULL;
+static int nb_streamid_map = 0;
+
static int frame_width = 0;
static int frame_height = 0;
static float frame_aspect_ratio = 0;
static int64_t recording_time = INT64_MAX;
static int64_t start_time = 0;
-static int64_t rec_timestamp = 0;
+static int64_t recording_timestamp = 0;
static int64_t input_ts_offset = 0;
static int file_overwrite = 0;
static int metadata_count;
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
-static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
+static AVBitStreamFilterContext **bitstream_filters[MAX_FILES] = {NULL};
+static int nb_bitstream_filters[MAX_FILES] = {0};
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
int showed_multi_packet_warning;
int is_past_recording_time;
#if CONFIG_AVFILTER
- AVFilterContext *out_video_filter;
+ AVFilterContext *output_video_filter;
AVFilterContext *input_video_filter;
AVFrame *filter_frame;
int has_filter_frame;
- AVFilterPicRef *picref;
+ AVFilterBufferRef *picref;
#endif
} AVInputStream;
}
static int get_filtered_video_pic(AVFilterContext *ctx,
- AVFilterPicRef **picref, AVFrame *pic2,
+ AVFilterBufferRef **picref, AVFrame *pic2,
uint64_t *pts)
{
- AVFilterPicRef *pic;
+ AVFilterBufferRef *pic;
if(avfilter_request_frame(ctx->inputs[0]))
return -1;
- if(!(pic = ctx->inputs[0]->cur_pic))
+ if(!(pic = ctx->inputs[0]->cur_buf))
return -1;
*picref = pic;
- ctx->inputs[0]->cur_pic = NULL;
+ ctx->inputs[0]->cur_buf = NULL;
*pts = pic->pts;
memcpy(pic2->data, pic->data, sizeof(pic->data));
memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
- pic2->interlaced_frame = pic->interlaced;
- pic2->top_field_first = pic->top_field_first;
+ pic2->interlaced_frame = pic->video->interlaced;
+ pic2->top_field_first = pic->video->top_field_first;
return 1;
}
AVCodecContext *codec = ost->st->codec;
AVCodecContext *icodec = ist->st->codec;
char args[255];
+ int ret;
graph = av_mallocz(sizeof(AVFilterGraph));
- if (!(ist->input_video_filter = avfilter_open(avfilter_get_by_name("buffer"), "src")))
- return -1;
- if (!(ist->out_video_filter = avfilter_open(&output_filter, "out")))
- return -1;
+ if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
+ return ret;
+ if ((ret = avfilter_open(&ist->output_video_filter, &output_filter, "out")) < 0)
+ return ret;
snprintf(args, 255, "%d:%d:%d", ist->st->codec->width,
ist->st->codec->height, ist->st->codec->pix_fmt);
- if (avfilter_init_filter(ist->input_video_filter, args, NULL))
- return -1;
- if (avfilter_init_filter(ist->out_video_filter, NULL, &codec->pix_fmt))
- return -1;
+ if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &codec->pix_fmt)) < 0)
+ return ret;
/* add input and output filters to the overall graph */
avfilter_graph_add_filter(graph, ist->input_video_filter);
- avfilter_graph_add_filter(graph, ist->out_video_filter);
+ avfilter_graph_add_filter(graph, ist->output_video_filter);
last_filter = ist->input_video_filter;
if (ost->video_crop) {
- snprintf(args, 255, "%d:%d:%d:%d", ost->leftBand, ost->topBand,
- codec->width,
- codec->height);
- filter = avfilter_open(avfilter_get_by_name("crop"), NULL);
- if (!filter)
- return -1;
- if (avfilter_init_filter(filter, args, NULL))
- return -1;
- if (avfilter_link(last_filter, 0, filter, 0))
- return -1;
+ snprintf(args, 255, "%d:%d:%d:%d",
+ codec->width, codec->height,
+ ost->leftBand, ost->topBand);
+ if ((ret = avfilter_open(&filter, avfilter_get_by_name("crop"), NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
+ return ret;
last_filter = filter;
avfilter_graph_add_filter(graph, last_filter);
}
codec->width,
codec->height,
(int)av_get_int(sws_opts, "sws_flags", NULL));
- filter = avfilter_open(avfilter_get_by_name("scale"), NULL);
- if (!filter)
- return -1;
- if (avfilter_init_filter(filter, args, NULL))
- return -1;
- if (avfilter_link(last_filter, 0, filter, 0))
- return -1;
+ if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
+ return ret;
last_filter = filter;
avfilter_graph_add_filter(graph, last_filter);
}
+ snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
+ graph->scale_sws_opts = av_strdup(args);
+
if (vfilters) {
AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
outputs->next = NULL;
inputs->name = av_strdup("out");
- inputs->filter = ist->out_video_filter;
+ inputs->filter = ist->output_video_filter;
inputs->pad_idx = 0;
inputs->next = NULL;
- if (avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL) < 0)
- return -1;
+ if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
+ return ret;
av_freep(&vfilters);
} else {
- if (avfilter_link(last_filter, 0, ist->out_video_filter, 0) < 0)
- return -1;
+ if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
+ return ret;
}
- snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
- graph->scale_sws_opts = av_strdup(args);
-
/* configure all the filter links */
- if (avfilter_graph_check_validity(graph, NULL))
- return -1;
- if (avfilter_graph_config_formats(graph, NULL))
- return -1;
- if (avfilter_graph_config_links(graph, NULL))
- return -1;
+ if ((ret = avfilter_graph_check_validity(graph, NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_graph_config_formats(graph, NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_graph_config_links(graph, NULL)) < 0)
+ return ret;
- codec->width = ist->out_video_filter->inputs[0]->w;
- codec->height = ist->out_video_filter->inputs[0]->h;
+ codec->width = ist->output_video_filter->inputs[0]->w;
+ codec->height = ist->output_video_filter->inputs[0]->h;
return 0;
}
static void term_exit(void)
{
+ av_log(NULL, AV_LOG_QUIET, "");
#if HAVE_TERMIOS_H
tcsetattr (0, TCSANOW, &oldtty);
#endif
return q_pressed || (q_pressed = read_key() == 'q');
}
-static int av_exit(int ret)
+static int ffmpeg_exit(int ret)
{
int i;
}
av_metadata_free(&s->metadata);
av_free(s);
+ av_free(bitstream_filters[i]);
}
- for(i=0;i<nb_input_files;i++)
+ for(i=0;i<nb_input_files;i++) {
av_close_input_file(input_files[i]);
+ av_free(input_files_ts_scale[i]);
+ }
av_free(intra_matrix);
av_free(inter_matrix);
av_free(vstats_filename);
av_free(opt_names);
+ av_free(streamid_map);
+ av_free(input_codecs);
+ av_free(output_codecs);
+ av_free(stream_maps);
av_free(video_codec_name);
av_free(audio_codec_name);
av_free(video_standard);
-#if CONFIG_POWERPC_PERF
- void powerpc_display_perf_report(void);
- powerpc_display_perf_report();
-#endif /* CONFIG_POWERPC_PERF */
-
- for (i=0;i<AVMEDIA_TYPE_NB;i++)
- av_free(avcodec_opts[i]);
- av_free(avformat_opts);
- av_free(sws_opts);
+ uninit_opts();
av_free(audio_buf);
av_free(audio_out);
allocated_audio_buf_size= allocated_audio_out_size= 0;
return ret;
}
+/* similar to ff_dynarray_add() and av_fast_realloc() */
+static void *grow_array(void *array, int elem_size, int *size, int new_size)
+{
+ if (new_size >= INT_MAX / elem_size) {
+ fprintf(stderr, "Array too big.\n");
+ ffmpeg_exit(1);
+ }
+ if (*size < new_size) {
+ uint8_t *tmp = av_realloc(array, new_size*elem_size);
+ if (!tmp) {
+ fprintf(stderr, "Could not alloc buffer.\n");
+ ffmpeg_exit(1);
+ }
+ memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
+ *size = new_size;
+ return tmp;
+ }
+ return array;
+}
+
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
{
if(codec && codec->sample_fmts){
{
if(codec && codec->supported_samplerates){
const int *p= codec->supported_samplerates;
- int best;
+ int best=0;
int best_dist=INT_MAX;
for(; *p; p++){
int dist= abs(st->codec->sample_rate - *p);
}
if(*p == -1
&& !( st->codec->codec_id==CODEC_ID_MJPEG
- && st->codec->strict_std_compliance <= FF_COMPLIANCE_INOFFICIAL
+ && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
&& ( st->codec->pix_fmt == PIX_FMT_YUV420P
|| st->codec->pix_fmt == PIX_FMT_YUV422P)))
st->codec->pix_fmt = codec->pix_fmts[0];
st->codec = avcodec_alloc_context();
if (!st->codec) {
print_error(filename, AVERROR(ENOMEM));
- av_exit(1);
+ ffmpeg_exit(1);
}
avcodec_copy_context(st->codec, ic->streams[i]->codec);
s->streams[i] = st;
avctx->codec ? avctx->codec->name : "copy");
print_error("", a);
if (exit_on_error)
- av_exit(1);
+ ffmpeg_exit(1);
}
*pkt= new_pkt;
ret= av_interleaved_write_frame(s, pkt);
if(ret < 0){
print_error("av_interleaved_write_frame()", ret);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
fprintf(stderr, "Buffer sizes too large\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
if (!audio_buf || !audio_out){
fprintf(stderr, "Out of memory in do_audio_out\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if (enc->channels != dec->channels)
fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
dec->channels, dec->sample_rate,
enc->channels, enc->sample_rate);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
avcodec_get_sample_fmt_name(dec->sample_fmt),
avcodec_get_sample_fmt_name(enc->sample_fmt));
- av_exit(1);
+ ffmpeg_exit(1);
}
ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
}
if(audio_sync_method){
double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
- - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
- double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
- int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
+ - av_fifo_size(ost->fifo)/(enc->channels * 2);
+ double idelta= delta*dec->sample_rate / enc->sample_rate;
+ int byte_delta= ((int)idelta)*2*dec->channels;
//FIXME resample delay
if(fabs(delta) > 50){
}
}else if(audio_sync_method>1){
int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
- assert(ost->audio_resample);
+ av_assert0(ost->audio_resample);
if(verbose > 2)
fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
// 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));
}
}else
ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
- - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
+ - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
if (ost->audio_resample) {
buftmp = audio_buf;
size_out = audio_resample(ost->resample,
(short *)buftmp, (short *)buf,
- size / (ist->st->codec->channels * isize));
+ size / (dec->channels * isize));
size_out = size_out * enc->channels * osize;
} else {
buftmp = buf;
if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
printf("av_audio_convert() failed\n");
if (exit_on_error)
- av_exit(1);
+ ffmpeg_exit(1);
return;
}
buftmp = audio_buf;
/* output resampled raw samples */
if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
fprintf(stderr, "av_fifo_realloc2() failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
(short *)audio_buf);
if (ret < 0) {
fprintf(stderr, "Audio encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
audio_size += ret;
pkt.stream_index= ost->index;
if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
pkt.flags |= AV_PKT_FLAG_KEY;
- write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
+ write_frame(s, &pkt, enc, bitstream_filters[ost->file_index][pkt.stream_index]);
ost->sync_opts += enc->frame_size;
}
if(size_out > audio_out_size){
fprintf(stderr, "Internal error, buffer size too small\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
//FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
(short *)buftmp);
if (ret < 0) {
fprintf(stderr, "Audio encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
audio_size += ret;
pkt.stream_index= ost->index;
if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
pkt.flags |= AV_PKT_FLAG_KEY;
- write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
+ write_frame(s, &pkt, enc, bitstream_filters[ost->file_index][pkt.stream_index]);
}
}
if (pts == AV_NOPTS_VALUE) {
fprintf(stderr, "Subtitle packets must have a pts\n");
if (exit_on_error)
- av_exit(1);
+ ffmpeg_exit(1);
return;
}
subtitle_out_max_size, sub);
if (subtitle_out_size < 0) {
fprintf(stderr, "Subtitle encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
av_init_packet(&pkt);
if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
fprintf(stderr, "error cropping picture\n");
if (exit_on_error)
- av_exit(1);
+ ffmpeg_exit(1);
return;
}
formatted_picture = &picture_crop_temp;
fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
if(!ost->video_resample)
- av_exit(1);
+ ffmpeg_exit(1);
}
#if !CONFIG_AVFILTER
rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
/* sanity check to ensure no bad band sizes sneak in */
- assert(topBand <= INT_MAX && topBand >= 0);
- assert(bottomBand <= INT_MAX && bottomBand >= 0);
- assert(leftBand <= INT_MAX && leftBand >= 0);
- assert(rightBand <= INT_MAX && rightBand >= 0);
+ av_assert0(topBand <= INT_MAX && topBand >= 0);
+ av_assert0(bottomBand <= INT_MAX && bottomBand >= 0);
+ av_assert0(leftBand <= INT_MAX && leftBand >= 0);
+ av_assert0(rightBand <= INT_MAX && rightBand >= 0);
ost->topBand = topBand;
ost->bottomBand = bottomBand;
sws_flags, NULL, NULL, NULL);
if (ost->img_resample_ctx == NULL) {
fprintf(stderr, "Cannot get resampling context\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
}
sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
/* handles sameq here. This is not correct because it may
not be a global option */
- if (same_quality) {
- big_picture.quality = ist->st->quality;
- }else
- big_picture.quality = ost->st->quality;
+ big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
if(!me_threshold)
big_picture.pict_type = 0;
// big_picture.pts = AV_NOPTS_VALUE;
&big_picture);
if (ret < 0) {
fprintf(stderr, "Video encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if(ret>0){
vstats_file = fopen(vstats_filename, "w");
if (!vstats_file) {
perror("fopen");
- av_exit(1);
+ ffmpeg_exit(1);
}
}
void *buffer_to_free;
static unsigned int samples_size= 0;
AVSubtitle subtitle, *subtitle_to_free;
- int got_subtitle;
#if CONFIG_AVFILTER
int frame_available;
#endif
break;
case AVMEDIA_TYPE_SUBTITLE:
ret = avcodec_decode_subtitle2(ist->st->codec,
- &subtitle, &got_subtitle, &avpkt);
+ &subtitle, &got_picture, &avpkt);
if (ret < 0)
goto fail_decode;
- if (!got_subtitle) {
+ if (!got_picture) {
goto discard_packet;
}
subtitle_to_free = &subtitle;
}
#if CONFIG_AVFILTER
frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
- !ist->out_video_filter || avfilter_poll_frame(ist->out_video_filter->inputs[0]);
+ !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
#endif
/* if output time reached then transcode raw format,
encode packets and output them */
if (start_time == 0 || ist->pts >= start_time)
#if CONFIG_AVFILTER
while (frame_available) {
- if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->out_video_filter)
- get_filtered_video_pic(ist->out_video_filter, &ist->picref, &picture, &ist->pts);
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
+ get_filtered_video_pic(ist->output_video_filter, &ist->picref, &picture, &ist->pts);
#endif
for(i=0;i<nb_ostreams;i++) {
int frame_size;
//ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
if (ost->encoding_needed) {
- assert(ist->decoding_needed);
+ av_assert0(ist->decoding_needed);
switch(ost->st->codec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
break;
case AVMEDIA_TYPE_VIDEO:
#if CONFIG_AVFILTER
- ost->st->codec->sample_aspect_ratio = ist->picref->pixel_aspect;
+ if (ist->picref->video)
+ ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
#endif
do_video_out(os, ost, ist, &picture, &frame_size);
if (vstats_filename && frame_size)
av_free_packet(&opkt);
}
}
-#if CONFIG_AVFILTER
- frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
- ist->out_video_filter && avfilter_poll_frame(ist->out_video_filter->inputs[0]);
-#endif
}
#if CONFIG_AVFILTER
+ frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
+ ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
if(ist->picref)
- avfilter_unref_pic(ist->picref);
+ avfilter_unref_buffer(ist->picref);
}
#endif
av_free(buffer_to_free);
} else { /* pad */
int frame_bytes = enc->frame_size*osize*enc->channels;
if (allocated_audio_buf_size < frame_bytes)
- av_exit(1);
- memset((uint8_t*)audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
+ ffmpeg_exit(1);
+ memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
}
ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
}
if (ret < 0) {
fprintf(stderr, "Audio encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
audio_size += ret;
pkt.flags |= AV_PKT_FLAG_KEY;
ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
if (ret < 0) {
fprintf(stderr, "Video encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
video_size += ret;
if(enc->coded_frame && enc->coded_frame->key_frame)
/*
* The following code is the main loop of the file converter
*/
-static int av_transcode(AVFormatContext **output_files,
- int nb_output_files,
- AVFormatContext **input_files,
- int nb_input_files,
- AVStreamMap *stream_maps, int nb_stream_maps)
+static int transcode(AVFormatContext **output_files,
+ int nb_output_files,
+ AVFormatContext **input_files,
+ int nb_input_files,
+ AVStreamMap *stream_maps, int nb_stream_maps)
{
int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
AVFormatContext *is, *os;
if (!os->nb_streams) {
dump_format(output_files[i], i, output_files[i]->filename, 1);
fprintf(stderr, "Output file #%d does not contain any stream\n", i);
- av_exit(1);
+ ret = AVERROR(EINVAL);
+ goto fail;
}
nb_ostreams += os->nb_streams;
}
if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
fprintf(stderr, "Number of stream maps must match number of output streams\n");
- av_exit(1);
+ ret = AVERROR(EINVAL);
+ goto fail;
}
/* Sanity check the mapping args -- do the input files & streams exist? */
if (fi < 0 || fi > nb_input_files - 1 ||
si < 0 || si > file_table[fi].nb_streams - 1) {
fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
- av_exit(1);
+ ret = AVERROR(EINVAL);
+ goto fail;
}
fi = stream_maps[i].sync_file_index;
si = stream_maps[i].sync_stream_index;
if (fi < 0 || fi > nb_input_files - 1 ||
si < 0 || si > file_table[fi].nb_streams - 1) {
fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
- av_exit(1);
+ ret = AVERROR(EINVAL);
+ goto fail;
}
}
fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
stream_maps[n].file_index, stream_maps[n].stream_index,
ost->file_index, ost->index);
- av_exit(1);
+ ffmpeg_exit(1);
}
} else {
int best_nb_frames=-1;
- /* get corresponding input stream index : we select the first one with the right type */
- found = 0;
- for(j=0;j<nb_istreams;j++) {
- int skip=0;
- ist = ist_table[j];
- if(opt_programid){
- int pi,si;
- AVFormatContext *f= input_files[ ist->file_index ];
- skip=1;
- for(pi=0; pi<f->nb_programs; pi++){
- AVProgram *p= f->programs[pi];
- if(p->id == opt_programid)
- for(si=0; si<p->nb_stream_indexes; si++){
- if(f->streams[ p->stream_index[si] ] == ist->st)
- skip=0;
- }
- }
+ /* get corresponding input stream index : we select the first one with the right type */
+ found = 0;
+ for(j=0;j<nb_istreams;j++) {
+ int skip=0;
+ ist = ist_table[j];
+ if(opt_programid){
+ int pi,si;
+ AVFormatContext *f= input_files[ ist->file_index ];
+ skip=1;
+ for(pi=0; pi<f->nb_programs; pi++){
+ AVProgram *p= f->programs[pi];
+ if(p->id == opt_programid)
+ for(si=0; si<p->nb_stream_indexes; si++){
+ if(f->streams[ p->stream_index[si] ] == ist->st)
+ skip=0;
+ }
}
- if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
- ist->st->codec->codec_type == ost->st->codec->codec_type) {
- if(best_nb_frames < ist->st->codec_info_nb_frames){
- best_nb_frames= ist->st->codec_info_nb_frames;
- ost->source_index = j;
- found = 1;
- }
+ }
+ if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
+ ist->st->codec->codec_type == ost->st->codec->codec_type) {
+ if(best_nb_frames < ist->st->codec_info_nb_frames){
+ best_nb_frames= ist->st->codec_info_nb_frames;
+ ost->source_index = j;
+ found = 1;
}
}
+ }
if (!found) {
if(! opt_programid) {
dump_format(output_files[i], i, output_files[i]->filename, 1);
fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
ost->file_index, ost->index);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
}
if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
codec->time_base = icodec->time_base;
codec->time_base.num *= icodec->ticks_per_frame;
+ av_reduce(&codec->time_base.num, &codec->time_base.den,
+ codec->time_base.num, codec->time_base.den, INT_MAX);
}else
codec->time_base = ist->st->time_base;
switch(codec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
if(audio_volume != 256) {
fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
codec->channel_layout = icodec->channel_layout;
codec->sample_rate = icodec->sample_rate;
case AVMEDIA_TYPE_VIDEO:
if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
ost->video_resample = ((codec->width != icodec->width -
if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
codec->width, codec->height)) {
fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
ost->img_resample_ctx = sws_getContext(
sws_flags, NULL, NULL, NULL);
if (ost->img_resample_ctx == NULL) {
fprintf(stderr, "Cannot get resampling context\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
#if !CONFIG_AVFILTER
f = fopen(logfilename, "wb");
if (!f) {
fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
- av_exit(1);
+ ffmpeg_exit(1);
}
ost->logfile = f;
} else {
size_t logbuffer_size;
if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
- av_exit(1);
+ ffmpeg_exit(1);
}
codec->stats_in = logbuffer;
}
for(i=0;i<nb_ostreams;i++) {
ost = ost_table[i];
if (ost->encoding_needed) {
- AVCodec *codec = output_codecs[i];
+ AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
if (!codec)
codec = avcodec_find_encoder(ost->st->codec->codec_id);
if (!codec) {
for(i=0;i<nb_istreams;i++) {
ist = ist_table[i];
if (ist->decoding_needed) {
- AVCodec *codec = input_codecs[i];
+ AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
if (!codec)
codec = avcodec_find_decoder(ist->st->codec->codec_id);
if (!codec) {
}
/* finish if limit size exhausted */
- if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
+ if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
break;
/* read a frame from it and output it in the fifo */
if (pkt.pts != AV_NOPTS_VALUE)
pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
- if(input_files_ts_scale[file_index][pkt.stream_index]){
+ if (pkt.stream_index < nb_input_files_ts_scale[file_index]
+ && input_files_ts_scale[file_index][pkt.stream_index]){
if(pkt.pts != AV_NOPTS_VALUE)
pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
if(pkt.dts != AV_NOPTS_VALUE)
fprintf(stderr, "Error while decoding stream #%d.%d\n",
ist->file_index, ist->index);
if (exit_on_error)
- av_exit(1);
+ ffmpeg_exit(1);
av_free_packet(&pkt);
goto redo;
}
static int opt_frame_rate(const char *opt, const char *arg)
{
- if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
+ if (av_parse_video_rate(&frame_rate, arg) < 0) {
fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
- av_exit(1);
+ ffmpeg_exit(1);
}
return 0;
}
frame_topBand = atoi(arg);
if (frame_topBand < 0) {
fprintf(stderr, "Incorrect top crop size\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if ((frame_topBand) >= frame_height){
fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
+ fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
frame_height -= frame_topBand;
}
frame_bottomBand = atoi(arg);
if (frame_bottomBand < 0) {
fprintf(stderr, "Incorrect bottom crop size\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if ((frame_bottomBand) >= frame_height){
fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
+ fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
frame_height -= frame_bottomBand;
}
frame_leftBand = atoi(arg);
if (frame_leftBand < 0) {
fprintf(stderr, "Incorrect left crop size\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if ((frame_leftBand) >= frame_width){
fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
+ fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
frame_width -= frame_leftBand;
}
frame_rightBand = atoi(arg);
if (frame_rightBand < 0) {
fprintf(stderr, "Incorrect right crop size\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if ((frame_rightBand) >= frame_width){
fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
+ fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
frame_width -= frame_rightBand;
}
static void opt_frame_size(const char *arg)
{
- if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
+ if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
fprintf(stderr, "Incorrect frame size\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
}
-static void opt_pad(const char *arg) {
- fprintf(stderr, "Please use vf=pad\n");
- av_exit(1);
+static int opt_pad(const char *opt, const char *arg) {
+ fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
+ return -1;
}
static void opt_frame_pix_fmt(const char *arg)
frame_pix_fmt = av_get_pix_fmt(arg);
if (frame_pix_fmt == PIX_FMT_NONE) {
fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
- av_exit(1);
+ ffmpeg_exit(1);
}
} else {
show_pix_fmts();
- av_exit(0);
+ ffmpeg_exit(0);
}
}
if (!ar) {
fprintf(stderr, "Incorrect aspect ratio specification.\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
frame_aspect_ratio = ar;
}
if(!mid){
fprintf(stderr, "Missing =\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
*mid++= 0;
if (video_qscale <= 0 ||
video_qscale > 255) {
fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
}
audio_sample_fmt = avcodec_get_sample_fmt(arg);
else {
list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
- av_exit(0);
+ ffmpeg_exit(0);
}
}
AVStreamMap *m;
char *p;
- m = &stream_maps[nb_stream_maps++];
+ stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
+ m = &stream_maps[nb_stream_maps-1];
m->file_index = strtol(arg, &p, 0);
if (*p)
scale= strtod(p, &p);
if(stream >= MAX_STREAMS)
- av_exit(1);
+ ffmpeg_exit(1);
+ input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
input_files_ts_scale[nb_input_files][stream]= scale;
}
return 0;
}
-static int opt_rec_timestamp(const char *opt, const char *arg)
+static int opt_recording_timestamp(const char *opt, const char *arg)
{
- rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
+ recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
return 0;
}
avcodec_find_decoder_by_name(name);
if(!codec) {
fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
- av_exit(1);
+ ffmpeg_exit(1);
}
if(codec->type != type) {
fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
- av_exit(1);
+ ffmpeg_exit(1);
}
if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
strict > FF_COMPLIANCE_EXPERIMENTAL) {
if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
fprintf(stderr, "Or use the non experimental %s '%s'.\n",
codec_string, codec->name);
- av_exit(1);
+ ffmpeg_exit(1);
}
return codec->id;
}
if (last_asked_format) {
if (!(file_iformat = av_find_input_format(last_asked_format))) {
fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
- av_exit(1);
+ ffmpeg_exit(1);
}
last_asked_format = NULL;
}
ic = avformat_alloc_context();
if (!ic) {
print_error(filename, AVERROR(ENOMEM));
- av_exit(1);
+ ffmpeg_exit(1);
}
memset(ap, 0, sizeof(*ap));
ap->channel = video_channel;
ap->standard = video_standard;
- set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
+ set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
ic->video_codec_id =
find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
if (err < 0) {
print_error(filename, err);
- av_exit(1);
+ ffmpeg_exit(1);
}
if(opt_programid) {
int i, j;
}
if(!found){
fprintf(stderr, "Specified program id not found\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
opt_programid=0;
}
ret = av_find_stream_info(ic);
if (ret < 0 && verbose >= 0) {
fprintf(stderr, "%s: could not find codec parameters\n", filename);
- av_exit(1);
+ av_close_input_file(ic);
+ ffmpeg_exit(1);
}
timestamp = start_time;
/* update the current parameters so that they match the one of the input stream */
for(i=0;i<ic->nb_streams;i++) {
AVStream *st = ic->streams[i];
- AVCodecContext *enc = st->codec;
- avcodec_thread_init(enc, thread_count);
- switch(enc->codec_type) {
+ AVCodecContext *dec = st->codec;
+ avcodec_thread_init(dec, thread_count);
+ input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
+ switch (dec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
- set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
- //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
- channel_layout = enc->channel_layout;
- audio_channels = enc->channels;
- audio_sample_rate = enc->sample_rate;
- audio_sample_fmt = enc->sample_fmt;
- input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
+ input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
+ set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
+ //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
+ channel_layout = dec->channel_layout;
+ audio_channels = dec->channels;
+ audio_sample_rate = dec->sample_rate;
+ audio_sample_fmt = dec->sample_fmt;
if(audio_disable)
st->discard= AVDISCARD_ALL;
+ /* Note that av_find_stream_info can add more streams, and we
+ * currently have no chance of setting up lowres decoding
+ * early enough for them. */
+ if (dec->lowres)
+ audio_sample_rate >>= dec->lowres;
break;
case AVMEDIA_TYPE_VIDEO:
- set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
- frame_height = enc->height;
- frame_width = enc->width;
+ input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
+ set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
+ frame_height = dec->height;
+ frame_width = dec->width;
if(ic->streams[i]->sample_aspect_ratio.num)
frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
else
- frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
- frame_aspect_ratio *= (float) enc->width / enc->height;
- frame_pix_fmt = enc->pix_fmt;
+ frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
+ frame_aspect_ratio *= (float) dec->width / dec->height;
+ frame_pix_fmt = dec->pix_fmt;
rfps = ic->streams[i]->r_frame_rate.num;
rfps_base = ic->streams[i]->r_frame_rate.den;
- if(enc->lowres) {
- enc->flags |= CODEC_FLAG_EMU_EDGE;
- frame_height >>= enc->lowres;
- frame_width >>= enc->lowres;
+ if (dec->lowres) {
+ dec->flags |= CODEC_FLAG_EMU_EDGE;
+ frame_height >>= dec->lowres;
+ frame_width >>= dec->lowres;
}
if(me_threshold)
- enc->debug |= FF_DEBUG_MV;
+ dec->debug |= FF_DEBUG_MV;
- if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) {
+ if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
if (verbose >= 0)
fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
- i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
+ i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
(float)rfps / rfps_base, rfps, rfps_base);
}
frame_rate.num = rfps;
frame_rate.den = rfps_base;
- input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
if(video_disable)
st->discard= AVDISCARD_ALL;
else if(video_discard)
case AVMEDIA_TYPE_DATA:
break;
case AVMEDIA_TYPE_SUBTITLE:
- input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
+ input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
if(subtitle_disable)
st->discard = AVDISCARD_ALL;
break;
case AVMEDIA_TYPE_ATTACHMENT:
case AVMEDIA_TYPE_UNKNOWN:
- nb_icodecs++;
break;
default:
abort();
AVStream *st;
AVCodecContext *video_enc;
enum CodecID codec_id;
+ AVCodec *codec= NULL;
- st = av_new_stream(oc, oc->nb_streams);
+ st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
- av_exit(1);
+ ffmpeg_exit(1);
+ }
+
+ output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
+ if(!video_stream_copy){
+ if (video_codec_name) {
+ codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
+ avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
+ codec = avcodec_find_encoder_by_name(video_codec_name);
+ output_codecs[nb_output_codecs-1] = codec;
+ } else {
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
+ codec = avcodec_find_encoder(codec_id);
+ }
}
- avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
+
+ avcodec_get_context_defaults3(st->codec, codec);
+ bitstream_filters[nb_output_files] = grow_array(bitstream_filters[nb_output_files], sizeof(*bitstream_filters[nb_output_files]), &nb_bitstream_filters[nb_output_files], oc->nb_streams);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
video_bitstream_filters= NULL;
} else {
const char *p;
int i;
- AVCodec *codec;
AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
- if (video_codec_name) {
- codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
- video_enc->strict_std_compliance);
- codec = avcodec_find_encoder_by_name(video_codec_name);
- output_codecs[nb_ocodecs] = codec;
- } else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
- codec = avcodec_find_encoder(codec_id);
- }
-
video_enc->codec_id = codec_id;
-
- set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
+ set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
if (codec && codec->supported_framerates && !force_fps)
fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
if(e!=3){
fprintf(stderr, "error parsing rc_override\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
video_enc->rc_override=
av_realloc(video_enc->rc_override,
}
}
}
- nb_ocodecs++;
if (video_language) {
av_metadata_set2(&st->metadata, "language", video_language, 0);
av_freep(&video_language);
static void new_audio_stream(AVFormatContext *oc)
{
AVStream *st;
+ AVCodec *codec= NULL;
AVCodecContext *audio_enc;
enum CodecID codec_id;
- st = av_new_stream(oc, oc->nb_streams);
+ st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
- avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
+ output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
+ if(!audio_stream_copy){
+ if (audio_codec_name) {
+ codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
+ avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
+ codec = avcodec_find_encoder_by_name(audio_codec_name);
+ output_codecs[nb_output_codecs-1] = codec;
+ } else {
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
+ codec = avcodec_find_encoder(codec_id);
+ }
+ }
+
+ avcodec_get_context_defaults3(st->codec, codec);
+
+ bitstream_filters[nb_output_files] = grow_array(bitstream_filters[nb_output_files], sizeof(*bitstream_filters[nb_output_files]), &nb_bitstream_filters[nb_output_files], oc->nb_streams);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
audio_bitstream_filters= NULL;
audio_enc->channels = audio_channels;
audio_enc->sample_rate = audio_sample_rate;
} else {
- AVCodec *codec;
-
- set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
-
- if (audio_codec_name) {
- codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
- audio_enc->strict_std_compliance);
- codec = avcodec_find_encoder_by_name(audio_codec_name);
- output_codecs[nb_ocodecs] = codec;
- } else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
- codec = avcodec_find_encoder(codec_id);
- }
audio_enc->codec_id = codec_id;
+ set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
if (audio_qscale > QSCALE_NONE) {
audio_enc->flags |= CODEC_FLAG_QSCALE;
choose_sample_fmt(st, codec);
choose_sample_rate(st, codec);
}
- nb_ocodecs++;
audio_enc->time_base= (AVRational){1, audio_sample_rate};
if (audio_language) {
av_metadata_set2(&st->metadata, "language", audio_language, 0);
static void new_subtitle_stream(AVFormatContext *oc)
{
AVStream *st;
+ AVCodec *codec=NULL;
AVCodecContext *subtitle_enc;
- st = av_new_stream(oc, oc->nb_streams);
+ st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
- avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
+ subtitle_enc = st->codec;
+ output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
+ if(!subtitle_stream_copy){
+ subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
+ avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
+ codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
+ }
+ avcodec_get_context_defaults3(st->codec, codec);
+ bitstream_filters[nb_output_files] =
+ grow_array(bitstream_filters[nb_output_files],
+ sizeof(*bitstream_filters[nb_output_files]),
+ &nb_bitstream_filters[nb_output_files], oc->nb_streams);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
subtitle_bitstream_filters= NULL;
- subtitle_enc = st->codec;
subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
if(subtitle_codec_tag)
if (subtitle_stream_copy) {
st->stream_copy = 1;
} else {
- set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
- subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
- subtitle_enc->strict_std_compliance);
- output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
+ set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
}
- nb_ocodecs++;
if (subtitle_language) {
av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
subtitle_stream_copy = 0;
}
-static void opt_new_audio_stream(void)
+static void opt_new_stream(const char *opt, const char *arg)
{
AVFormatContext *oc;
if (nb_output_files <= 0) {
fprintf(stderr, "At least one output file must be specified\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
oc = output_files[nb_output_files - 1];
- new_audio_stream(oc);
-}
-static void opt_new_video_stream(void)
-{
- AVFormatContext *oc;
- if (nb_output_files <= 0) {
- fprintf(stderr, "At least one output file must be specified\n");
- av_exit(1);
- }
- oc = output_files[nb_output_files - 1];
- new_video_stream(oc);
+ if (!strcmp(opt, "newvideo" )) new_video_stream (oc);
+ else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc);
+ else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc);
+ else av_assert0(0);
}
-static void opt_new_subtitle_stream(void)
+/* arg format is "output-stream-index:streamid-value". */
+static void opt_streamid(const char *opt, const char *arg)
{
- AVFormatContext *oc;
- if (nb_output_files <= 0) {
- fprintf(stderr, "At least one output file must be specified\n");
- av_exit(1);
- }
- oc = output_files[nb_output_files - 1];
- new_subtitle_stream(oc);
+ int idx;
+ char *p;
+ char idx_str[16];
+
+ strncpy(idx_str, arg, sizeof(idx_str));
+ idx_str[sizeof(idx_str)-1] = '\0';
+ p = strchr(idx_str, ':');
+ if (!p) {
+ fprintf(stderr,
+ "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
+ arg, opt);
+ ffmpeg_exit(1);
+ }
+ *p++ = '\0';
+ idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
+ streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
+ streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
}
static void opt_output_file(const char *filename)
oc = avformat_alloc_context();
if (!oc) {
print_error(filename, AVERROR(ENOMEM));
- av_exit(1);
+ ffmpeg_exit(1);
}
if (last_asked_format) {
file_oformat = av_guess_format(last_asked_format, NULL, NULL);
if (!file_oformat) {
fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
- av_exit(1);
+ ffmpeg_exit(1);
}
last_asked_format = NULL;
} else {
if (!file_oformat) {
fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
filename);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
int err = read_ffserver_streams(oc, filename);
if (err < 0) {
print_error(filename, err);
- av_exit(1);
+ ffmpeg_exit(1);
}
} else {
use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
new_subtitle_stream(oc);
}
- oc->timestamp = rec_timestamp;
+ oc->timestamp = recording_timestamp;
for(; metadata_count>0; metadata_count--){
av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
if (!av_filename_number_test(oc->filename)) {
print_error(oc->filename, AVERROR_NUMEXPECTED);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
fflush(stderr);
if (!read_yesno()) {
fprintf(stderr, "Not overwriting - exiting\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
}
else {
fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
}
/* open the file */
if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
print_error(filename, err);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
if (av_set_parameters(oc, ap) < 0) {
fprintf(stderr, "%s: Invalid encoding parameters\n",
oc->filename);
- av_exit(1);
+ ffmpeg_exit(1);
}
oc->preload= (int)(mux_preload*AV_TIME_BASE);
oc->loop_output = loop_output;
oc->flags |= AVFMT_FLAG_NONBLOCK;
- set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
+ set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
+
+ nb_streamid_map = 0;
}
/* same option as mencoder */
pass = atoi(pass_str);
if (pass != 1 && pass != 2) {
fprintf(stderr, "pass number can be only 1 or 2\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
do_pass = pass;
}
p = strchr(p, ',');
if(!p) {
fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
- av_exit(1);
+ ffmpeg_exit(1);
}
p++;
}
parse_matrix_coeffs(intra_matrix, arg);
}
-/**
- * Trivial log callback.
- * Only suitable for show_help and similar since it lacks prefix handling.
- */
-static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
-{
- vfprintf(stdout, fmt, vl);
-}
-
static void show_usage(void)
{
printf("Hyper fast Audio and Video encoder\n");
OPT_GRAB,
OPT_GRAB);
printf("\n");
- av_opt_show(avcodec_opts[0], NULL);
+ av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
printf("\n");
- av_opt_show(avformat_opts, NULL);
+ av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
printf("\n");
- av_opt_show(sws_opts, NULL);
+ av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
}
static void opt_target(const char *arg)
fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if(!strcmp(arg, "vcd")) {
} else {
fprintf(stderr, "Unknown target: %s\n", arg);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
if(!bsfc){
fprintf(stderr, "Unknown bitstream filter %s\n", arg);
- av_exit(1);
+ ffmpeg_exit(1);
}
bsfp= *opt == 'v' ? &video_bitstream_filters :
if(!f){
fprintf(stderr, "File for preset '%s' not found\n", arg);
- av_exit(1);
+ ffmpeg_exit(1);
}
while(!feof(f)){
e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
if(e){
fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
- av_exit(1);
+ ffmpeg_exit(1);
}
if(!strcmp(tmp, "acodec")){
opt_audio_codec(tmp2);
opt_subtitle_codec(tmp2);
}else if(opt_default(tmp, tmp2) < 0){
fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
{ "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
{ "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
{ "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
- { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
+ { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
{ "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
{ "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
{ "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
{ "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
{ "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
{ "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" },
- { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
- { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
- { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
- { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
- { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set top pad band size (in pixels)", "size" },
- { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set bottom pad band size (in pixels)", "size" },
- { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set left pad band size (in pixels)", "size" },
- { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set right pad band size (in pixels)", "size" },
- { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
+ { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "Deprecated, please use the crop avfilter", "size" },
+ { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "Deprecated, please use the crop avfilter", "size" },
+ { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "Deprecated, please use the crop avfilter", "size" },
+ { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "Deprecated, please use the crop avfilter", "size" },
+ { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
+ { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
+ { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
+ { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
+ { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
{ "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
{ "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
{ "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
{ "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
{ "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
{ "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
- { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
+ { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
{ "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
{ "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
{ "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
+ { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
/* audio options */
{ "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
{ "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
{ "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
{ "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
- { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
+ { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
{ "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
{ "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" },
/* subtitle options */
{ "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
{ "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
- { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
+ { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
{ "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
{ "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
int main(int argc, char **argv)
{
- int i;
int64_t ti;
+ av_log_set_flags(AV_LOG_SKIP_REPEATED);
+
avcodec_register_all();
#if CONFIG_AVDEVICE
avdevice_register_all();
url_set_interrupt_cb(decode_interrupt_cb);
#endif
- for(i=0; i<AVMEDIA_TYPE_NB; i++){
- avcodec_opts[i]= avcodec_alloc_context2(i);
- }
- avformat_opts = avformat_alloc_context();
- sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
+ init_opts();
show_banner();
if(nb_output_files <= 0 && nb_input_files == 0) {
show_usage();
fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
/* file converter / grab */
if (nb_output_files <= 0) {
fprintf(stderr, "At least one output file must be specified\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if (nb_input_files == 0) {
fprintf(stderr, "At least one input file must be specified\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
ti = getutime();
- if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
- stream_maps, nb_stream_maps) < 0)
- av_exit(1);
+ if (transcode(output_files, nb_output_files, input_files, nb_input_files,
+ stream_maps, nb_stream_maps) < 0)
+ ffmpeg_exit(1);
ti = getutime() - ti;
if (do_benchmark) {
int maxrss = getmaxrss() / 1024;
printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
}
- return av_exit(0);
+ return ffmpeg_exit(0);
}
projects / ffmpeg / blobdiff