static AVInputFormat *file_iformat;
static AVOutputFormat *file_oformat;
static AVImageFormat *image_format;
-static int frame_width = 160;
-static int frame_height = 128;
+static int frame_width = 0;
+static int frame_height = 0;
static float frame_aspect_ratio = 0;
static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
static int frame_padtop = 0;
static int frame_bottomBand = 0;
static int frame_leftBand = 0;
static int frame_rightBand = 0;
+static int max_frames[3] = {INT_MAX, INT_MAX, INT_MAX};
static int frame_rate = 25;
static int frame_rate_base = 1;
static int video_bit_rate = 200*1000;
static int video_qmax = 31;
static int video_lmin = 2*FF_QP2LAMBDA;
static int video_lmax = 31*FF_QP2LAMBDA;
-static int video_mb_qmin = 2;
-static int video_mb_qmax = 31;
+static int video_mb_lmin = 2*FF_QP2LAMBDA;
+static int video_mb_lmax = 31*FF_QP2LAMBDA;
static int video_qdiff = 3;
+static int video_lelim = 0;
+static int video_celim = 0;
static float video_qblur = 0.5;
+static float video_qsquish = 0.0;
static float video_qcomp = 0.5;
static uint16_t *intra_matrix = NULL;
static uint16_t *inter_matrix = NULL;
static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
static int me_method = ME_EPZS;
static int video_disable = 0;
+static int video_discard = 0;
static int video_codec_id = CODEC_ID_NONE;
static int video_codec_tag = 0;
static int same_quality = 0;
static int use_qpel = 0;
static int use_qprd = 0;
static int use_cbprd = 0;
+static int use_mv0 = 0;
+static int do_normalize_aqp = 0;
static int qns = 0;
static int closed_gop = 0;
static int strict_gop = 0;
+static int no_output = 0;
static int do_deinterlace = 0;
static int do_interlace_dct = 0;
static int do_interlace_me = 0;
static int nsse_weight = 8;
static int subpel_quality= 8;
static int lowres= 0;
+static int frame_skip_threshold= 0;
+static int frame_skip_factor= 0;
+static int frame_skip_exp= 0;
+static int frame_skip_cmp= FF_CMP_DCTMAX;
extern int loop_input; /* currently a hack */
static int gop_size = 12;
optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
(img->linesize[i] - (padright >> shift));
- for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
+ for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
memset(optr, color[i], (padleft + padright) >> shift);
optr += img->linesize[i];
}
}
- if (padbottom) {
- optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
- memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
+ if (padbottom || padright) {
+ optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
+ memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
}
}
}
+static int bit_buffer_size= 1024*256;
static uint8_t *bit_buffer= NULL;
static void do_video_out(AVFormatContext *s,
AVCodecContext *enc, *dec;
enum PixelFormat target_pixfmt;
-#define VIDEO_BUFFER_SIZE (1024*1024)
-
avcodec_get_frame_defaults(&picture_format_temp);
avcodec_get_frame_defaults(&picture_crop_temp);
}else
ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
+ nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
if (nb_frames <= 0)
return;
big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
ret = avcodec_encode_video(enc,
- bit_buffer, VIDEO_BUFFER_SIZE,
+ bit_buffer, bit_buffer_size,
&big_picture);
//enc->frame_number = enc->real_pict_num;
- if(ret){
+ if(ret>0){
pkt.data= bit_buffer;
pkt.size= ret;
if(enc->coded_frame)
if (!fvstats) {
today2 = time(NULL);
today = localtime(&today2);
- sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
+ snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
today->tm_min,
today->tm_sec);
fvstats = fopen(filename,"w");
os = output_files[ost->file_index];
enc = &ost->st->codec;
if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
- sprintf(buf + strlen(buf), "q=%2.1f ",
+ snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
enc->coded_frame->quality/(float)FF_QP2LAMBDA);
}
if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
frame_number = ost->frame_number;
- sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
+ snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%2.1f ",
frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
if(is_last_report)
- sprintf(buf + strlen(buf), "L");
+ snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
if (enc->flags&CODEC_FLAG_PSNR){
int j;
double error, error_sum=0;
double scale, scale_sum=0;
char type[3]= {'Y','U','V'};
- sprintf(buf + strlen(buf), "PSNR=");
+ snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
for(j=0; j<3; j++){
if(is_last_report){
error= enc->error[j];
if(j) scale/=4;
error_sum += error;
scale_sum += scale;
- sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
+ snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
}
- sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
+ snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
}
vid = 1;
}
if (verbose || is_last_report) {
bitrate = (double)(total_size * 8) / ti1 / 1000.0;
- sprintf(buf + strlen(buf),
+ snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
"size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
(double)total_size / 1024, ti1, bitrate);
if (verbose > 1)
- sprintf(buf + strlen(buf), " dup=%d drop=%d",
+ snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
nb_frames_dup, nb_frames_drop);
if (verbose >= 0)
} else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
ist->next_pts = ist->pts = pkt->dts;
} else {
- assert(ist->pts == ist->next_pts);
+// assert(ist->pts == ist->next_pts);
}
if (pkt == NULL) {
goto fail_decode;
}
} else {
+ switch(ist->st->codec.codec_type) {
+ case CODEC_TYPE_AUDIO:
+ ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec.frame_size) /
+ (ist->st->codec.sample_rate * ist->st->codec.channels);
+ break;
+ case CODEC_TYPE_VIDEO:
+ if (ist->st->codec.frame_rate_base != 0) {
+ ist->next_pts += ((int64_t)AV_TIME_BASE *
+ ist->st->codec.frame_rate_base) /
+ ist->st->codec.frame_rate;
+ }
+ break;
+ }
data_buf = ptr;
data_size = len;
ret = len;
switch(ost->st->codec.codec_type) {
case CODEC_TYPE_AUDIO:
- ret = avcodec_encode_audio(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
+ ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
audio_size += ret;
pkt.flags |= PKT_FLAG_KEY;
break;
case CODEC_TYPE_VIDEO:
- ret = avcodec_encode_video(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
+ ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
video_size += ret;
if(enc->coded_frame && enc->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
if (!file_table)
goto fail;
-
- if (!bit_buffer)
- bit_buffer = av_malloc(VIDEO_BUFFER_SIZE);
- if (!bit_buffer)
- goto fail;
/* input stream init */
j = 0;
codec->sample_rate = icodec->sample_rate;
codec->channels = icodec->channels;
codec->frame_size = icodec->frame_size;
+ codec->block_align= icodec->block_align;
break;
case CODEC_TYPE_VIDEO:
codec->frame_rate = icodec->frame_rate;
codec->frame_rate_base = icodec->frame_rate_base;
codec->width = icodec->width;
codec->height = icodec->height;
+ codec->has_b_frames = icodec->has_b_frames;
break;
default:
av_abort();
}
}
}
+ if(codec->codec_type == CODEC_TYPE_VIDEO){
+ int size= codec->width * codec->height;
+ bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
+ }
}
+ if (!bit_buffer)
+ bit_buffer = av_malloc(bit_buffer_size);
+ if (!bit_buffer)
+ goto fail;
+
/* dump the file output parameters - cannot be done before in case
of stream copy */
for(i=0;i<nb_output_files;i++) {
exit(1);
}
if (avcodec_open(&ost->st->codec, codec) < 0) {
- fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
+ fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
ost->file_index, ost->index);
exit(1);
}
ist->next_pts = ist->st->start_time;
if(ist->next_pts == AV_NOPTS_VALUE)
ist->next_pts=0;
+ if(input_files_ts_offset[ist->file_index])
+ ist->next_pts= AV_NOPTS_VALUE;
ist->is_start = 1;
}
if(!input_sync) file_index = ist->file_index;
}
}
+ if(ost->frame_number >= max_frames[ost->st->codec.codec_type]){
+ file_index= -1;
+ break;
+ }
}
/* if none, if is finished */
if (file_index < 0) {
goto discard_packet;
// fprintf(stderr, "next:%lld dts:%lld off:%lld %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) {
+ if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
int64_t delta= pkt.dts - ist->next_pts;
if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
input_files_ts_offset[ist->file_index]-= delta;
ret = 0;
fail1:
+ av_freep(&bit_buffer);
av_free(file_table);
if (ist_table) {
}
}
+static void opt_qsquish(const char *arg)
+{
+ video_qsquish = atof(arg);
+ if (video_qsquish < 0.0 ||
+ video_qsquish > 99.0) {
+ fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
+ exit(1);
+ }
+}
+
+static void opt_lelim(const char *arg)
+{
+ video_lelim = atoi(arg);
+ if (video_lelim < -99 ||
+ video_lelim > 99) {
+ fprintf(stderr, "lelim must be >= -99 and <= 99\n");
+ exit(1);
+ }
+}
+
+static void opt_celim(const char *arg)
+{
+ video_celim = atoi(arg);
+ if (video_celim < -99 ||
+ video_celim > 99) {
+ fprintf(stderr, "celim must be >= -99 and <= 99\n");
+ exit(1);
+ }
+}
+
static void opt_lmax(const char *arg)
{
video_lmax = atof(arg)*FF_QP2LAMBDA;
static void opt_qmin(const char *arg)
{
video_qmin = atoi(arg);
- if (video_qmin < 0 ||
+ if (video_qmin < 1 ||
video_qmin > 31) {
fprintf(stderr, "qmin must be >= 1 and <= 31\n");
exit(1);
static void opt_qmax(const char *arg)
{
video_qmax = atoi(arg);
- if (video_qmax < 0 ||
+ if (video_qmax < 1 ||
video_qmax > 31) {
fprintf(stderr, "qmax must be >= 1 and <= 31\n");
exit(1);
}
}
-static void opt_mb_qmin(const char *arg)
+static void opt_mb_lmin(const char *arg)
{
- video_mb_qmin = atoi(arg);
- if (video_mb_qmin < 0 ||
- video_mb_qmin > 31) {
- fprintf(stderr, "qmin must be >= 1 and <= 31\n");
+ video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
+ if (video_mb_lmin < 1 ||
+ video_mb_lmin > FF_LAMBDA_MAX) {
+ fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
exit(1);
}
}
-static void opt_mb_qmax(const char *arg)
+static void opt_mb_lmax(const char *arg)
{
- video_mb_qmax = atoi(arg);
- if (video_mb_qmax < 0 ||
- video_mb_qmax > 31) {
- fprintf(stderr, "qmax must be >= 1 and <= 31\n");
+ video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
+ if (video_mb_lmax < 1 ||
+ video_mb_lmax > FF_LAMBDA_MAX) {
+ fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
exit(1);
}
}
static void opt_thread_count(const char *arg)
{
thread_count= atoi(arg);
-#if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
+#if !defined(HAVE_THREADS)
if (verbose >= 0)
fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
#endif
/* update the current parameters so that they match the one of the input stream */
for(i=0;i<ic->nb_streams;i++) {
AVCodecContext *enc = &ic->streams[i]->codec;
-#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
+#if defined(HAVE_THREADS)
if(thread_count>1)
avcodec_thread_init(enc, thread_count);
#endif
//fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
audio_channels = enc->channels;
audio_sample_rate = enc->sample_rate;
+ if(audio_disable)
+ ic->streams[i]->discard= AVDISCARD_ALL;
break;
case CODEC_TYPE_VIDEO:
frame_height = enc->height;
if(me_threshold)
enc->debug |= FF_DEBUG_MV;
- assert(enc->frame_rate_base == rfps_base); // should be true for now
- if (enc->frame_rate != rfps) {
+ if (enc->frame_rate != rfps || enc->frame_rate_base != rfps_base) {
if (verbose >= 0)
- fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
- i, (float)enc->frame_rate / enc->frame_rate_base,
+ fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
+ i, (float)enc->frame_rate / enc->frame_rate_base, enc->frame_rate, enc->frame_rate_base,
- (float)rfps / rfps_base);
+ (float)rfps / rfps_base, rfps, rfps_base);
}
/* update the current frame rate to match the stream frame rate */
frame_rate = rfps;
frame_rate_base = rfps_base;
enc->rate_emu = rate_emu;
+ if(video_disable)
+ ic->streams[i]->discard= AVDISCARD_ALL;
+ else if(video_discard)
+ ic->streams[i]->discard= video_discard;
break;
case CODEC_TYPE_DATA:
break;
fprintf(stderr, "Could not alloc stream\n");
exit(1);
}
-#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
+#if defined(HAVE_THREADS)
if(thread_count>1)
avcodec_thread_init(&st->codec, thread_count);
#endif
video_enc->gop_size = 0;
if (video_qscale || same_quality) {
video_enc->flags |= CODEC_FLAG_QSCALE;
+ video_enc->global_quality=
st->quality = FF_QP2LAMBDA * video_qscale;
}
}
if (use_trell) {
video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
+ }
+ if (use_mv0) {
+ video_enc->flags |= CODEC_FLAG_MV0;
+ }
+ if (do_normalize_aqp) {
+ video_enc->flags |= CODEC_FLAG_NORMALIZE_AQP;
}
if (use_scan_offset) {
video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
if (do_interlace_me) {
video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
}
+ if (no_output) {
+ video_enc->flags2 |= CODEC_FLAG2_NO_OUTPUT;
+ }
video_enc->qmin = video_qmin;
video_enc->qmax = video_qmax;
video_enc->lmin = video_lmin;
video_enc->lmax = video_lmax;
- video_enc->mb_qmin = video_mb_qmin;
- video_enc->mb_qmax = video_mb_qmax;
+ video_enc->rc_qsquish = video_qsquish;
+ video_enc->luma_elim_threshold = video_lelim;
+ video_enc->chroma_elim_threshold = video_celim;
+ video_enc->mb_lmin = video_mb_lmin;
+ video_enc->mb_lmax = video_mb_lmax;
video_enc->max_qdiff = video_qdiff;
video_enc->qblur = video_qblur;
video_enc->qcompress = video_qcomp;
video_enc->level= video_level;
video_enc->nsse_weight= nsse_weight;
video_enc->me_subpel_quality= subpel_quality;
+ video_enc->frame_skip_threshold= frame_skip_threshold;
+ video_enc->frame_skip_factor= frame_skip_factor;
+ video_enc->frame_skip_exp= frame_skip_exp;
+ video_enc->frame_skip_cmp= frame_skip_cmp;
if(packet_size){
video_enc->rtp_mode= 1;
fprintf(stderr, "Could not alloc stream\n");
exit(1);
}
-#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
+#if defined(HAVE_THREADS)
if(thread_count>1)
avcodec_thread_init(&st->codec, thread_count);
#endif
output_files[nb_output_files++] = oc;
- strcpy(oc->filename, filename);
+ pstrcpy(oc->filename, sizeof(oc->filename), filename);
/* check filename in case of an image number is expected */
if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
static void opt_target(const char *arg)
{
int norm = -1;
+ static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
if(!strncmp(arg, "pal-", 4)) {
norm = 0;
} else if(!strncmp(arg, "ntsc-", 5)) {
norm = 1;
arg += 5;
+ } else if(!strncmp(arg, "film-", 5)) {
+ norm = 2;
+ arg += 5;
} else {
int fr;
/* Calculate FR via float to avoid int overflow */
}
}
if(verbose && norm >= 0)
- printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
+ fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
}
if(norm < 0) {
- fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
- fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
+ 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");
exit(1);
}
opt_format("vcd");
opt_frame_size(norm ? "352x240" : "352x288");
+ opt_frame_rate(frame_rates[norm]);
+ opt_gop_size(norm ? "18" : "15");
video_bit_rate = 1150000;
video_rc_max_rate = 1150000;
opt_format("svcd");
opt_frame_size(norm ? "480x480" : "480x576");
+ opt_frame_rate(frame_rates[norm]);
opt_gop_size(norm ? "18" : "15");
video_bit_rate = 2040000;
opt_format("dvd");
opt_frame_size(norm ? "720x480" : "720x576");
+ opt_frame_rate(frame_rates[norm]);
opt_gop_size(norm ? "18" : "15");
video_bit_rate = 6000000;
video_rc_min_rate = 0; //1500000;
video_rc_buffer_size = 224*1024*8;
+ mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
+ mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
+
audio_bit_rate = 448000;
audio_sample_rate = 48000;
+ } else if(!strcmp(arg, "dv")) {
+
+ opt_format("dv");
+
+ opt_frame_size(norm ? "720x480" : "720x576");
+ opt_frame_rate(frame_rates[norm]);
+
+ audio_sample_rate = 48000;
+ audio_channels = 2;
+
} else {
fprintf(stderr, "Unknown target: %s\n", arg);
exit(1);
static void show_version(void)
{
- printf("ffmpeg " FFMPEG_VERSION "\n"
+ fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
"libavcodec %d\n"
"libavformat %d\n",
avcodec_build(), LIBAVFORMAT_BUILD);
{ "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)" },
{ "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
- { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
+ { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
{ "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
{ "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
{ "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
/* video options */
{ "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
+ { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
+ { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio 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" },
{ "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" },
{ "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" },
+ { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
{ "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" },
{ "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
{ "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
- { "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" },
+ { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
+ { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "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" },
+ { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
{ "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" },
{ "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
{ "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
{ "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
+ { "lelim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lelim}, "single coefficient elimination threshold for luminance (negative values also consider DC coefficient)", "elim" },
+ { "celim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_celim}, "single coefficient elimination threshold for chrominance (negative values also consider DC coefficient)", "elim" },
{ "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
{ "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
{ "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
{ "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
{ "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
{ "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
+ { "mv0", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_mv0}, "try to encode each MB with MV=<0,0> and choose the better one (has no effect if mbd=0)" },
+ { "naq", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_normalize_aqp}, "normalize adaptive quantization" },
{ "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
{ "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
+ { "noout", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&no_output}, "skip bitstream encoding" },
{ "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
{ "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
{ "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
{ "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
{ "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
{ "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
+ { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
+ { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
+ { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
+ { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
/* audio options */
{ "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
static void show_banner(void)
{
- printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
+ fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
LIBAVCODEC_BUILD);
- printf(" configuration: %s\n", FFMPEG_CONFIGURATION);
- printf(" built on " __DATE__ " " __TIME__);
+ fprintf(stderr, " configuration: %s\n", FFMPEG_CONFIGURATION);
+ fprintf(stderr, " built on " __DATE__ " " __TIME__);
#ifdef __GNUC__
- printf(", gcc: %s\n", __VERSION__);
+ fprintf(stderr, ", gcc: %s\n", __VERSION__);
#else
- printf(", using a non-gcc compiler\n");
+ fprintf(stderr, ", using a non-gcc compiler\n");
#endif
}