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

lavfi/mp: drop mp=eq and mp=eq2

Browse Source 
mp=eq2 was ported to a native libavfilter filter in commit
4c38e960d0.
pull/105/merge
Stefano Sabatini 10 years ago
parent 7ccd625a46
commit 0ca5c4dade
6 changed files with 1 additions and 778 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. 12
      doc/filters.texi
  2. 2
      libavfilter/Makefile
  3. 240
      libavfilter/libmpcodecs/vf_eq.c
  4. 519
      libavfilter/libmpcodecs/vf_eq2.c
  5. 2
      libavfilter/version.h
  6. 4
      libavfilter/vf_mp.c

12
doc/filters.texi
Unescape View File

@ -6279,8 +6279,6 @@ the named filter.
The list of the currently supported filters follows:
@table @var
@item eq2
@item eq
@item softpulldown
@end table
@ -6288,16 +6286,6 @@ The parameter syntax and behavior for the listed filters are the same
of the corresponding MPlayer filters. For detailed instructions check
the "VIDEO FILTERS" section in the MPlayer manual.
@subsection Examples
@itemize
@item
Adjust gamma, brightness, contrast:
@example
mp=eq2=1.0:2:0.5
@end example
@end itemize
See also mplayer(1), @url{http://www.mplayerhq.hu/}.
@section mpdecimate

2
libavfilter/Makefile
Unescape View File

@ -228,8 +228,6 @@ OBJS-$(CONFIG_NULLSINK_FILTER) += vsink_nullsink.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/mp_image.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/img_format.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_eq2.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_eq.o
OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_softpulldown.o
# multimedia filters

240
libavfilter/libmpcodecs/vf_eq.c
Unescape View File

@ -1,240 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include "config.h"
#include "mp_msg.h"
#include "cpudetect.h"
#include "img_format.h"
#include "mp_image.h"
#include "vf.h"
#include "libvo/video_out.h"
struct vf_priv_s {
unsigned char *buf;
int brightness;
int contrast;
};
#if HAVE_MMX_INLINE && HAVE_6REGS
static void process_MMX(unsigned char *dest, int dstride, unsigned char *src, int sstride,
int w, int h, int brightness, int contrast)
{
int i;
int pel;
int dstep = dstride-w;
int sstep = sstride-w;
short brvec[4];
short contvec[4];
contrast = ((contrast+100)*256*16)/100;
brightness = ((brightness+100)*511)/200-128 - contrast/32;
brvec[0] = brvec[1] = brvec[2] = brvec[3] = brightness;
contvec[0] = contvec[1] = contvec[2] = contvec[3] = contrast;
while (h--) {
__asm__ volatile (
"movq (%5), %%mm3 \n\t"
"movq (%6), %%mm4 \n\t"
"pxor %%mm0, %%mm0 \n\t"
"movl %4, %%eax\n\t"
ASMALIGN(4)
"1: \n\t"
"movq (%0), %%mm1 \n\t"
"movq (%0), %%mm2 \n\t"
"punpcklbw %%mm0, %%mm1 \n\t"
"punpckhbw %%mm0, %%mm2 \n\t"
"psllw $4, %%mm1 \n\t"
"psllw $4, %%mm2 \n\t"
"pmulhw %%mm4, %%mm1 \n\t"
"pmulhw %%mm4, %%mm2 \n\t"
"paddw %%mm3, %%mm1 \n\t"
"paddw %%mm3, %%mm2 \n\t"
"packuswb %%mm2, %%mm1 \n\t"
"add $8, %0 \n\t"
"movq %%mm1, (%1) \n\t"
"add $8, %1 \n\t"
"decl %%eax \n\t"
"jnz 1b \n\t"
: "=r" (src), "=r" (dest)
: "0" (src), "1" (dest), "r" (w>>3), "r" (brvec), "r" (contvec)
: "%eax"
);
for (i = w&7; i; i--)
{
pel = ((*src++* contrast)>>12) + brightness;
if(pel&768) pel = (-pel)>>31;
*dest++ = pel;
}
src += sstep;
dest += dstep;
}
__asm__ volatile ( "emms \n\t" ::: "memory" );
}
#endif
static void process_C(unsigned char *dest, int dstride, unsigned char *src, int sstride,
int w, int h, int brightness, int contrast)
{
int i;
int pel;
int dstep = dstride-w;
int sstep = sstride-w;
contrast = ((contrast+100)*256*256)/100;
brightness = ((brightness+100)*511)/200-128 - contrast/512;
while (h--) {
for (i = w; i; i--)
{
pel = ((*src++* contrast)>>16) + brightness;
if(pel&768) pel = (-pel)>>31;
*dest++ = pel;
}
src += sstep;
dest += dstep;
}
}
static void (*process)(unsigned char *dest, int dstride, unsigned char *src, int sstride,
int w, int h, int brightness, int contrast);
/* FIXME: add packed yuv version of process */
static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts)
{
mp_image_t *dmpi;
dmpi=ff_vf_get_image(vf->next, mpi->imgfmt,
MP_IMGTYPE_EXPORT, 0,
mpi->w, mpi->h);
dmpi->stride[0] = mpi->stride[0];
dmpi->planes[1] = mpi->planes[1];
dmpi->planes[2] = mpi->planes[2];
dmpi->stride[1] = mpi->stride[1];
dmpi->stride[2] = mpi->stride[2];
if (!vf->priv->buf) vf->priv->buf = malloc(mpi->stride[0]*mpi->h);
if ((vf->priv->brightness == 0) && (vf->priv->contrast == 0))
dmpi->planes[0] = mpi->planes[0];
else {
dmpi->planes[0] = vf->priv->buf;
process(dmpi->planes[0], dmpi->stride[0],
mpi->planes[0], mpi->stride[0],
mpi->w, mpi->h, vf->priv->brightness,
vf->priv->contrast);
}
return ff_vf_next_put_image(vf,dmpi, pts);
}
static int control(struct vf_instance *vf, int request, void* data)
{
vf_equalizer_t *eq;
switch (request) {
case VFCTRL_SET_EQUALIZER:
eq = data;
if (!strcmp(eq->item,"brightness")) {
vf->priv->brightness = eq->value;
return CONTROL_TRUE;
}
else if (!strcmp(eq->item,"contrast")) {
vf->priv->contrast = eq->value;
return CONTROL_TRUE;
}
break;
case VFCTRL_GET_EQUALIZER:
eq = data;
if (!strcmp(eq->item,"brightness")) {
eq->value = vf->priv->brightness;
return CONTROL_TRUE;
}
else if (!strcmp(eq->item,"contrast")) {
eq->value = vf->priv->contrast;
return CONTROL_TRUE;
}
break;
}
return ff_vf_next_control(vf, request, data);
}
static int query_format(struct vf_instance *vf, unsigned int fmt)
{
switch (fmt) {
case IMGFMT_YVU9:
case IMGFMT_IF09:
case IMGFMT_YV12:
case IMGFMT_I420:
case IMGFMT_IYUV:
case IMGFMT_CLPL:
case IMGFMT_Y800:
case IMGFMT_Y8:
case IMGFMT_NV12:
case IMGFMT_NV21:
case IMGFMT_444P:
case IMGFMT_422P:
case IMGFMT_411P:
return ff_vf_next_query_format(vf, fmt);
}
return 0;
}
static void uninit(struct vf_instance *vf)
{
free(vf->priv->buf);
free(vf->priv);
}
static int vf_open(vf_instance_t *vf, char *args)
{
vf->control=control;
vf->query_format=query_format;
vf->put_image=put_image;
vf->uninit=uninit;
vf->priv = malloc(sizeof(struct vf_priv_s));
memset(vf->priv, 0, sizeof(struct vf_priv_s));
if (args) sscanf(args, "%d:%d", &vf->priv->brightness, &vf->priv->contrast);
process = process_C;
#if HAVE_MMX_INLINE && HAVE_6REGS
if(ff_gCpuCaps.hasMMX) process = process_MMX;
#endif
return 1;
}
const vf_info_t ff_vf_info_eq = {
"soft video equalizer",
"eq",
"Richard Felker",
"",
vf_open,
};

