* select an input file for an output file
*/
typedef struct MetadataMap {
- int file; //< file index
- char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
- int index; //< stream/chapter/program number
+ int file; ///< file index
+ char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
+ int index; ///< stream/chapter/program number
} MetadataMap;
typedef struct ChapterMap {
int ist_index; /* index of first stream in ist_table */
int buffer_size; /* current total buffer size */
int64_t ts_offset;
+ int nb_streams; /* nb streams we are aware of */
} InputFile;
static InputStream *input_streams = NULL;
return received_nb_signals > 1;
}
-static int ffmpeg_exit(int ret)
+void exit_program(int ret)
{
int i;
}
exit(ret); /* not all OS-es handle main() return value */
- return ret;
}
static void assert_avoptions(AVDictionary *m)
AVDictionaryEntry *t;
if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
- ffmpeg_exit(1);
+ exit_program(1);
}
}
if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
codec_string, codec->name);
- ffmpeg_exit(1);
- }
-}
-
-/* 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;
+ exit_program(1);
}
- return array;
}
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
if (!st) {
av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
output_streams_for_file[file_idx] =
av_mallocz(sizeof(OutputStream));
if (!ost) {
fprintf(stderr, "Could not alloc output stream\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
ost->file_index = file_idx;
ost->index = idx;
avctx->codec ? avctx->codec->name : "copy");
print_error("", a);
if (exit_on_error)
- ffmpeg_exit(1);
+ exit_program(1);
}
*pkt= new_pkt;
ret= av_interleaved_write_frame(s, pkt);
if(ret < 0){
print_error("av_interleaved_write_frame()", ret);
- ffmpeg_exit(1);
+ exit_program(1);
}
}
if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
fprintf(stderr, "Buffer sizes too large\n");
- ffmpeg_exit(1);
+ exit_program(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");
- ffmpeg_exit(1);
+ exit_program(1);
}
if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
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);
- ffmpeg_exit(1);
+ exit_program(1);
}
}
}
fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
av_get_sample_fmt_name(dec->sample_fmt),
av_get_sample_fmt_name(enc->sample_fmt));
- ffmpeg_exit(1);
+ exit_program(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)
- ffmpeg_exit(1);
+ exit_program(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");
- ffmpeg_exit(1);
+ exit_program(1);
}
av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
(short *)audio_buf);
if (ret < 0) {
fprintf(stderr, "Audio encoding failed\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
audio_size += ret;
pkt.stream_index= ost->index;
if(size_out > audio_out_size){
fprintf(stderr, "Internal error, buffer size too small\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
//FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
(short *)buftmp);
if (ret < 0) {
fprintf(stderr, "Audio encoding failed\n");
- ffmpeg_exit(1);
+ exit_program(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)
- ffmpeg_exit(1);
+ exit_program(1);
return;
}
subtitle_out_max_size, sub);
if (subtitle_out_size < 0) {
fprintf(stderr, "Subtitle encoding failed\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
av_init_packet(&pkt);
ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
if(!ost->video_resample)
- ffmpeg_exit(1);
+ exit_program(1);
}
#if !CONFIG_AVFILTER
ost->sws_flags, NULL, NULL, NULL);
if (ost->img_resample_ctx == NULL) {
fprintf(stderr, "Cannot get resampling context\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
}
sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
&big_picture);
if (ret < 0) {
fprintf(stderr, "Video encoding failed\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
if(ret>0){
vstats_file = fopen(vstats_filename, "w");
if (!vstats_file) {
perror("fopen");
- ffmpeg_exit(1);
+ exit_program(1);
}
}
} else { /* pad */
int frame_bytes = enc->frame_size*osize*enc->channels;
if (allocated_audio_buf_size < frame_bytes)
- ffmpeg_exit(1);
+ exit_program(1);
generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
}
}
if (ret < 0) {
fprintf(stderr, "Audio encoding failed\n");
- ffmpeg_exit(1);
+ exit_program(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");
- ffmpeg_exit(1);
+ exit_program(1);
}
video_size += ret;
if(enc->coded_frame && enc->coded_frame->key_frame)
ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
if (!ost->forced_kf_pts) {
av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
for (i = 0; i < n; i++) {
p = i ? strchr(p, ',') + 1 : kf;
int si = stream_maps[i].stream_index;
if (fi < 0 || fi > nb_input_files - 1 ||
- si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
+ si < 0 || si > input_files[fi].nb_streams - 1) {
fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
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 > input_files[fi].ctx->nb_streams - 1) {
+ si < 0 || si > input_files[fi].nb_streams - 1) {
fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
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);
- ffmpeg_exit(1);
+ exit_program(1);
}
} else {
av_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);
- ffmpeg_exit(1);
+ exit_program(1);
}
}
}
case AVMEDIA_TYPE_AUDIO:
if(audio_volume != 256) {
fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
codec->channel_layout = icodec->channel_layout;
codec->sample_rate = icodec->sample_rate;
if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
if (!codec->width || !codec->height) {
if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
codec->width, codec->height)) {
fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
ost->img_resample_ctx = sws_getContext(
icodec->width,
ost->sws_flags, NULL, NULL, NULL);
if (ost->img_resample_ctx == NULL) {
fprintf(stderr, "Cannot get resampling context\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
#endif
codec->bits_per_raw_sample= 0;
f = fopen(logfilename, "wb");
if (!f) {
fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
- ffmpeg_exit(1);
+ exit_program(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);
- ffmpeg_exit(1);
+ exit_program(1);
}
codec->stats_in = logbuffer;
}
}
/* the following test is needed in case new streams appear
dynamically in stream : we ignore them */
- if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
+ if (pkt.stream_index >= input_files[file_index].nb_streams)
goto discard_packet;
ist_index = input_files[file_index].ist_index + pkt.stream_index;
ist = &input_streams[ist_index];
fprintf(stderr, "Error while decoding stream #%d.%d\n",
ist->file_index, ist->st->index);
if (exit_on_error)
- ffmpeg_exit(1);
+ exit_program(1);
av_free_packet(&pkt);
goto redo;
}
{
if (av_parse_video_rate(&frame_rate, arg) < 0) {
fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
- ffmpeg_exit(1);
+ exit_program(1);
}
return 0;
}
}
} else {
show_pix_fmts();
- ffmpeg_exit(0);
+ exit_program(0);
}
return 0;
}
if(!mid){
fprintf(stderr, "Missing =\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
*mid++= 0;
char fmt_str[128];
for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
- ffmpeg_exit(0);
+ exit_program(0);
}
return 0;
}
break;
default:
fprintf(stderr, "Invalid metadata type %c.\n", *arg);
- ffmpeg_exit(1);
+ exit_program(1);
}
} else
*type = 'g';
avcodec_find_decoder_by_name(name);
if(!codec) {
fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
- ffmpeg_exit(1);
+ exit_program(1);
}
if(codec->type != type) {
fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
- ffmpeg_exit(1);
+ exit_program(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);
- ffmpeg_exit(1);
+ exit_program(1);
}
last_asked_format = NULL;
}
ic = avformat_alloc_context();
if (!ic) {
print_error(filename, AVERROR(ENOMEM));
- ffmpeg_exit(1);
+ exit_program(1);
}
if (audio_sample_rate) {
snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
if (err < 0) {
print_error(filename, err);
- ffmpeg_exit(1);
+ exit_program(1);
}
assert_avoptions(format_opts);
}
if(!found){
fprintf(stderr, "Specified program id not found\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
opt_programid=0;
}
if (ret < 0 && verbose >= 0) {
fprintf(stderr, "%s: could not find codec parameters\n", filename);
av_close_input_file(ic);
- ffmpeg_exit(1);
+ exit_program(1);
}
timestamp = start_time;
input_files[nb_input_files - 1].ctx = ic;
input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
+ input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
frame_rate = (AVRational){0, 0};
frame_pix_fmt = PIX_FMT_NONE;
int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
if(e!=3){
fprintf(stderr, "error parsing rc_override\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
video_enc->rc_override=
av_realloc(video_enc->rc_override,
data_enc = st->codec;
if (!data_stream_copy) {
fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
data_enc->codec_type = AVMEDIA_TYPE_DATA;
int file_idx = nb_output_files - 1;
if (nb_output_files <= 0) {
fprintf(stderr, "At least one output file must be specified\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
oc = output_files[file_idx];
fprintf(stderr,
"Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
arg, opt);
- ffmpeg_exit(1);
+ exit_program(1);
}
*p++ = '\0';
idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
return 0;
}
-static void opt_output_file(const char *filename)
+static void opt_output_file(void *optctx, const char *filename)
{
AVFormatContext *oc;
int err, use_video, use_audio, use_subtitle, use_data;
oc = avformat_alloc_context();
if (!oc) {
print_error(filename, AVERROR(ENOMEM));
- ffmpeg_exit(1);
+ exit_program(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);
- ffmpeg_exit(1);
+ exit_program(1);
}
last_asked_format = NULL;
} else {
if (!file_oformat) {
fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
filename);
- ffmpeg_exit(1);
+ exit_program(1);
}
}
int err = read_avserver_streams(oc, filename);
if (err < 0) {
print_error(filename, err);
- ffmpeg_exit(1);
+ exit_program(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(EINVAL));
- ffmpeg_exit(1);
+ exit_program(1);
}
}
fflush(stderr);
if (!read_yesno()) {
fprintf(stderr, "Not overwriting - exiting\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
}
else {
fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
- ffmpeg_exit(1);
+ exit_program(1);
}
}
}
/* open the file */
if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
print_error(filename, err);
- ffmpeg_exit(1);
+ exit_program(1);
}
}
p = strchr(p, ',');
if(!p) {
fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
- ffmpeg_exit(1);
+ exit_program(1);
}
p++;
}
AVCodec *c;
AVOutputFormat *oformat = NULL;
AVInputFormat *iformat = NULL;
+ const AVClass *class;
av_log_set_callback(log_callback_help);
show_usage();
OPT_GRAB,
OPT_GRAB);
printf("\n");
- av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
+ class = avcodec_get_class();
+ av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
printf("\n");
/* individual codec options */
}
}
- av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
+ class = avformat_get_class();
+ av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
printf("\n");
/* individual muxer options */
}
}
- av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
+ class = sws_get_class();
+ av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
}
static int opt_target(const char *opt, 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");
- ffmpeg_exit(1);
+ exit_program(1);
}
if(!strcmp(arg, "vcd")) {
if(!bsfc){
fprintf(stderr, "Unknown bitstream filter %s\n", arg);
- ffmpeg_exit(1);
+ exit_program(1);
}
bsfp= *opt == 'v' ? &video_bitstream_filters :
if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
fprintf(stderr, "File for preset '%s' not found\n", arg);
- ffmpeg_exit(1);
+ exit_program(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);
- ffmpeg_exit(1);
+ exit_program(1);
}
if(!strcmp(tmp, "acodec")){
opt_audio_codec(tmp, tmp2);
opt_data_codec(tmp, 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);
- ffmpeg_exit(1);
+ exit_program(1);
}
}
int64_t ti;
av_log_set_flags(AV_LOG_SKIP_REPEATED);
+ parse_loglevel(argc, argv, options);
avcodec_register_all();
#if CONFIG_AVDEVICE
"(see Changelog for the list of incompatible changes).\n");
/* parse options */
- parse_options(argc, argv, options, opt_output_file);
+ parse_options(NULL, argc, argv, options, opt_output_file);
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");
- ffmpeg_exit(1);
+ exit_program(1);
}
/* file converter / grab */
if (nb_output_files <= 0) {
fprintf(stderr, "At least one output file must be specified\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
if (nb_input_files == 0) {
fprintf(stderr, "At least one input file must be specified\n");
- ffmpeg_exit(1);
+ exit_program(1);
}
ti = getutime();
if (transcode(output_files, nb_output_files, input_files, nb_input_files,
stream_maps, nb_stream_maps) < 0)
- ffmpeg_exit(1);
+ exit_program(1);
ti = getutime() - ti;
if (do_benchmark) {
int maxrss = getmaxrss() / 1024;
printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
}
- return ffmpeg_exit(0);
+ exit_program(0);
+ return 0;
}