Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge commit '62dcdb028cc84845fd263bb09304c4c6500bda7a'

Browse Source 
* commit '62dcdb028cc84845fd263bb09304c4c6500bda7a':
  vf_blackframe: switch to an AVOptions-based system.
  vf_aspect: switch to an AVOptions-based system.

Conflicts:
	doc/filters.texi
	libavfilter/vf_aspect.c
	libavfilter/vf_blackframe.c

In the aspect filter most changes are merged but not the final
switch to the libav API because that is too restrictive and has
difficulty handling the syntax.

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/21/head
Michael Niedermayer 12 years ago
parent 2a2a643c90 62dcdb028c
commit 43bac121d3
4 changed files with 90 additions and 96 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      doc/filters.texi
  2. 1
      libavfilter/avfilter.c
  3. 121
      libavfilter/vf_aspect.c
  4. 42
      libavfilter/vf_blackframe.c

22
doc/filters.texi
Unescape View File

@ -1874,16 +1874,17 @@ pairs, separated by ":". If the key of the first options is omitted,
the arguments are interpreted according to the syntax
blackframe[=@var{amount}[:@var{threshold}]].
A description of the accepted options follows.
The filter accepts the following options:
@table @option
@item amount
Set the percentage of pixels that have to be below the
threshold to enable black detection. Default value is 98.
The percentage of the pixels that have to be below the threshold, defaults to
98.
@item threshold
Set the threshold below which a pixel value is considered
black. Default value is 32.
Threshold below which a pixel value is considered black, defaults to 32.
@end table
@section blend
@ -5040,7 +5041,7 @@ Set the maximum integer value to use for expressing numerator and
denominator when reducing the expressed aspect ratio to a rational.
Default value is @code{100}.
@item r, ratio:
@item r, ratio, dar, sar:
Set the aspect ratio used by the filter.
The parameter can be a floating point number string, an expression, or
@ -5057,16 +5058,17 @@ are assumed to be @var{ratio} and @var{max} in that order.
For example to change the display aspect ratio to 16:9, specify:
@example
setdar='16:9'
@end example
The example above is equivalent to:
@example
# the above is equivalent to
setdar=1.77777
setdar=dar=16/9
setdar=dar=1.77777
@end example
To change the sample aspect ratio to 10:11, specify:
@example
setsar='10:11'
# the above is equivalent to
setsar='sar=10/11'
@end example
To set a display aspect ratio of 16:9, and specify a maximum integer value of

1
libavfilter/avfilter.c
Unescape View File

@ -655,6 +655,7 @@ int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque
int ret=0;
int anton_options =
!strcmp(filter->filter->name, "aformat") ||
!strcmp(filter->filter->name, "blackframe") ||
!strcmp(filter->filter->name, "format") ||
!strcmp(filter->filter->name, "noformat") ||
!strcmp(filter->filter->name, "resample")

121
libavfilter/vf_aspect.c
Unescape View File

