#define INFINITY HUGE_VAL
#endif
-#define MAXINT64 int64_t_C(0x7fffffffffffffff)
-
/* select an input stream for an output stream */
typedef struct AVStreamMap {
int file_index;
extern const OptionDef options[];
-void show_help(void);
+static void show_help(void);
+static void show_license(void);
#define MAX_FILES 20
static int video_codec_id = CODEC_ID_NONE;
static int same_quality = 0;
static int b_frames = 0;
-static int use_hq = 0;
+static int mb_decision = FF_MB_DECISION_SIMPLE;
static int use_4mv = 0;
-/* Fx */
static int use_aic = 0;
static int use_umv = 0;
-/* /Fx */
static int do_deinterlace = 0;
static int workaround_bugs = FF_BUG_AUTODETECT;
static int error_resilience = 2;
static int packet_size = 0;
static int strict = 0;
static int debug = 0;
+extern int loop_input; /* currently a hack */
static int gop_size = 12;
static int intra_only = 0;
static char *audio_grab_format = "audio_device";
static char *audio_device = NULL;
+static int using_stdin = 0;
+
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
typedef struct AVOutputStream {
int64_t start; /* time when read started */
unsigned long frame; /* current frame */
+ AVFrac next_pts; /* synthetic pts for cases where pkt.pts == 0 */
+ int64_t pts; /* current pts */
} AVInputStream;
typedef struct AVInputFile {
but not for the general case */
if (audio_sync) {
/* compute the A-V delay and duplicate/remove frames if needed */
- double adelta, vdelta, apts, vpts, av_delay;
-
- if (audio_sync->sync_ipts != AV_NOPTS_VALUE &&
- ost->sync_ipts != AV_NOPTS_VALUE) {
-
- adelta = (double)(ost->st->pts.val - audio_sync->sync_opts) *
- s->pts_num / s->pts_den;
- apts = audio_sync->sync_ipts + adelta;
-
- vdelta = (double)(ost->st->pts.val - ost->sync_opts) *
- s->pts_num / s->pts_den;
- vpts = ost->sync_ipts + vdelta;
-
- av_delay = apts - vpts;
- // printf("delay=%f\n", av_delay);
- if (av_delay < -AV_DELAY_MAX)
- nb_frames = 2;
- else if (av_delay > AV_DELAY_MAX)
- nb_frames = 0;
- }
+ double adelta, vdelta, av_delay;
+
+ adelta = audio_sync->sync_ipts - ((double)audio_sync->sync_opts *
+ s->pts_num / s->pts_den);
+
+ vdelta = ost->sync_ipts - ((double)ost->sync_opts *
+ s->pts_num / s->pts_den);
+
+ av_delay = adelta - vdelta;
+ // printf("delay=%f\n", av_delay);
+ if (av_delay < -AV_DELAY_MAX)
+ nb_frames = 2;
+ else if (av_delay > AV_DELAY_MAX)
+ nb_frames = 0;
} else {
double vdelta;
- if (ost->sync_ipts != AV_NOPTS_VALUE) {
- vdelta = (double)(ost->st->pts.val) * s->pts_num / s->pts_den - (ost->sync_ipts - ost->sync_ipts_offset);
- if (vdelta < 100 && vdelta > -100 && ost->sync_ipts_offset) {
- if (vdelta < -AV_DELAY_MAX)
- nb_frames = 2;
- else if (vdelta > AV_DELAY_MAX)
- nb_frames = 0;
- } else {
- ost->sync_ipts_offset -= vdelta;
- if (!ost->sync_ipts_offset)
- ost->sync_ipts_offset = 0.000001; /* one microsecond */
- }
-
-#if defined(PJSG)
- {
- static char *action[] = { "drop frame", "copy frame", "dup frame" };
- printf("Input PTS %12.6f, output PTS %12.6f: %s\n",
- (double) ost->sync_ipts, (double) ost->st->pts.val * s->pts_num / s->pts_den,
- action[nb_frames]);
- }
-#endif
+ vdelta = (double)(ost->st->pts.val) * s->pts_num / s->pts_den - (ost->sync_ipts - ost->sync_ipts_offset);
+ if (vdelta < 100 && vdelta > -100 && ost->sync_ipts_offset) {
+ if (vdelta < -AV_DELAY_MAX)
+ nb_frames = 2;
+ else if (vdelta > AV_DELAY_MAX)
+ nb_frames = 0;
+ } else {
+ ost->sync_ipts_offset -= vdelta;
+ if (!ost->sync_ipts_offset)
+ ost->sync_ipts_offset = 0.000001; /* one microsecond */
}
}
+
+#if defined(AVSYNC_DEBUG)
+ static char *action[] = { "drop frame", "copy frame", "dup frame" };
+ if (audio_sync)
+ fprintf(stderr, "Input APTS %12.6f, output APTS %12.6f, ",
+ (double) audio_sync->sync_ipts,
+ (double) audio_sync->st->pts.val * s->pts_num / s->pts_den);
+ fprintf(stderr, "Input VPTS %12.6f, output VPTS %12.6f: %s\n",
+ (double) ost->sync_ipts,
+ (double) ost->st->pts.val * s->pts_num / s->pts_den,
+ action[nb_frames]);
+#endif
+
if (nb_frames <= 0)
return;
int nb_input_files,
AVStreamMap *stream_maps, int nb_stream_maps)
{
- int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, pts_set;
+ int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
AVFormatContext *is, *os;
AVCodecContext *codec, *icodec;
AVOutputStream *ost, **ost_table = NULL;
ost->resample = audio_resample_init(codec->channels, icodec->channels,
codec->sample_rate,
icodec->sample_rate);
+ if(!ost->resample)
+ {
+ printf("Can't resample. Aborting.\n");
+ av_abort();
+ }
}
/* Request specific number of channels */
icodec->channels = codec->channels;
ost->resample = audio_resample_init(codec->channels, icodec->channels,
codec->sample_rate,
icodec->sample_rate);
+ if(!ost->resample)
+ {
+ printf("Can't resample. Aborting.\n");
+ av_abort();
+ }
}
}
ist->decoding_needed = 1;
/* init pts */
for(i=0;i<nb_istreams;i++) {
ist = ist_table[i];
+ is = input_files[ist->file_index];
+ ist->pts = 0;
+ switch (ist->st->codec.codec_type) {
+ case CODEC_TYPE_AUDIO:
+ av_frac_init(&ist->next_pts,
+ 0, 0, is->pts_num * ist->st->codec.sample_rate);
+ break;
+ case CODEC_TYPE_VIDEO:
+ av_frac_init(&ist->next_pts,
+ 0, 0, is->pts_num * ist->st->codec.frame_rate);
+ break;
+ default:
+ break;
+ }
}
/* compute buffer size max (should use a complete heuristic) */
}
#ifndef CONFIG_WIN32
- fprintf(stderr, "Press [q] to stop encoding\n");
+ if ( !using_stdin )
+ fprintf(stderr, "Press [q] to stop encoding\n");
#endif
term_init();
stream_no_data = 0;
key = -1;
- for(;;) {
+ for(; received_sigterm == 0;) {
int file_index, ist_index;
AVPacket pkt;
uint8_t *ptr;
redo:
/* if 'q' pressed, exits */
- if (key) {
+ if (!using_stdin) {
/* read_key() returns 0 on EOF */
key = read_key();
if (key == 'q')
len = pkt.size;
ptr = pkt.data;
- pts_set = 0;
while (len > 0) {
- int64_t ipts;
-
- ipts = AV_NOPTS_VALUE;
-
/* decode the packet if needed */
data_buf = NULL; /* fail safe */
data_size = 0;
frame has begun (MPEG semantics) */
/* NOTE2: even if the fraction is not initialized,
av_frac_set can be used to set the integer part */
- if (ist->frame_decoded &&
- pkt.pts != AV_NOPTS_VALUE &&
- !pts_set) {
- ipts = pkt.pts;
+ if (ist->frame_decoded) {
+ /* If pts is unavailable -- we have to use synthetic one */
+ if( pkt.pts != AV_NOPTS_VALUE )
+ {
+ ist->pts = ist->next_pts.val = pkt.pts;
+ }
+ else
+ {
+ ist->pts = ist->next_pts.val;
+ }
ist->frame_decoded = 0;
- pts_set = 1;
}
switch(ist->st->codec.codec_type) {
continue;
}
data_buf = (uint8_t *)samples;
+ av_frac_add(&ist->next_pts,
+ is->pts_den * data_size / (2 * ist->st->codec.channels));
break;
case CODEC_TYPE_VIDEO:
{
len -= ret;
continue;
}
-
+ av_frac_add(&ist->next_pts,
+ is->pts_den * ist->st->codec.frame_rate_base);
}
break;
default:
if (ost->source_index == ist_index) {
os = output_files[ost->file_index];
- if (ipts != AV_NOPTS_VALUE) {
#if 0
- printf("%d: got pts=%f %f\n",
- i, pkt.pts / 90000.0,
- (ipts - ost->st->pts.val) / 90000.0);
+ printf("%d: got pts=%f %f\n", i, pkt.pts / 90000.0,
+ (ist->pts - ost->st->pts.val) / 90000.0);
#endif
- /* set the input output pts pairs */
- ost->sync_ipts = (double)ipts * is->pts_num /
- is->pts_den;
- /* XXX: take into account the various fifos,
- in particular for audio */
- ost->sync_opts = ost->st->pts.val;
- //printf("ipts=%lld sync_ipts=%f sync_opts=%lld pts.val=%lld pkt.pts=%lld\n", ipts, ost->sync_ipts, ost->sync_opts, ost->st->pts.val, pkt.pts);
- } else {
- //printf("pts.val=%lld\n", ost->st->pts.val);
- ost->sync_ipts = AV_NOPTS_VALUE;
- }
+ /* set the input output pts pairs */
+ ost->sync_ipts = (double)ist->pts * is->pts_num /
+ is->pts_den;
+ /* XXX: take into account the various fifos,
+ in particular for audio */
+ ost->sync_opts = ost->st->pts.val;
+ //printf("ipts=%lld sync_ipts=%f sync_opts=%lld pts.val=%lld pkt.pts=%lld\n", ist->pts, ost->sync_ipts, ost->sync_opts, ost->st->pts.val, pkt.pts);
if (ost->encoding_needed) {
switch(ost->st->codec.codec_type) {
}
}
av_free(buffer_to_free);
- ipts = AV_NOPTS_VALUE;
}
discard_packet:
av_free_packet(&pkt);
}
#endif
-static void show_licence(void)
-{
- printf(
- "ffmpeg version " FFMPEG_VERSION "\n"
- "Copyright (c) 2000, 2001, 2002 Fabrice Bellard\n"
- "This library 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 of the License, or (at your option) any later version.\n"
- "\n"
- "This library 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 this library; if not, write to the Free Software\n"
- "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
- );
- exit(1);
-}
-
static void opt_image_format(const char *arg)
{
AVImageFormat *f;
static void opt_frame_rate(const char *arg)
{
- frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME not optimal
- frame_rate = (int)(strtod(arg, 0) * frame_rate_base + 0.5);
- //FIXME parse fractions
+ if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
+ fprintf(stderr, "Incorrect frame rate\n");
+ exit(1);
+ }
}
-
static void opt_frame_crop_top(const char *arg)
{
frame_topBand = atoi(arg);
static void opt_frame_size(const char *arg)
{
- parse_image_size(&frame_width, &frame_height, arg);
- if (frame_width <= 0 || frame_height <= 0) {
+ if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
fprintf(stderr, "Incorrect frame size\n");
exit(1);
}
}
}
+static void opt_mb_decision(const char *arg)
+{
+ mb_decision = atoi(arg);
+}
+
static void opt_qscale(const char *arg)
{
video_qscale = atoi(arg);
if (!strcmp(filename, "-"))
filename = "pipe:";
+ using_stdin |= !strcmp(filename, "pipe:" ) ||
+ !strcmp( filename, "/dev/stdin" );
+
/* get default parameters from command line */
memset(ap, 0, sizeof(*ap));
ap->sample_rate = audio_sample_rate;
if(bitexact)
video_enc->flags |= CODEC_FLAG_BITEXACT;
- if (use_hq) {
- video_enc->flags |= CODEC_FLAG_HQ;
- }
- /* Fx */
+ video_enc->mb_decision = mb_decision;
+
if (use_umv) {
video_enc->flags |= CODEC_FLAG_H263P_UMV;
}
if (use_aic) {
video_enc->flags |= CODEC_FLAG_H263P_AIC;
}
- /* /Fx */
if (use_4mv) {
- video_enc->flags |= CODEC_FLAG_HQ;
+ video_enc->mb_decision = FF_MB_DECISION_BITS; //FIXME remove
video_enc->flags |= CODEC_FLAG_4MV;
}
if (url_exist(filename)) {
int c;
- printf("File '%s' already exists. Overwrite ? [y/N] ", filename);
- fflush(stdout);
- c = getchar();
- if (toupper(c) != 'Y') {
- fprintf(stderr, "Not overwriting - exiting\n");
+ if ( !using_stdin ) {
+ fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
+ fflush(stderr);
+ c = getchar();
+ if (toupper(c) != 'Y') {
+ fprintf(stderr, "Not overwriting - exiting\n");
+ exit(1);
+ }
+ }
+ else {
+ fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
exit(1);
- }
+ }
}
}
printf(" %s:", up->name);
printf("\n");
- printf("Frame size abbreviations: sqcif qcif cif 4cif\n");
+ printf("Frame size, frame rate abbreviations: ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
printf("Motion estimation methods:");
pp = motion_str;
while (*pp) {
}
const OptionDef options[] = {
- { "L", 0, {(void*)show_licence}, "show license" },
+ /* main options */
+ { "L", 0, {(void*)show_license}, "show license" },
{ "h", 0, {(void*)show_help}, "show help" },
{ "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
{ "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
{ "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
{ "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
{ "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
- { "pass", HAS_ARG, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
- { "passlogfile", HAS_ARG | OPT_STRING, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
- /* video options */
- { "b", HAS_ARG, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
- { "r", HAS_ARG, {(void*)opt_frame_rate}, "set frame rate (in Hz)", "rate" },
- { "re", OPT_BOOL|OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate" },
- { "s", HAS_ARG, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
- { "aspect", HAS_ARG, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
- { "pix_fmt", HAS_ARG | OPT_EXPERT, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
- { "croptop", HAS_ARG, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
- { "cropbottom", HAS_ARG, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
- { "cropleft", HAS_ARG, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
- { "cropright", HAS_ARG, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
- { "g", HAS_ARG | OPT_EXPERT, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
- { "intra", OPT_BOOL | OPT_EXPERT, {(void*)&intra_only}, "use only intra frames"},
- { "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" },
- { "qscale", HAS_ARG | OPT_EXPERT, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
- { "qmin", HAS_ARG | OPT_EXPERT, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
- { "qmax", HAS_ARG | OPT_EXPERT, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
- { "mbqmin", HAS_ARG | OPT_EXPERT, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
- { "mbqmax", HAS_ARG | OPT_EXPERT, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
- { "qdiff", HAS_ARG | OPT_EXPERT, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
- { "qblur", HAS_ARG | OPT_EXPERT, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
- { "qcomp", HAS_ARG | OPT_EXPERT, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
- { "rc_init_cplx", HAS_ARG | OPT_EXPERT, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
- { "b_qfactor", HAS_ARG | OPT_EXPERT, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
- { "i_qfactor", HAS_ARG | OPT_EXPERT, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
- { "b_qoffset", HAS_ARG | OPT_EXPERT, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
- { "i_qoffset", HAS_ARG | OPT_EXPERT, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
-// { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
- { "rc_eq", HAS_ARG | OPT_EXPERT, {(void*)opt_video_rc_eq}, "", "equation" },
- { "rc_override", HAS_ARG | OPT_EXPERT, {(void*)opt_video_rc_override_string}, "Rate control override", "qualities for specific intervals" },
- { "bt", HAS_ARG, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
- { "maxrate", HAS_ARG, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
- { "minrate", HAS_ARG, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
- { "bufsize", HAS_ARG, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kbit)", "size" },
- { "vd", HAS_ARG | OPT_EXPERT, {(void*)opt_video_device}, "set video grab device", "device" },
- { "vc", HAS_ARG | OPT_EXPERT, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
- { "tvstd", HAS_ARG | OPT_EXPERT, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
- { "dv1394", OPT_EXPERT, {(void*)opt_dv1394}, "set DV1394 grab", "" },
- { "vcodec", HAS_ARG | OPT_EXPERT, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
- { "me", HAS_ARG | OPT_EXPERT, {(void*)opt_motion_estimation}, "set motion estimation method",
- "method" },
- { "dct_algo", HAS_ARG | OPT_EXPERT, {(void*)opt_dct_algo}, "set dct algo", "algo" },
- { "idct_algo", HAS_ARG | OPT_EXPERT, {(void*)opt_idct_algo}, "set idct algo", "algo" },
- { "er", HAS_ARG | OPT_EXPERT, {(void*)opt_error_resilience}, "set error resilience", "" },
- { "ec", HAS_ARG | OPT_EXPERT, {(void*)opt_error_concealment}, "set error concealment", "" },
- { "bf", HAS_ARG | OPT_EXPERT, {(void*)opt_b_frames}, "use 'frames' B frames (only MPEG-4)", "frames" },
- { "hq", OPT_BOOL | OPT_EXPERT, {(void*)&use_hq}, "activate high quality settings" },
- { "4mv", OPT_BOOL | OPT_EXPERT, {(void*)&use_4mv}, "use four motion vector by macroblock (only MPEG-4)" },
- { "part", OPT_BOOL | OPT_EXPERT, {(void*)&use_part}, "use data partitioning (only MPEG-4)" },
- { "bug", HAS_ARG | OPT_EXPERT, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
- { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "packet size", "size in bits" },
- { "strict", HAS_ARG | OPT_EXPERT, {(void*)opt_strict}, "strictness", "how strictly to follow the standarts" },
- { "sameq", OPT_BOOL, {(void*)&same_quality},
- "use same video quality as source (implies VBR)" },
{ "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
- /* audio options */
- { "ab", HAS_ARG, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
- { "ar", HAS_ARG, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
- { "ac", HAS_ARG, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
- { "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" },
- { "ad", HAS_ARG | OPT_EXPERT, {(void*)opt_audio_device}, "set audio device", "device" },
- { "acodec", HAS_ARG | OPT_EXPERT, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
- { "deinterlace", OPT_BOOL | OPT_EXPERT, {(void*)&do_deinterlace},
- "deinterlace pictures" },
{ "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
"add timings for benchmarking" },
{ "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
"dump each input packet" },
- { "psnr", OPT_BOOL | OPT_EXPERT, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
- { "vstats", OPT_BOOL | OPT_EXPERT, {(void*)&do_vstats}, "dump video coding statistics to file" },
{ "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
- { "vhook", HAS_ARG | OPT_EXPERT, {(void*)add_frame_hooker}, "insert video processing module", "module name and parameters" },
- /* Fx */
- { "aic", OPT_BOOL | OPT_EXPERT, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
- { "umv", OPT_BOOL | OPT_EXPERT, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
- /* /Fx */
+ { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
+ { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
+
+ /* video options */
+ { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
+ { "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" },
+ { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
+ { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
+ { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
+ { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
+ { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
+ { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
+ { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
+ { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
+ { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
+ { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
+ { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
+ { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
+ { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
+ { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
+ { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
+ { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
+ { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
+ { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
+ { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
+ { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
+ { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
+ { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
+// { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
+ { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
+ { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
+ { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
+ { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
+ { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
+ { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kbit)", "size" },
+ { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
+ { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
+ "method" },
+ { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
+ { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
+ { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
+ { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
+ { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames (only MPEG-4)", "frames" },
+ { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
+ { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
+ { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (only MPEG-4)" },
+ { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (only MPEG-4)" },
+ { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
+ { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
+ { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standarts", "strictness" },
+ { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
+ "use same video quality as source (implies VBR)" },
+ { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
+ { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
+ { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
+ "deinterlace pictures" },
+ { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
+ { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
+ { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
+ { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
+ { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
+
+ /* audio options */
+ { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
+ { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
+ { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
+ { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
+ { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
+
+ /* grab options */
+ { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
+ { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
+ { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
+ { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
+ { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
{ NULL, },
};
-void show_help(void)
+static void show_banner(void)
+{
+ printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2003 Fabrice Bellard\n");
+}
+
+static void show_license(void)
+{
+ show_banner();
+ printf(
+ "This library 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 of the License, or (at your option) any later version.\n"
+ "\n"
+ "This library 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 this library; if not, write to the Free Software\n"
+ "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
+ );
+ exit(1);
+}
+
+static void show_help(void)
{
- printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000, 2001, 2002 Fabrice Bellard\n");
+ show_banner();
printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
"Hyper fast Audio and Video encoder\n");
printf("\n");
- show_help_options(options);
+ show_help_options(options, "Main options:\n",
+ OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
+ show_help_options(options, "\nVideo options:\n",
+ OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
+ OPT_VIDEO);
+ show_help_options(options, "\nAdvanced Video options:\n",
+ OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
+ OPT_VIDEO | OPT_EXPERT);
+ show_help_options(options, "\nAudio options:\n",
+ OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
+ OPT_AUDIO);
+ show_help_options(options, "\nAdvanced Audio options:\n",
+ OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
+ OPT_AUDIO | OPT_EXPERT);
+ show_help_options(options, "\nAudio/Video grab options:\n",
+ OPT_GRAB,
+ OPT_GRAB);
+ show_help_options(options, "\nAdvanced options:\n",
+ OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
+ OPT_EXPERT);
exit(1);
}
av_free_static();
-#ifdef POWERPC_TBL_PERFORMANCE_REPORT
+#ifdef POWERPC_PERFORMANCE_REPORT
extern void powerpc_display_perf_report(void);
powerpc_display_perf_report();
-#endif /* POWERPC_TBL_PERFORMANCE_REPORT */
+#endif /* POWERPC_PERFORMANCE_REPORT */
#ifndef CONFIG_WIN32
if (received_sigterm) {
projects / ffmpeg / blobdiff