extern const OptionDef options[];
static void show_help(void);
-static void show_license(void);
+static void opt_show_license(void);
static int opt_default(const char *opt, const char *arg);
#define MAX_FILES 20
static char *video_rc_eq="tex^qComp";
static int video_disable = 0;
static int video_discard = 0;
-static int video_codec_id = CODEC_ID_NONE;
+static char *video_codec_name = NULL;
static int video_codec_tag = 0;
static int same_quality = 0;
static int do_deinterlace = 0;
static float audio_qscale = QSCALE_NONE;
static int audio_disable = 0;
static int audio_channels = 1;
-static int audio_codec_id = CODEC_ID_NONE;
+static char *audio_codec_name = NULL;
static int audio_codec_tag = 0;
static char *audio_language = NULL;
static int subtitle_disable = 0;
-static int subtitle_codec_id = CODEC_ID_NONE;
+static char *subtitle_codec_name = NULL;
static char *subtitle_language = NULL;
static float mux_preload= 0.5;
static int opt_shortest = 0; //
static int video_global_header = 0;
static char *vstats_filename;
-static FILE *fvstats;
+static FILE *vstats_file;
static int rate_emu = 0;
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);
+}
/*
* 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)
is = input_files[ist->file_index];
ist->pts = 0;
ist->next_pts=0;
- if(input_files_ts_offset[ist->file_index] != -is->start_time)
+ if( input_files_ts_offset[ist->file_index] != -is->start_time
+ && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
ist->next_pts= AV_NOPTS_VALUE;
ist->is_start = 1;
}
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) {
// fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
- int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
- if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
+ int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
+ int64_t delta= pkt_dts - ist->next_pts;
+ if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
input_files_ts_offset[ist->file_index]-= delta;
if (verbose > 2)
fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
video_standard = av_strdup(arg);
}
-static void opt_codec(int *pstream_copy, int *pcodec_id,
+static void opt_codec(int *pstream_copy, char **pcodec_name,
int codec_type, const char *arg)
{
- AVCodec *p;
-
+ av_freep(pcodec_name);
if (!strcmp(arg, "copy")) {
*pstream_copy = 1;
} else {
- p = first_avcodec;
- while (p) {
- if (!strcmp(p->name, arg) && p->type == codec_type)
- break;
- p = p->next;
- }
- if (p == NULL) {
- fprintf(stderr, "Unknown codec '%s'\n", arg);
- exit(1);
- } else {
- *pcodec_id = p->id;
- }
+ *pcodec_name = av_strdup(arg);
}
}
static void opt_audio_codec(const char *arg)
{
- opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
+ opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
}
static void opt_audio_tag(const char *arg)
static void opt_video_codec(const char *arg)
{
- opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
+ opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
}
static void opt_subtitle_codec(const char *arg)
{
- opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
+ opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
}
static void opt_map(const char *arg)
input_ts_offset = parse_date(arg, 1);
}
+static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
+{
+ char *codec_string = encoder ? "encoder" : "decoder";
+ AVCodec *codec;
+
+ if(!name)
+ return CODEC_ID_NONE;
+ codec = encoder ?
+ avcodec_find_encoder_by_name(name) :
+ avcodec_find_decoder_by_name(name);
+ if(!codec) {
+ av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
+ exit(1);
+ }
+ if(codec->type != type) {
+ av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
+ exit(1);
+ }
+ return codec->id;
+}
+
static void opt_input_file(const char *filename)
{
AVFormatContext *ic;
ap->pix_fmt = frame_pix_fmt;
ap->channel = video_channel;
ap->standard = video_standard;
- ap->video_codec_id = video_codec_id;
- ap->audio_codec_id = audio_codec_id;
+ ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
+ ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
if(pgmyuv_compatibility_hack)
ap->video_codec_id= CODEC_ID_PGMYUV;
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 */
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;
AVCodec *codec;
codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
- if (video_codec_id != CODEC_ID_NONE)
- codec_id = video_codec_id;
+ if (video_codec_name)
+ codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
video_enc->codec_id = codec_id;
codec = avcodec_find_encoder(codec_id);
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);
}
/* reset some key parameters */
video_disable = 0;
- video_codec_id = CODEC_ID_NONE;
+ av_freep(&video_codec_name);
video_stream_copy = 0;
}
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);
}
- if (audio_codec_id != CODEC_ID_NONE)
- codec_id = audio_codec_id;
+ if (audio_codec_name)
+ codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
audio_enc->codec_id = codec_id;
if (audio_qscale > QSCALE_NONE) {
/* reset some key parameters */
audio_disable = 0;
- audio_codec_id = CODEC_ID_NONE;
+ av_freep(&audio_codec_name);
audio_stream_copy = 0;
}
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 = subtitle_codec_id;
+ subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
}
if (subtitle_language) {
}
subtitle_disable = 0;
- subtitle_codec_id = CODEC_ID_NONE;
+ av_freep(&subtitle_codec_name);
subtitle_stream_copy = 0;
}
exit(1);
}
} else {
- use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
- use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
- use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_id != CODEC_ID_NONE;
+ use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
+ use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
+ use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
/* disable if no corresponding type found and at least one
input file */
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);
}
extern int ffm_nopts;
#endif
-static void show_formats(void)
+static void opt_show_formats(void)
{
AVInputFormat *ifmt;
AVOutputFormat *ofmt;
"even though both encoding and decoding are supported. For example, the h263\n"
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
"worse.\n");
- exit(1);
+ exit(0);
}
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
parse_matrix_coeffs(intra_matrix, arg);
}
+static void opt_show_help(void)
+{
+ show_help();
+ exit(0);
+}
+
static void opt_target(const char *arg)
{
int norm = -1;
*bsfp= bsfc;
}
-static void show_version(void)
+static void opt_show_version(void)
{
/* TODO: add function interface to avutil and avformat */
fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
"libavcodec %d\n"
"libavformat %d\n",
LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
- exit(1);
+ exit(0);
}
static int opt_default(const char *opt, const char *arg){
const OptionDef options[] = {
/* main options */
- { "L", 0, {(void*)show_license}, "show license" },
- { "h", 0, {(void*)show_help}, "show help" },
- { "version", 0, {(void*)show_version}, "show version" },
- { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
+ { "L", 0, {(void*)opt_show_license}, "show license" },
+ { "h", 0, {(void*)opt_show_help}, "show help" },
+ { "version", 0, {(void*)opt_show_version}, "show version" },
+ { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
{ "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
{ "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
{ "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" },
#endif
}
-static void show_license(void)
+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(1);
+ show_license();
+ exit(0);
}
/**
av_opt_show(avctx_opts[0], NULL);
av_opt_show(avformat_opts, NULL);
av_opt_show(sws_opts, NULL);
-
- exit(1);
-}
-
-void parse_arg_file(const char *filename)
-{
- opt_output_file(filename);
}
int main(int argc, char **argv)
sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
show_banner();
- if (argc <= 1)
+ if (argc <= 1) {
show_help();
+ exit(1);
+ }
/* parse options */
- parse_options(argc, argv, options);
+ parse_options(argc, argv, options, opt_output_file);
/* file converter / grab */
if (nb_output_files <= 0) {
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);
+ av_free(video_codec_name);
+ av_free(audio_codec_name);
+ av_free(subtitle_codec_name);
+
av_free(video_standard);
#ifdef CONFIG_POWERPC_PERF
projects / ffmpeg / blobdiff