@ -23,105 +23,103 @@
* aspect ratio modification video filters
*/
#include <float.h>
#include "libavutil/common.h"
#include "libavutil/opt.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "libavutil/parseutils.h"
#include "avfilter.h"
#include "internal.h"
#include "video.h"
typedef struct {
const AVClass *class;
AVRational ratio;
AVRational aspect;
char *ratio_str;
int max;
#if FF_API_OLD_FILTER_OPTS
float aspect_num, aspect_den;
#endif
} AspectContext;
#define OFFSET(x) offsetof(AspectContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
static const AVOption options[] = {
{"max", "set max value for nominator or denominator in the ratio", OFFSET(max), AV_OPT_TYPE_INT, {.i64=100}, 1, INT_MAX, FLAGS },
{"ratio", "set ratio", OFFSET(ratio_str), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, FLAGS },
{"r", "set ratio", OFFSET(ratio_str), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, FLAGS },
{NULL}
};
static av_cold int init(AVFilterContext *ctx, const char *args, const AVClass *class)
#if FF_API_OLD_FILTER_OPTS
static av_cold int init(AVFilterContext *ctx, const char *args)
{
AspectContext *aspect = ctx->priv;
AspectContext *s = ctx->priv;
static const char *shorthand[] = { "ratio", "max", NULL };
char c;
int ret;
AVRational q;
aspect->class = class;
av_opt_set_defaults(aspect);
if (args && sscanf(args, "%d:%d%c", &q.num, &q.den, &c) == 2) {
aspect->ratio_str = av_strdup(args);
s->ratio_str = av_strdup(args);
av_log(ctx, AV_LOG_WARNING,
"num:den syntax is deprecated, please use num/den or named options instead\n");
} else if ((ret = av_opt_set_from_string(aspect, args, shorthand, "=", ":")) < 0) {
} else if ((ret = av_opt_set_from_string(s, args, shorthand, "=", ":")) < 0) {
return ret;
}
if (aspect->ratio_str) {
ret = av_parse_ratio(&aspect->ratio, aspect->ratio_str, aspect->max, 0, ctx);
if (ret < 0 || aspect->ratio.num < 0 || aspect->ratio.den <= 0) {
if (s->ratio_str) {
ret = av_parse_ratio(&s->aspect, s->ratio_str, s->max, 0, ctx);
if (ret < 0 || s->aspect.num < 0 || s->aspect.den <= 0) {
av_log(ctx, AV_LOG_ERROR,
"Invalid string '%s' for aspect ratio\n", args);
return AVERROR(EINVAL);
}
}
av_log(ctx, AV_LOG_VERBOSE, "a:%d/%d\n", aspect->ratio.num, aspect->ratio.den);
return 0;
}
#endif
static int filter_frame(AVFilterLink *link, AVFrame *frame)
{
AspectContext *aspect = link->dst->priv;
frame->sample_aspect_ratio = aspect->ratio;
frame->sample_aspect_ratio = aspect->aspect;
return ff_filter_frame(link->dst->outputs[0], frame);
}
static av_cold void uninit(AVFilterContext *ctx)
{
AspectContext *aspect = ctx->priv;
av_opt_free(aspect);
}
#define OFFSET(x) offsetof(AspectContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
#if CONFIG_SETDAR_FILTER
#define setdar_options options
AVFILTER_DEFINE_CLASS(setdar);
static av_cold int setdar_init(AVFilterContext *ctx, const char *args)
{
return init(ctx, args, &setdar_class);
}
static int setdar_config_props(AVFilterLink *inlink)
{
AspectContext *aspect = inlink->dst->priv;
AVRational dar = aspect->ratio;
av_reduce(&aspect->ratio.num, &aspect->ratio.den,
aspect->ratio.num * inlink->h,
aspect->ratio.den * inlink->w, 100);
AVRational dar = aspect->aspect;
if (aspect->aspect.num && aspect->aspect.den) {
av_reduce(&aspect->aspect.num, &aspect->aspect.den,
aspect->aspect.num * inlink->h,
aspect->aspect.den * inlink->w, 100);
inlink->sample_aspect_ratio = aspect->aspect;
} else {
inlink->sample_aspect_ratio = (AVRational){ 1, 1 };
dar = (AVRational){ inlink->w, inlink->h };
}
av_log(inlink->dst, AV_LOG_VERBOSE, "w:%d h:%d -> dar:%d/%d sar:%d/%d\n",
inlink->w, inlink->h, dar.num, dar.den, aspect->ratio.num, aspect->ratio.den);
inlink->sample_aspect_ratio = aspect->ratio;
inlink->w, inlink->h, dar.num, dar.den,
inlink->sample_aspect_ratio.num, inlink->sample_aspect_ratio.den);
return 0;
}
static const AVOption setdar_options[] = {
{"max", "set max value for nominator or denominator in the ratio", OFFSET(max), AV_OPT_TYPE_INT, {.i64=100}, 1, INT_MAX, FLAGS },
{"ratio", "display aspect ratio", OFFSET(ratio_str), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, FLAGS },
{"r", "display aspect ratio", OFFSET(ratio_str), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, FLAGS },
{"dar", "display aspect ratio", OFFSET(ratio_str), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, FLAGS },
{NULL}
};
AVFILTER_DEFINE_CLASS(setdar);
static const AVFilterPad avfilter_vf_setdar_inputs[] = {
{
.name = "default",
@ -145,38 +143,42 @@ AVFilter avfilter_vf_setdar = {
.name = "setdar",
.description = NULL_IF_CONFIG_SMALL("Set the frame display aspect ratio."),
.init = setdar_init,
.uninit = uninit,
#if FF_API_OLD_FILTER_OPTS
.init = init,
#endif
.priv_size = sizeof(AspectContext),
.priv_class = &setdar_class,
.inputs = avfilter_vf_setdar_inputs,
.outputs = avfilter_vf_setdar_outputs,
.priv_class = &setdar_class,
};
#endif /* CONFIG_SETDAR_FILTER */
#if CONFIG_SETSAR_FILTER
#define setsar_options options
AVFILTER_DEFINE_CLASS(setsar);
static av_cold int setsar_init(AVFilterContext *ctx, const char *args)
{
return init(ctx, args, &setsar_class);
}
static int setsar_config_props(AVFilterLink *inlink)
{
AspectContext *aspect = inlink->dst->priv;
inlink->sample_aspect_ratio = aspect->ratio;
inlink->sample_aspect_ratio = aspect->aspect;
return 0;
}
static const AVOption setsar_options[] = {
{"max", "set max value for nominator or denominator in the ratio", OFFSET(max), AV_OPT_TYPE_INT, {.i64=100}, 1, INT_MAX, FLAGS },
{"ratio", "sample (pixel) aspect ratio", OFFSET(ratio_str), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, FLAGS },
{"r", "sample (pixel) aspect ratio", OFFSET(ratio_str), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, FLAGS },
{"sar", "sample (pixel) aspect ratio", OFFSET(ratio_str), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, FLAGS },
{NULL}
};
AVFILTER_DEFINE_CLASS(setsar);
static const AVFilterPad avfilter_vf_setsar_inputs[] = {
{
.name = "default",
@ -200,15 +202,16 @@ AVFilter avfilter_vf_setsar = {
.name = "setsar",
.description = NULL_IF_CONFIG_SMALL("Set the pixel sample aspect ratio."),
.init = setsar_init,
.uninit = uninit,
#if FF_API_OLD_FILTER_OPTS
.init = init,
#endif
.priv_size = sizeof(AspectContext),
.priv_class = &setsar_class,
.inputs = avfilter_vf_setsar_inputs,
.outputs = avfilter_vf_setsar_outputs,
.priv_class = &setsar_class,
};
#endif /* CONFIG_SETSAR_FILTER */

42
libavfilter/vf_blackframe.c
Unescape View File

@ -40,24 +40,13 @@
typedef struct {
const AVClass *class;
unsigned int bamount; ///< black amount
unsigned int bthresh; ///< black threshold
int bamount; ///< black amount
int bthresh; ///< black threshold
unsigned int frame; ///< frame number
unsigned int nblack; ///< number of black pixels counted so far
unsigned int last_keyframe; ///< frame number of the last received key-frame
} BlackFrameContext;
#define OFFSET(x) offsetof(BlackFrameContext, x)
#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
static const AVOption blackframe_options[] = {
{ "amount", "set least percentual amount of pixels below the black threshold enabling black detection", OFFSET(bamount), AV_OPT_TYPE_INT, {.i64=98}, 0, 100, FLAGS },
{ "thresh", "set threshold below which a pixel value is considered black", OFFSET(bthresh), AV_OPT_TYPE_INT, {.i64=32}, 0, 255, FLAGS },
{ NULL }
};
AVFILTER_DEFINE_CLASS(blackframe);
static int query_formats(AVFilterContext *ctx)
{
static const enum AVPixelFormat pix_fmts[] = {
@ -70,16 +59,6 @@ static int query_formats(AVFilterContext *ctx)
return 0;
}
static av_cold int init(AVFilterContext *ctx, const char *args)
{
BlackFrameContext *blackframe = ctx->priv;
av_log(ctx, AV_LOG_VERBOSE, "bamount:%u bthresh:%u\n",
blackframe->bamount, blackframe->bthresh);
return 0;
}
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
{
AVFilterContext *ctx = inlink->dst;
@ -110,6 +89,18 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
return ff_filter_frame(inlink->dst->outputs[0], frame);
}
#define OFFSET(x) offsetof(BlackFrameContext, x)
#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
static const AVOption blackframe_options[] = {
{ "amount", "Percentage of the pixels that have to be below the threshold "
"for the frame to be considered black.", OFFSET(bamount), AV_OPT_TYPE_INT, { .i64 = 98 }, 0, 100, FLAGS },
{ "threshold", "threshold below which a pixel value is considered black",
OFFSET(bthresh), AV_OPT_TYPE_INT, { .i64 = 32 }, 0, 255, FLAGS },
{ NULL },
};
AVFILTER_DEFINE_CLASS(blackframe);
static const AVFilterPad avfilter_vf_blackframe_inputs[] = {
{
.name = "default",
@ -128,14 +119,12 @@ static const AVFilterPad avfilter_vf_blackframe_outputs[] = {
{ NULL }
};
static const char *const shorthand[] = { "amount", "thresh", NULL };
AVFilter avfilter_vf_blackframe = {
.name = "blackframe",
.description = NULL_IF_CONFIG_SMALL("Detect frames that are (almost) black."),
.priv_size = sizeof(BlackFrameContext),
.init = init,
.priv_class = &blackframe_class,
.query_formats = query_formats,
@ -144,5 +133,4 @@ AVFilter avfilter_vf_blackframe = {
.outputs = avfilter_vf_blackframe_outputs,
.priv_class = &blackframe_class,
.shorthand = shorthand,
};

Write Preview
Loading…
Cancel
Save