#undef exit
+static const char program_name[] = "FFmpeg";
+static const int program_birth_year = 2000;
+
/* select an input stream for an output stream */
typedef struct AVStreamMap {
int file_index;
extern const OptionDef options[];
static void show_help(void);
-static void opt_show_license(void);
static int opt_default(const char *opt, const char *arg);
#define MAX_FILES 20
static int opt_shortest = 0; //
static int video_global_header = 0;
static char *vstats_filename;
-static FILE *fvstats;
+static FILE *vstats_file;
+static int opt_programid = 0;
static int rate_emu = 0;
}
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
+ int ret;
+
while(bsfc){
AVPacket new_pkt= *pkt;
int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
bsfc= bsfc->next;
}
- av_interleaved_write_frame(s, pkt);
+ ret= av_interleaved_write_frame(s, pkt);
+ if(ret < 0){
+ print_error("av_interleaved_write_frame()", ret);
+ exit(1);
+ }
}
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
double ti1, bitrate, avg_bitrate;
/* this is executed just the first time do_video_stats is called */
- if (!fvstats) {
- fvstats = fopen(vstats_filename, "w");
- if (!fvstats) {
+ if (!vstats_file) {
+ vstats_file = fopen(vstats_filename, "w");
+ if (!vstats_file) {
perror("fopen");
exit(1);
}
enc = ost->st->codec;
if (enc->codec_type == CODEC_TYPE_VIDEO) {
frame_number = ost->frame_number;
- fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
+ fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
if (enc->flags&CODEC_FLAG_PSNR)
- fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
+ fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
- fprintf(fvstats,"f_size= %6d ", frame_size);
+ fprintf(vstats_file,"f_size= %6d ", frame_size);
/* compute pts value */
ti1 = ost->sync_opts * av_q2d(enc->time_base);
if (ti1 < 0.01)
bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
- fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
+ fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
(double)video_size / 1024, ti1, bitrate, avg_bitrate);
- fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
+ fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
}
}
return -1;
}
+static void print_sdp(AVFormatContext **avc, int n)
+{
+ char sdp[2048];
+
+ avf_sdp_create(avc, n, sdp, sizeof(sdp));
+ printf("SDP:\n%s\n", sdp);
+}
+
+static int stream_index_from_inputs(AVFormatContext **input_files,
+ int nb_input_files,
+ AVInputFile *file_table,
+ AVInputStream **ist_table,
+ enum CodecType type,
+ int programid)
+{
+ int p, q, z;
+ for(z=0; z<nb_input_files; z++) {
+ AVFormatContext *ic = input_files[z];
+ for(p=0; p<ic->nb_programs; p++) {
+ AVProgram *program = ic->programs[p];
+ if(program->id != programid)
+ continue;
+ for(q=0; q<program->nb_stream_indexes; q++) {
+ int sidx = program->stream_index[q];
+ int ris = file_table[z].ist_index + sidx;
+ if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
+ return ris;
+ }
+ }
+ }
+
+ return -1;
+}
/*
* The following code is the main loop of the file converter
AVInputStream *ist, **ist_table = NULL;
AVInputFile *file_table;
int key;
+ int want_sdp = 1;
file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
if (!file_table)
}
} else {
- /* get corresponding input stream index : we select the first one with the right type */
- found = 0;
- for(j=0;j<nb_istreams;j++) {
- ist = ist_table[j];
- if (ist->discard &&
- ist->st->codec->codec_type == ost->st->codec->codec_type) {
+ if(opt_programid) {
+ found = 0;
+ j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
+ if(j != -1) {
ost->source_index = j;
found = 1;
- break;
}
- }
-
- if (!found) {
- /* try again and reuse existing stream */
+ } else {
+ /* get corresponding input stream index : we select the first one with the right type */
+ found = 0;
for(j=0;j<nb_istreams;j++) {
ist = ist_table[j];
- if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
+ if (ist->discard &&
+ ist->st->codec->codec_type == ost->st->codec->codec_type) {
ost->source_index = j;
found = 1;
+ break;
+ }
+ }
+ }
+
+ if (!found) {
+ if(! opt_programid) {
+ /* try again and reuse existing stream */
+ for(j=0;j<nb_istreams;j++) {
+ ist = ist_table[j];
+ if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
+ ost->source_index = j;
+ found = 1;
+ }
}
}
if (!found) {
ret = AVERROR(EINVAL);
goto fail;
}
+ if (strcmp(output_files[i]->oformat->name, "rtp")) {
+ want_sdp = 0;
+ }
+ }
+ if (want_sdp) {
+ print_sdp(output_files, nb_output_files);
}
if ( !using_stdin && verbose >= 0) {
}
}
+static void opt_bitrate(const char *opt, const char *arg)
+{
+ int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
+
+ opt_default(opt, arg);
+
+ if (av_get_int(avctx_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");
+}
+
static void opt_frame_crop_top(const char *arg)
{
frame_topBand = atoi(arg);
m->in_file = strtol(p, (char **)&p, 0);
}
+static int64_t parse_time_or_die(const char *timestr, int is_duration)
+{
+ int64_t us = parse_date(timestr, is_duration);
+ if (us == INT64_MIN) {
+ fprintf(stderr, "Invalid %s specification: %s\n",
+ is_duration ? "duration" : "date", timestr);
+ exit(1);
+ }
+ return us;
+}
+
static void opt_recording_time(const char *arg)
{
- recording_time = parse_date(arg, 1);
+ recording_time = parse_time_or_die(arg, 1);
}
static void opt_start_time(const char *arg)
{
- start_time = parse_date(arg, 1);
+ start_time = parse_time_or_die(arg, 1);
}
static void opt_rec_timestamp(const char *arg)
{
- rec_timestamp = parse_date(arg, 0) / 1000000;
+ rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
}
static void opt_input_ts_offset(const char *arg)
{
- input_ts_offset = parse_date(arg, 1);
+ input_ts_offset = parse_time_or_die(arg, 1);
}
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
for(i=0; i<opt_name_count; i++){
const AVOption *opt;
double d= av_get_double(avformat_opts, opt_names[i], &opt);
- if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
+ if(!isnan(d) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
av_set_double(ic, opt_names[i], d);
}
/* open the input file with generic libav function */
print_error(filename, err);
exit(1);
}
+ if(opt_programid) {
+ int i;
+ for(i=0; i<ic->nb_programs; i++)
+ if(ic->programs[i]->id != opt_programid)
+ ic->programs[i]->discard = AVDISCARD_ALL;
+ }
ic->loop_input = loop_input;
for(j=0; j<opt_name_count; j++){
const AVOption *opt;
double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
- if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
+ if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
av_set_double(enc, opt_names[j], d);
}
//fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
for(j=0; j<opt_name_count; j++){
const AVOption *opt;
double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
- if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
+ if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
av_set_double(enc, opt_names[j], d);
}
frame_height = enc->height;
for(i=0; i<opt_name_count; i++){
const AVOption *opt;
double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
- if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
+ if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
av_set_double(video_enc, opt_names[i], d);
}
for(i=0; i<opt_name_count; i++){
const AVOption *opt;
double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
- if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
+ if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
av_set_double(audio_enc, opt_names[i], d);
}
for(i=0; i<opt_name_count; i++){
const AVOption *opt;
double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
- if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
+ if(!isnan(d) && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
av_set_double(subtitle_enc, opt_names[i], d);
}
subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
for(i=0; i<opt_name_count; i++){
const AVOption *opt;
double d = av_get_double(avformat_opts, opt_names[i], &opt);
- if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
+ if(!isnan(d) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
av_set_double(oc, opt_names[i], d);
}
opt_vstats_file(filename);
}
-static void opt_video_bsf(const char *arg)
+static void opt_bsf(const char *opt, const char *arg)
{
AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
AVBitStreamFilterContext **bsfp;
exit(1);
}
- bsfp= &video_bitstream_filters;
+ bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;
while(*bsfp)
bsfp= &(*bsfp)->next;
*bsfp= bsfc;
}
-//FIXME avoid audio - video code duplication
-static void opt_audio_bsf(const char *arg)
+static void opt_show_license(void)
{
- AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
- AVBitStreamFilterContext **bsfp;
-
- if(!bsfc){
- fprintf(stderr, "Unknown bitstream filter %s\n", arg);
- exit(1);
- }
-
- bsfp= &audio_bitstream_filters;
- while(*bsfp)
- bsfp= &(*bsfp)->next;
-
- *bsfp= bsfc;
+ show_license();
+ exit(0);
}
static void opt_show_version(void)
{
- /* TODO: add function interface to avutil and avformat */
- fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
- "libavutil %d\n"
- "libavcodec %d\n"
- "libavformat %d\n",
- LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
+ show_version(program_name);
exit(0);
}
{ "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
{ "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
{ "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
- { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
+ { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
{ "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
{ "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
{ "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
{ "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
{ "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
{ "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
+ { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
/* video options */
+ { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
+ { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
{ "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
{ "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
{ "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
{ "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
/* audio options */
+ { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
{ "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_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" },
{ "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
{ "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
- { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
- { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
+ { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
+ { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
{ "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
{ NULL, },
};
-static void show_banner(void)
-{
- fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
- fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
- fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
- fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
- fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
- fprintf(stderr, " built on " __DATE__ " " __TIME__);
-#ifdef __GNUC__
- fprintf(stderr, ", gcc: " __VERSION__ "\n");
-#else
- fprintf(stderr, ", using a non-gcc compiler\n");
-#endif
-}
-
-static void opt_show_license(void)
-{
-#ifdef CONFIG_GPL
- printf(
- "FFmpeg is free software; you can redistribute it and/or modify\n"
- "it under the terms of the GNU General Public License as published by\n"
- "the Free Software Foundation; either version 2 of the License, or\n"
- "(at your option) any later version.\n"
- "\n"
- "FFmpeg is distributed in the hope that it will be useful,\n"
- "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
- "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
- "GNU General Public License for more details.\n"
- "\n"
- "You should have received a copy of the GNU General Public License\n"
- "along with FFmpeg; if not, write to the Free Software\n"
- "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
- );
-#else
- printf(
- "FFmpeg is free software; you can redistribute it and/or\n"
- "modify it under the terms of the GNU Lesser General Public\n"
- "License as published by the Free Software Foundation; either\n"
- "version 2.1 of the License, or (at your option) any later version.\n"
- "\n"
- "FFmpeg is distributed in the hope that it will be useful,\n"
- "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
- "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
- "Lesser General Public License for more details.\n"
- "\n"
- "You should have received a copy of the GNU Lesser General Public\n"
- "License along with FFmpeg; if not, write to the Free Software\n"
- "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
- );
-#endif
- exit(0);
-}
-
/**
* Trivial log callback.
* Only suitable for show_help and similar since it lacks prefix handling.
av_opt_show(sws_opts, NULL);
}
-int main(int argc, char **argv)
+static int av_exit()
{
int i;
- int64_t ti;
-
- av_register_all();
-
- for(i=0; i<CODEC_TYPE_NB; i++){
- avctx_opts[i]= avcodec_alloc_context2(i);
- }
- avformat_opts = av_alloc_format_context();
- sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
-
- show_banner();
- if (argc <= 1) {
- show_help();
- exit(1);
- }
-
- /* parse options */
- parse_options(argc, argv, options, opt_output_file);
-
- /* file converter / grab */
- if (nb_output_files <= 0) {
- fprintf(stderr, "Must supply at least one output file\n");
- exit(1);
- }
-
- if (nb_input_files == 0) {
- fprintf(stderr, "Must supply at least one input file\n");
- exit(1);
- }
-
- ti = getutime();
- av_encode(output_files, nb_output_files, input_files, nb_input_files,
- stream_maps, nb_stream_maps);
- ti = getutime() - ti;
- if (do_benchmark) {
- printf("bench: utime=%0.3fs\n", ti / 1000000.0);
- }
/* close files */
for(i=0;i<nb_output_files;i++) {
av_free(intra_matrix);
av_free(inter_matrix);
- if (fvstats)
- fclose(fvstats);
+ if (vstats_file)
+ fclose(vstats_file);
av_free(vstats_filename);
av_free(opt_names);
exit(0); /* not all OS-es handle main() return value */
return 0;
}
+
+int main(int argc, char **argv)
+{
+ int i;
+ int64_t ti;
+
+ av_register_all();
+
+ for(i=0; i<CODEC_TYPE_NB; i++){
+ avctx_opts[i]= avcodec_alloc_context2(i);
+ }
+ avformat_opts = av_alloc_format_context();
+ sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
+
+ show_banner(program_name, program_birth_year);
+ if (argc <= 1) {
+ show_help();
+ exit(1);
+ }
+
+ /* parse options */
+ parse_options(argc, argv, options, opt_output_file);
+
+ /* file converter / grab */
+ if (nb_output_files <= 0) {
+ fprintf(stderr, "Must supply at least one output file\n");
+ exit(1);
+ }
+
+ if (nb_input_files == 0) {
+ fprintf(stderr, "Must supply at least one input file\n");
+ exit(1);
+ }
+
+ ti = getutime();
+ av_encode(output_files, nb_output_files, input_files, nb_input_files,
+ stream_maps, nb_stream_maps);
+ ti = getutime() - ti;
+ if (do_benchmark) {
+ printf("bench: utime=%0.3fs\n", ti / 1000000.0);
+ }
+
+ return av_exit();
+}
projects / ffmpeg / blobdiff