#include "libswscale/swscale.h"
#include "libavcodec/opt.h"
#include "libavcodec/audioconvert.h"
+#include "libavcore/parseutils.h"
#include "libavutil/colorspace.h"
#include "libavutil/fifo.h"
#include "libavutil/pixdesc.h"
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;
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;
+ 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);
}
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;
}
/* 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;
}
return q_pressed || (q_pressed = read_key() == 'q');
}
-static int av_exit(int ret)
+static int ffmpeg_exit(int ret)
{
int i;
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 (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(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 (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
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);
}
}
}
#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;
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)
#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]);
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);
+ ffmpeg_exit(1);
memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
}
}
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;
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);
}
}
}
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;
}
}
/* 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 */
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);
}
}
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);
}
}
scale= strtod(p, &p);
if(stream >= MAX_STREAMS)
- av_exit(1);
+ ffmpeg_exit(1);
input_files_ts_scale[nb_input_files][stream]= scale;
}
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));
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;
}
if (ret < 0 && verbose >= 0) {
fprintf(stderr, "%s: could not find codec parameters\n", filename);
av_close_input_file(ic);
- av_exit(1);
+ ffmpeg_exit(1);
}
timestamp = start_time;
input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
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(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
st = av_new_stream(oc, streamid_map[oc->nb_streams]);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
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,
st = av_new_stream(oc, streamid_map[oc->nb_streams]);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
st = av_new_stream(oc, streamid_map[oc->nb_streams]);
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_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);
-}
-
-static void opt_new_subtitle_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_subtitle_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 assert(0);
}
/* arg format is "output-stream-index:streamid-value". */
fprintf(stderr,
"Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
arg, opt);
- av_exit(1);
+ ffmpeg_exit(1);
}
*p++ = '\0';
idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
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;
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);
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++;
}
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);
}
}
{ "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" },
{ "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" },
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