* 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 {
static const OptionDef options[];
#define MAX_FILES 100
-#define MAX_STREAMS 1024 /* arbitrary sanity check value */
-
-#define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
static const char *last_asked_format = NULL;
static double *ts_scale;
#endif
int sws_flags;
+ AVDictionary *opts;
} OutputStream;
static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
int is_start; /* is 1 at the start and after a discontinuity */
int showed_multi_packet_warning;
int is_past_recording_time;
+ AVDictionary *opts;
} InputStream;
typedef struct InputFile {
return received_nb_signals > 1;
}
-static int ffmpeg_exit(int ret)
+void exit_program(int ret)
{
int i;
for(i=0;i<nb_input_files;i++) {
av_close_input_file(input_files[i].ctx);
}
+ for (i = 0; i < nb_input_streams; i++)
+ av_dict_free(&input_streams[i].opts);
av_free(intra_matrix);
av_free(inter_matrix);
}
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);
}
}
-/* similar to ff_dynarray_add() and av_fast_realloc() */
-static void *grow_array(void *array, int elem_size, int *size, int new_size)
+static void assert_codec_experimental(AVCodecContext *c, int encoder)
{
- 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;
+ const char *codec_string = encoder ? "encoder" : "decoder";
+ AVCodec *codec;
+ if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
+ c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
+ av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
+ "results.\nAdd '-strict experimental' if you want to use it.\n",
+ codec_string, c->codec->name);
+ codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
+ if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
+ av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
+ codec_string, codec->name);
+ 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;
ost->st = st;
ost->enc = codec;
+ if (codec)
+ ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
avcodec_get_context_defaults3(st->codec, codec);
return ost;
}
-static int read_ffserver_streams(AVFormatContext *s, const char *filename)
+static int read_avserver_streams(AVFormatContext *s, const char *filename)
{
int i, err;
AVFormatContext *ic = NULL;
- int nopts = 0;
err = avformat_open_input(&ic, filename, NULL, NULL);
if (err < 0)
} else
choose_pixel_fmt(st, codec);
}
-
- if(st->codec->flags & CODEC_FLAG_BITEXACT)
- nopts = 1;
}
av_close_input_file(ic);
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);
}
}
ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
&avpkt);
if (ret < 0)
- goto fail_decode;
+ return ret;
avpkt.data += ret;
avpkt.size -= ret;
data_size = ret;
&picture, &got_output, &avpkt);
quality = same_quality ? picture.quality : 0;
if (ret < 0)
- goto fail_decode;
+ return ret;
if (!got_output) {
/* no picture yet */
goto discard_packet;
ret = avcodec_decode_subtitle2(ist->st->codec,
&subtitle, &got_output, &avpkt);
if (ret < 0)
- goto fail_decode;
+ return ret;
if (!got_output) {
goto discard_packet;
}
avpkt.size = 0;
break;
default:
- goto fail_decode;
+ return -1;
}
} else {
switch(ist->st->codec->codec_type) {
} 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)
}
return 0;
- fail_decode:
- return -1;
}
static void print_sdp(AVFormatContext **avc, int n)
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;
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) {
+ codec->width = icodec->width;
+ codec->height = icodec->height;
+ }
+
ost->video_resample = codec->width != icodec->width ||
codec->height != icodec->height ||
codec->pix_fmt != icodec->pix_fmt;
#if !CONFIG_AVFILTER
avcodec_get_frame_defaults(&ost->pict_tmp);
if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
- codec->width, codec->height)) {
+ 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,
icodec->height,
- icodec->pix_fmt,
- codec->width,
- codec->height,
- codec->pix_fmt,
- ost->sws_flags, NULL, NULL, NULL);
+ icodec->pix_fmt,
+ codec->width,
+ codec->height,
+ codec->pix_fmt,
+ 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;
}
- if (!codec->width || !codec->height) {
- codec->width = icodec->width;
- codec->height = icodec->height;
- }
+
ost->resample_height = icodec->height;
ost->resample_width = icodec->width;
ost->resample_pix_fmt= icodec->pix_fmt;
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;
}
memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
}
- if (avcodec_open(ost->st->codec, codec) < 0) {
+ if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
ost->file_index, ost->index);
ret = AVERROR(EINVAL);
goto dump_format;
}
+ assert_codec_experimental(ost->st->codec, 1);
+ assert_avoptions(ost->opts);
+ if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
+ av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
+ "It takes bits/s as argument, not kbits/s\n");
extra_size += ost->st->codec->extradata_size;
}
}
}
}
- if (avcodec_open(ist->st->codec, codec) < 0) {
+ if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
ist->file_index, ist->st->index);
ret = AVERROR(EINVAL);
goto dump_format;
}
- //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
- // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
+ assert_codec_experimental(ist->st->codec, 0);
+ assert_avoptions(ost->opts);
}
}
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;
}
audio_resample_close(ost->resample);
if (ost->reformat_ctx)
av_audio_convert_free(ost->reformat_ctx);
+ av_dict_free(&ost->opts);
av_free(ost);
}
}
{
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;
}
-static int opt_bitrate(const char *opt, const char *arg)
-{
- int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
-
- opt_default(opt, arg);
-
- if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
- fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
-
- return 0;
-}
-
static int opt_frame_crop(const char *opt, const char *arg)
{
fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
}
} 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';
p++;
scale= strtod(p, &p);
- if(stream >= MAX_STREAMS)
- ffmpeg_exit(1);
-
ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
ts_scale[stream] = scale;
return 0;
return 0;
}
-static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
+static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
{
const char *codec_string = encoder ? "encoder" : "decoder";
AVCodec *codec;
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);
- }
- if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
- strict > FF_COMPLIANCE_EXPERIMENTAL) {
- fprintf(stderr, "%s '%s' is experimental and might produce bad "
- "results.\nAdd '-strict experimental' if you want to use it.\n",
- codec_string, codec->name);
- codec = encoder ?
- avcodec_find_encoder(codec->id) :
- avcodec_find_decoder(codec->id);
- if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
- fprintf(stderr, "Or use the non experimental %s '%s'.\n",
- codec_string, codec->name);
- ffmpeg_exit(1);
+ exit_program(1);
}
return codec->id;
}
int err, i, ret, rfps, rfps_base;
int64_t timestamp;
uint8_t buf[128];
+ AVDictionary **opts;
+ int orig_nb_streams; // number of streams before avformat_find_stream_info
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);
av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
ic->video_codec_id =
- find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
- avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
+ find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
ic->audio_codec_id =
- find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
- avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
+ find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
ic->subtitle_codec_id=
- find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
- avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
+ find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
ic->flags |= AVFMT_FLAG_NONBLOCK;
/* open the input file with generic libav function */
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;
}
ic->loop_input = loop_input;
}
- /* Set AVCodecContext options so they will be seen by av_find_stream_info() */
- for (i = 0; i < ic->nb_streams; i++) {
- AVCodecContext *dec = ic->streams[i]->codec;
- switch (dec->codec_type) {
- case AVMEDIA_TYPE_AUDIO:
- set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO],
- AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
- NULL);
- break;
- case AVMEDIA_TYPE_VIDEO:
- set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO],
- AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
- NULL);
- break;
- }
- }
+ /* Set AVCodecContext options for avformat_find_stream_info */
+ opts = setup_find_stream_info_opts(ic, codec_opts);
+ orig_nb_streams = ic->nb_streams;
/* If not enough info to get the stream parameters, we decode the
first frames to get it. (used in mpeg case for example) */
- ret = av_find_stream_info(ic);
+ ret = avformat_find_stream_info(ic, opts);
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;
ist->st = st;
ist->file_index = nb_input_files;
ist->discard = 1;
+ ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
if (i < nb_ts_scale)
ist->ts_scale = ts_scale[i];
switch (dec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
ist->dec = 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, ist->dec);
if(audio_disable)
st->discard= AVDISCARD_ALL;
break;
case AVMEDIA_TYPE_VIDEO:
ist->dec = 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, ist->dec);
rfps = ic->streams[i]->r_frame_rate.num;
rfps_base = ic->streams[i]->r_frame_rate.den;
if (dec->lowres) {
av_freep(&ts_scale);
nb_ts_scale = 0;
+ for (i = 0; i < orig_nb_streams; i++)
+ av_dict_free(&opts[i]);
+ av_freep(&opts);
av_freep(&video_codec_name);
av_freep(&audio_codec_name);
av_freep(&subtitle_codec_name);
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_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
codec = avcodec_find_encoder_by_name(video_codec_name);
} else {
codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
}
+ video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
if (video_stream_copy) {
st->stream_copy = 1;
- video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
video_enc->sample_aspect_ratio =
st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
} else {
if (frame_rate.num)
ost->frame_rate = frame_rate;
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, codec);
video_enc->width = frame_width;
video_enc->height = frame_height;
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,
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_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
codec = avcodec_find_encoder_by_name(audio_codec_name);
} else {
codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
}
if (audio_stream_copy) {
st->stream_copy = 1;
} else {
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;
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;
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
if (data_stream_copy) {
st->stream_copy = 1;
if(!subtitle_stream_copy){
if (subtitle_codec_name) {
- codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
- avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
+ codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
codec = avcodec_find_encoder_by_name(subtitle_codec_name);
} else {
codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
if (subtitle_stream_copy) {
st->stream_copy = 1;
} else {
subtitle_enc->codec_id = codec_id;
- set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
}
if (subtitle_language) {
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, MAX_STREAMS-1);
+ idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
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);
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);
}
}
if (!strcmp(file_oformat->name, "ffm") &&
av_strstart(filename, "http:", NULL)) {
- /* special case for files sent to ffserver: we get the stream
- parameters from ffserver */
- int err = read_ffserver_streams(oc, filename);
+ /* special case for files sent to avserver: we get the stream
+ parameters from avserver */
+ 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);
}
}
{ "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
/* video options */
- { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
- { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
{ "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
{ "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
{ "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
{ "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
/* audio options */
- { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
{ "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
{ "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
{ "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
show_banner();
+ av_log(NULL, AV_LOG_WARNING, "This program is not developed anymore and is only "
+ "provided for compatibility. Use avconv instead "
+ "(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;
}
OSDN Git Service