519
libavfilter/libmpcodecs/vf_eq2.c
Unescape View File

@ -1,519 +0,0 @@
/*
* Software equalizer (brightness, contrast, gamma, saturation)
*
* Hampa Hug <hampa@hampa.ch> (original LUT gamma/contrast/brightness filter)
* Daniel Moreno <comac@comac.darktech.org> (saturation, R/G/B gamma support)
* Richard Felker (original MMX contrast/brightness code (vf_eq.c))
* Michael Niedermayer <michalni@gmx.at> (LUT16)
*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <inttypes.h>
#include "config.h"
#include "mp_msg.h"
#include "cpudetect.h"
#include "img_format.h"
#include "mp_image.h"
#include "vf.h"
#define LUT16
/* Per channel parameters */
typedef struct eq2_param_t {
unsigned char lut[256];
#ifdef LUT16
uint16_t lut16[256*256];
#endif
int lut_clean;
void (*adjust) (struct eq2_param_t *par, unsigned char *dst, unsigned char *src,
unsigned w, unsigned h, unsigned dstride, unsigned sstride);
double c;
double b;
double g;
double w;
} eq2_param_t;
typedef struct vf_priv_s {
eq2_param_t param[3];
double contrast;
double brightness;
double saturation;
double gamma;
double gamma_weight;
double rgamma;
double ggamma;
double bgamma;
unsigned buf_w[3];
unsigned buf_h[3];
unsigned char *buf[3];
} vf_eq2_t;
static
void create_lut (eq2_param_t *par)
{
unsigned i;
double g, v;
double lw, gw;
g = par->g;
gw = par->w;
lw = 1.0 - gw;
if ((g < 0.001) || (g > 1000.0)) {
g = 1.0;
}
g = 1.0 / g;
for (i = 0; i < 256; i++) {
v = (double) i / 255.0;
v = par->c * (v - 0.5) + 0.5 + par->b;
if (v <= 0.0) {
par->lut[i] = 0;
}
else {
v = v*lw + pow(v, g)*gw;
if (v >= 1.0) {
par->lut[i] = 255;
}
else {
par->lut[i] = (unsigned char) (256.0 * v);
}
}
}
#ifdef LUT16
for(i=0; i<256*256; i++){
par->lut16[i]= par->lut[i&0xFF] + (par->lut[i>>8]<<8);
}
#endif
par->lut_clean = 1;
}
#if HAVE_MMX_INLINE && HAVE_6REGS
static
void affine_1d_MMX (eq2_param_t *par, unsigned char *dst, unsigned char *src,
unsigned w, unsigned h, unsigned dstride, unsigned sstride)
{
unsigned i;
int contrast, brightness;
unsigned dstep, sstep;
int pel;
short brvec[4];
short contvec[4];
// printf("\nmmx: src=%p dst=%p w=%d h=%d ds=%d ss=%d\n",src,dst,w,h,dstride,sstride);
contrast = (int) (par->c * 256 * 16);
brightness = ((int) (100.0 * par->b + 100.0) * 511) / 200 - 128 - contrast / 32;
brvec[0] = brvec[1] = brvec[2] = brvec[3] = brightness;
contvec[0] = contvec[1] = contvec[2] = contvec[3] = contrast;
sstep = sstride - w;
dstep = dstride - w;
while (h-- > 0) {
__asm__ volatile (
"movq (%5), %%mm3 \n\t"
"movq (%6), %%mm4 \n\t"
"pxor %%mm0, %%mm0 \n\t"
"movl %4, %%eax\n\t"
ASMALIGN(4)
"1: \n\t"
"movq (%0), %%mm1 \n\t"
"movq (%0), %%mm2 \n\t"
"punpcklbw %%mm0, %%mm1 \n\t"
"punpckhbw %%mm0, %%mm2 \n\t"
"psllw $4, %%mm1 \n\t"
"psllw $4, %%mm2 \n\t"
"pmulhw %%mm4, %%mm1 \n\t"
"pmulhw %%mm4, %%mm2 \n\t"
"paddw %%mm3, %%mm1 \n\t"
"paddw %%mm3, %%mm2 \n\t"
"packuswb %%mm2, %%mm1 \n\t"
"add $8, %0 \n\t"
"movq %%mm1, (%1) \n\t"
"add $8, %1 \n\t"
"decl %%eax \n\t"
"jnz 1b \n\t"
: "=r" (src), "=r" (dst)
: "0" (src), "1" (dst), "r" (w >> 3), "r" (brvec), "r" (contvec)
: "%eax"
);
for (i = w & 7; i > 0; i--) {
pel = ((*src++ * contrast) >> 12) + brightness;
if (pel & 768) {
pel = (-pel) >> 31;
}
*dst++ = pel;
}
src += sstep;
dst += dstep;
}
__asm__ volatile ( "emms \n\t" ::: "memory" );
}
#endif
static
void apply_lut (eq2_param_t *par, unsigned char *dst, unsigned char *src,
unsigned w, unsigned h, unsigned dstride, unsigned sstride)
{
unsigned i, j, w2;
unsigned char *lut;
uint16_t *lut16;
if (!par->lut_clean) {
create_lut (par);
}
lut = par->lut;
#ifdef LUT16
lut16 = par->lut16;
w2= (w>>3)<<2;
for (j = 0; j < h; j++) {
uint16_t *src16= (uint16_t*)src;
uint16_t *dst16= (uint16_t*)dst;
for (i = 0; i < w2; i+=4) {
dst16[i+0] = lut16[src16[i+0]];
dst16[i+1] = lut16[src16[i+1]];
dst16[i+2] = lut16[src16[i+2]];
dst16[i+3] = lut16[src16[i+3]];
}
i <<= 1;
#else
w2= (w>>3)<<3;
for (j = 0; j < h; j++) {
for (i = 0; i < w2; i+=8) {
dst[i+0] = lut[src[i+0]];
dst[i+1] = lut[src[i+1]];
dst[i+2] = lut[src[i+2]];
dst[i+3] = lut[src[i+3]];
dst[i+4] = lut[src[i+4]];
dst[i+5] = lut[src[i+5]];
dst[i+6] = lut[src[i+6]];
dst[i+7] = lut[src[i+7]];
}
#endif
for (; i < w; i++) {
dst[i] = lut[src[i]];
}
src += sstride;
dst += dstride;
}
}
static
int put_image (vf_instance_t *vf, mp_image_t *src, double pts)
{
unsigned i;
vf_eq2_t *eq2;
mp_image_t *dst;
unsigned long img_n,img_c;
eq2 = vf->priv;
if ((eq2->buf_w[0] != src->w) || (eq2->buf_h[0] != src->h)) {
eq2->buf_w[0] = src->w;
eq2->buf_h[0] = src->h;
eq2->buf_w[1] = eq2->buf_w[2] = src->w >> src->chroma_x_shift;
eq2->buf_h[1] = eq2->buf_h[2] = src->h >> src->chroma_y_shift;
img_n = eq2->buf_w[0]*eq2->buf_h[0];
if(src->num_planes>1){
img_c = eq2->buf_w[1]*eq2->buf_h[1];
eq2->buf[0] = realloc (eq2->buf[0], img_n + 2*img_c);
eq2->buf[1] = eq2->buf[0] + img_n;
eq2->buf[2] = eq2->buf[1] + img_c;
} else
eq2->buf[0] = realloc (eq2->buf[0], img_n);
}
dst = ff_vf_get_image (vf->next, src->imgfmt, MP_IMGTYPE_EXPORT, 0, src->w, src->h);
for (i = 0; i < ((src->num_planes>1)?3:1); i++) {
if (eq2->param[i].adjust) {
dst->planes[i] = eq2->buf[i];
dst->stride[i] = eq2->buf_w[i];
eq2->param[i].adjust (&eq2->param[i], dst->planes[i], src->planes[i],
eq2->buf_w[i], eq2->buf_h[i], dst->stride[i], src->stride[i]);
}
else {
dst->planes[i] = src->planes[i];
dst->stride[i] = src->stride[i];
}
}
return ff_vf_next_put_image (vf, dst, pts);
}
static
void check_values (eq2_param_t *par)
{
/* yuck! floating point comparisons... */
if ((par->c == 1.0) && (par->b == 0.0) && (par->g == 1.0)) {
par->adjust = NULL;
}
#if HAVE_MMX_INLINE && HAVE_6REGS
else if (par->g == 1.0 && ff_gCpuCaps.hasMMX) {
par->adjust = &affine_1d_MMX;
}
#endif
else {
par->adjust = &apply_lut;
}
}
static
void print_values (vf_eq2_t *eq2)
{
ff_mp_msg (MSGT_VFILTER, MSGL_V, "vf_eq2: c=%.2f b=%.2f g=%.4f s=%.2f \n",
eq2->contrast, eq2->brightness, eq2->gamma, eq2->saturation
);
}
static
void set_contrast (vf_eq2_t *eq2, double c)
{
eq2->contrast = c;
eq2->param[0].c = c;
eq2->param[0].lut_clean = 0;
check_values (&eq2->param[0]);
print_values (eq2);
}
static
void set_brightness (vf_eq2_t *eq2, double b)
{
eq2->brightness = b;
eq2->param[0].b = b;
eq2->param[0].lut_clean = 0;
check_values (&eq2->param[0]);
print_values (eq2);
}
static
void set_gamma (vf_eq2_t *eq2, double g)
{
eq2->gamma = g;
eq2->param[0].g = eq2->gamma * eq2->ggamma;
eq2->param[1].g = sqrt (eq2->bgamma / eq2->ggamma);
eq2->param[2].g = sqrt (eq2->rgamma / eq2->ggamma);
eq2->param[0].w = eq2->param[1].w = eq2->param[2].w = eq2->gamma_weight;
eq2->param[0].lut_clean = 0;
eq2->param[1].lut_clean = 0;
eq2->param[2].lut_clean = 0;
check_values (&eq2->param[0]);
check_values (&eq2->param[1]);
check_values (&eq2->param[2]);
print_values (eq2);
}
static
void set_saturation (vf_eq2_t *eq2, double s)
{
eq2->saturation = s;
eq2->param[1].c = s;
eq2->param[2].c = s;
eq2->param[1].lut_clean = 0;
eq2->param[2].lut_clean = 0;
check_values (&eq2->param[1]);
check_values (&eq2->param[2]);
print_values (eq2);
}
static
int control (vf_instance_t *vf, int request, void *data)
{
vf_equalizer_t *eq;
switch (request) {
case VFCTRL_SET_EQUALIZER:
eq = (vf_equalizer_t *) data;
if (strcmp (eq->item, "gamma") == 0) {
set_gamma (vf->priv, exp (log (8.0) * eq->value / 100.0));
return CONTROL_TRUE;
}
else if (strcmp (eq->item, "contrast") == 0) {
set_contrast (vf->priv, (1.0 / 100.0) * (eq->value + 100));
return CONTROL_TRUE;
}
else if (strcmp (eq->item, "brightness") == 0) {
set_brightness (vf->priv, (1.0 / 100.0) * eq->value);
return CONTROL_TRUE;
}
else if (strcmp (eq->item, "saturation") == 0) {
set_saturation (vf->priv, (double) (eq->value + 100) / 100.0);
return CONTROL_TRUE;
}
break;
case VFCTRL_GET_EQUALIZER:
eq = (vf_equalizer_t *) data;
if (strcmp (eq->item, "gamma") == 0) {
eq->value = (int) (100.0 * log (vf->priv->gamma) / log (8.0));
return CONTROL_TRUE;
}
else if (strcmp (eq->item, "contrast") == 0) {
eq->value = (int) (100.0 * vf->priv->contrast) - 100;
return CONTROL_TRUE;
}
else if (strcmp (eq->item, "brightness") == 0) {
eq->value = (int) (100.0 * vf->priv->brightness);
return CONTROL_TRUE;
}
else if (strcmp (eq->item, "saturation") == 0) {
eq->value = (int) (100.0 * vf->priv->saturation) - 100;
return CONTROL_TRUE;
}
break;
}
return ff_vf_next_control (vf, request, data);
}
static
int query_format (vf_instance_t *vf, unsigned fmt)
{
switch (fmt) {
case IMGFMT_YVU9:
case IMGFMT_IF09:
case IMGFMT_YV12:
case IMGFMT_I420:
case IMGFMT_IYUV:
case IMGFMT_Y800:
case IMGFMT_Y8:
case IMGFMT_444P:
case IMGFMT_422P:
case IMGFMT_411P:
return ff_vf_next_query_format (vf, fmt);
}
return 0;
}
static
void uninit (vf_instance_t *vf)
{
if (vf->priv) {
free (vf->priv->buf[0]);
free (vf->priv);
}
}
static
int vf_open(vf_instance_t *vf, char *args)
{
unsigned i;
vf_eq2_t *eq2;
double par[8];
vf->control = control;
vf->query_format = query_format;
vf->put_image = put_image;
vf->uninit = uninit;
vf->priv = malloc (sizeof (vf_eq2_t));
eq2 = vf->priv;
for (i = 0; i < 3; i++) {
eq2->buf[i] = NULL;
eq2->buf_w[i] = 0;
eq2->buf_h[i] = 0;
eq2->param[i].adjust = NULL;
eq2->param[i].c = 1.0;
eq2->param[i].b = 0.0;
eq2->param[i].g = 1.0;
eq2->param[i].lut_clean = 0;
}
eq2->contrast = 1.0;
eq2->brightness = 0.0;
eq2->saturation = 1.0;
eq2->gamma = 1.0;
eq2->gamma_weight = 1.0;
eq2->rgamma = 1.0;
eq2->ggamma = 1.0;
eq2->bgamma = 1.0;
if (args) {
par[0] = 1.0;
par[1] = 1.0;
par[2] = 0.0;
par[3] = 1.0;
par[4] = 1.0;
par[5] = 1.0;
par[6] = 1.0;
par[7] = 1.0;
sscanf (args, "%lf:%lf:%lf:%lf:%lf:%lf:%lf:%lf",
par, par + 1, par + 2, par + 3, par + 4, par + 5, par + 6, par + 7
);
eq2->rgamma = par[4];
eq2->ggamma = par[5];
eq2->bgamma = par[6];
eq2->gamma_weight = par[7];
set_gamma (eq2, par[0]);
set_contrast (eq2, par[1]);
set_brightness (eq2, par[2]);
set_saturation (eq2, par[3]);
}
return 1;
}
const vf_info_t ff_vf_info_eq2 = {
"Software equalizer",
"eq2",
"Hampa Hug, Daniel Moreno, Richard Felker",
"",
&vf_open,
NULL
};

2
libavfilter/version.h
Unescape View File

@ -31,7 +31,7 @@
#define LIBAVFILTER_VERSION_MAJOR 5
#define LIBAVFILTER_VERSION_MINOR 9
#define LIBAVFILTER_VERSION_MICRO 100
#define LIBAVFILTER_VERSION_MICRO 101
#define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
LIBAVFILTER_VERSION_MINOR, \

4
libavfilter/vf_mp.c
Unescape View File

@ -125,13 +125,9 @@ static const struct {
{0, AV_PIX_FMT_NONE}
};
extern const vf_info_t ff_vf_info_eq2;
extern const vf_info_t ff_vf_info_eq;
extern const vf_info_t ff_vf_info_softpulldown;
static const vf_info_t* const filters[]={
&ff_vf_info_eq2,
&ff_vf_info_eq,
&ff_vf_info_softpulldown,
NULL
};

Write Preview
Loading…
Cancel
Save