2010-01-30 16:57:40 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2002-04-06 22:05:01 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2011-07-30 16:03:20 +00:00
|
|
|
#include <assert.h>
|
2002-04-06 22:05:01 +00:00
|
|
|
|
2005-11-18 14:39:25 +00:00
|
|
|
#include "config.h"
|
2009-02-17 11:16:19 +00:00
|
|
|
#if HAVE_MALLOC_H
|
2002-05-25 13:22:28 +00:00
|
|
|
#include <malloc.h>
|
|
|
|
#endif
|
|
|
|
|
2005-11-18 14:39:25 +00:00
|
|
|
#include "mp_msg.h"
|
|
|
|
#include "m_option.h"
|
|
|
|
#include "m_struct.h"
|
2002-08-13 23:32:05 +00:00
|
|
|
|
2002-04-06 22:05:01 +00:00
|
|
|
|
2002-04-13 19:14:34 +00:00
|
|
|
#include "img_format.h"
|
|
|
|
#include "mp_image.h"
|
2002-04-06 22:05:01 +00:00
|
|
|
#include "vf.h"
|
|
|
|
|
2005-11-18 14:39:25 +00:00
|
|
|
#include "libvo/fastmemcpy.h"
|
2010-04-20 04:33:00 +00:00
|
|
|
#include "libavutil/mem.h"
|
2003-05-20 17:42:33 +00:00
|
|
|
|
2007-11-09 06:57:24 +00:00
|
|
|
extern const vf_info_t vf_info_vo;
|
|
|
|
extern const vf_info_t vf_info_rectangle;
|
|
|
|
extern const vf_info_t vf_info_bmovl;
|
|
|
|
extern const vf_info_t vf_info_crop;
|
|
|
|
extern const vf_info_t vf_info_expand;
|
|
|
|
extern const vf_info_t vf_info_pp;
|
|
|
|
extern const vf_info_t vf_info_scale;
|
|
|
|
extern const vf_info_t vf_info_format;
|
|
|
|
extern const vf_info_t vf_info_noformat;
|
|
|
|
extern const vf_info_t vf_info_flip;
|
|
|
|
extern const vf_info_t vf_info_rotate;
|
|
|
|
extern const vf_info_t vf_info_mirror;
|
|
|
|
extern const vf_info_t vf_info_palette;
|
|
|
|
extern const vf_info_t vf_info_lavc;
|
|
|
|
extern const vf_info_t vf_info_dvbscale;
|
|
|
|
extern const vf_info_t vf_info_cropdetect;
|
|
|
|
extern const vf_info_t vf_info_test;
|
|
|
|
extern const vf_info_t vf_info_noise;
|
|
|
|
extern const vf_info_t vf_info_yvu9;
|
|
|
|
extern const vf_info_t vf_info_lavcdeint;
|
|
|
|
extern const vf_info_t vf_info_eq;
|
|
|
|
extern const vf_info_t vf_info_eq2;
|
2009-07-07 02:01:36 +00:00
|
|
|
extern const vf_info_t vf_info_gradfun;
|
2007-11-09 06:57:24 +00:00
|
|
|
extern const vf_info_t vf_info_halfpack;
|
|
|
|
extern const vf_info_t vf_info_dint;
|
|
|
|
extern const vf_info_t vf_info_1bpp;
|
|
|
|
extern const vf_info_t vf_info_2xsai;
|
|
|
|
extern const vf_info_t vf_info_unsharp;
|
|
|
|
extern const vf_info_t vf_info_swapuv;
|
|
|
|
extern const vf_info_t vf_info_il;
|
|
|
|
extern const vf_info_t vf_info_fil;
|
|
|
|
extern const vf_info_t vf_info_boxblur;
|
|
|
|
extern const vf_info_t vf_info_sab;
|
|
|
|
extern const vf_info_t vf_info_smartblur;
|
|
|
|
extern const vf_info_t vf_info_perspective;
|
|
|
|
extern const vf_info_t vf_info_down3dright;
|
|
|
|
extern const vf_info_t vf_info_field;
|
|
|
|
extern const vf_info_t vf_info_denoise3d;
|
|
|
|
extern const vf_info_t vf_info_hqdn3d;
|
|
|
|
extern const vf_info_t vf_info_detc;
|
|
|
|
extern const vf_info_t vf_info_telecine;
|
|
|
|
extern const vf_info_t vf_info_tinterlace;
|
|
|
|
extern const vf_info_t vf_info_tfields;
|
|
|
|
extern const vf_info_t vf_info_ivtc;
|
|
|
|
extern const vf_info_t vf_info_ilpack;
|
|
|
|
extern const vf_info_t vf_info_dsize;
|
|
|
|
extern const vf_info_t vf_info_decimate;
|
|
|
|
extern const vf_info_t vf_info_softpulldown;
|
|
|
|
extern const vf_info_t vf_info_pullup;
|
|
|
|
extern const vf_info_t vf_info_filmdint;
|
|
|
|
extern const vf_info_t vf_info_framestep;
|
|
|
|
extern const vf_info_t vf_info_tile;
|
|
|
|
extern const vf_info_t vf_info_delogo;
|
|
|
|
extern const vf_info_t vf_info_remove_logo;
|
|
|
|
extern const vf_info_t vf_info_hue;
|
|
|
|
extern const vf_info_t vf_info_spp;
|
|
|
|
extern const vf_info_t vf_info_uspp;
|
|
|
|
extern const vf_info_t vf_info_fspp;
|
|
|
|
extern const vf_info_t vf_info_pp7;
|
|
|
|
extern const vf_info_t vf_info_yuvcsp;
|
|
|
|
extern const vf_info_t vf_info_kerndeint;
|
|
|
|
extern const vf_info_t vf_info_rgbtest;
|
|
|
|
extern const vf_info_t vf_info_qp;
|
|
|
|
extern const vf_info_t vf_info_phase;
|
|
|
|
extern const vf_info_t vf_info_divtc;
|
|
|
|
extern const vf_info_t vf_info_harddup;
|
|
|
|
extern const vf_info_t vf_info_softskip;
|
|
|
|
extern const vf_info_t vf_info_screenshot;
|
|
|
|
extern const vf_info_t vf_info_ass;
|
|
|
|
extern const vf_info_t vf_info_mcdeint;
|
|
|
|
extern const vf_info_t vf_info_yadif;
|
|
|
|
extern const vf_info_t vf_info_blackframe;
|
|
|
|
extern const vf_info_t vf_info_geq;
|
|
|
|
extern const vf_info_t vf_info_ow;
|
2010-03-05 23:13:08 +00:00
|
|
|
extern const vf_info_t vf_info_fixpts;
|
2010-10-22 17:46:12 +00:00
|
|
|
extern const vf_info_t vf_info_stereo3d;
|
2002-04-06 22:05:01 +00:00
|
|
|
|
|
|
|
// list of available filters:
|
2011-11-03 13:21:53 +00:00
|
|
|
static const vf_info_t *const filter_list[] = {
|
2002-07-27 11:40:15 +00:00
|
|
|
&vf_info_rectangle,
|
2007-03-21 08:24:20 +00:00
|
|
|
#ifdef HAVE_POSIX_SELECT
|
2002-10-23 00:26:27 +00:00
|
|
|
&vf_info_bmovl,
|
2003-04-04 20:12:24 +00:00
|
|
|
#endif
|
2002-04-06 22:05:01 +00:00
|
|
|
&vf_info_crop,
|
|
|
|
&vf_info_expand,
|
2002-04-07 20:21:37 +00:00
|
|
|
&vf_info_scale,
|
2002-04-06 22:05:01 +00:00
|
|
|
// &vf_info_osd,
|
|
|
|
&vf_info_vo,
|
2002-04-09 14:01:53 +00:00
|
|
|
&vf_info_format,
|
2004-02-06 20:31:57 +00:00
|
|
|
&vf_info_noformat,
|
2002-04-11 03:17:14 +00:00
|
|
|
&vf_info_flip,
|
2002-04-19 02:18:46 +00:00
|
|
|
&vf_info_rotate,
|
2002-04-21 14:36:36 +00:00
|
|
|
&vf_info_mirror,
|
2002-04-21 17:22:37 +00:00
|
|
|
&vf_info_palette,
|
2008-04-11 08:13:36 +00:00
|
|
|
&vf_info_pp7,
|
2010-10-31 00:19:56 +00:00
|
|
|
#ifdef CONFIG_FFMPEG
|
|
|
|
&vf_info_pp,
|
2002-04-27 23:34:44 +00:00
|
|
|
&vf_info_lavc,
|
2002-07-31 19:50:42 +00:00
|
|
|
&vf_info_lavcdeint,
|
2008-04-11 08:11:16 +00:00
|
|
|
&vf_info_screenshot,
|
2009-12-06 23:51:37 +00:00
|
|
|
&vf_info_uspp,
|
2002-04-27 23:35:23 +00:00
|
|
|
#endif
|
2002-05-06 22:48:22 +00:00
|
|
|
&vf_info_dvbscale,
|
2002-05-12 19:06:54 +00:00
|
|
|
&vf_info_cropdetect,
|
2002-06-03 14:13:28 +00:00
|
|
|
&vf_info_test,
|
2002-06-14 01:14:56 +00:00
|
|
|
&vf_info_noise,
|
2002-06-21 17:38:06 +00:00
|
|
|
&vf_info_yvu9,
|
2002-08-21 23:08:20 +00:00
|
|
|
&vf_info_eq,
|
2002-09-27 21:08:36 +00:00
|
|
|
&vf_info_eq2,
|
2009-07-07 02:01:36 +00:00
|
|
|
&vf_info_gradfun,
|
2002-08-30 06:16:40 +00:00
|
|
|
&vf_info_halfpack,
|
2002-09-10 23:18:31 +00:00
|
|
|
&vf_info_dint,
|
2002-10-16 18:40:03 +00:00
|
|
|
&vf_info_1bpp,
|
2002-10-25 16:49:33 +00:00
|
|
|
&vf_info_2xsai,
|
2002-10-29 22:37:11 +00:00
|
|
|
&vf_info_unsharp,
|
2002-10-31 18:13:56 +00:00
|
|
|
&vf_info_swapuv,
|
2002-10-31 20:03:08 +00:00
|
|
|
&vf_info_il,
|
2003-10-22 21:21:52 +00:00
|
|
|
&vf_info_fil,
|
2002-10-31 23:26:11 +00:00
|
|
|
&vf_info_boxblur,
|
2002-11-04 16:42:17 +00:00
|
|
|
&vf_info_sab,
|
2002-11-04 20:39:27 +00:00
|
|
|
&vf_info_smartblur,
|
2002-11-05 13:29:10 +00:00
|
|
|
&vf_info_perspective,
|
2003-02-11 21:44:55 +00:00
|
|
|
&vf_info_down3dright,
|
2003-01-23 16:33:57 +00:00
|
|
|
&vf_info_field,
|
2003-01-30 22:53:32 +00:00
|
|
|
&vf_info_denoise3d,
|
2003-02-15 22:24:32 +00:00
|
|
|
&vf_info_hqdn3d,
|
2003-02-20 03:16:41 +00:00
|
|
|
&vf_info_detc,
|
2003-02-20 04:57:37 +00:00
|
|
|
&vf_info_telecine,
|
2003-08-11 20:04:30 +00:00
|
|
|
&vf_info_tinterlace,
|
2003-03-01 05:35:09 +00:00
|
|
|
&vf_info_tfields,
|
2003-04-19 01:39:37 +00:00
|
|
|
&vf_info_ivtc,
|
|
|
|
&vf_info_ilpack,
|
2003-04-27 18:55:04 +00:00
|
|
|
&vf_info_dsize,
|
2003-05-22 12:38:42 +00:00
|
|
|
&vf_info_decimate,
|
2003-08-03 12:09:58 +00:00
|
|
|
&vf_info_softpulldown,
|
2003-08-18 15:24:08 +00:00
|
|
|
&vf_info_pullup,
|
2003-12-08 22:57:47 +00:00
|
|
|
&vf_info_filmdint,
|
2003-08-31 21:41:24 +00:00
|
|
|
&vf_info_framestep,
|
|
|
|
&vf_info_tile,
|
2003-09-03 22:44:28 +00:00
|
|
|
&vf_info_delogo,
|
2005-06-08 15:29:26 +00:00
|
|
|
&vf_info_remove_logo,
|
2003-10-23 18:36:02 +00:00
|
|
|
&vf_info_hue,
|
2010-10-31 00:19:56 +00:00
|
|
|
#ifdef CONFIG_FFMPEG_INTERNALS
|
2003-10-26 23:07:21 +00:00
|
|
|
&vf_info_spp,
|
2005-06-04 07:05:02 +00:00
|
|
|
&vf_info_fspp,
|
2006-06-07 22:14:00 +00:00
|
|
|
&vf_info_mcdeint,
|
2010-11-06 18:02:44 +00:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_FFMPEG_EVAL_API
|
2007-03-23 13:31:08 +00:00
|
|
|
&vf_info_geq,
|
2011-07-17 21:15:08 +00:00
|
|
|
&vf_info_qp,
|
2003-10-26 23:07:21 +00:00
|
|
|
#endif
|
2003-11-29 19:34:26 +00:00
|
|
|
&vf_info_yuvcsp,
|
2004-01-29 09:50:17 +00:00
|
|
|
&vf_info_kerndeint,
|
2004-01-30 17:38:15 +00:00
|
|
|
&vf_info_rgbtest,
|
2004-03-29 04:39:04 +00:00
|
|
|
&vf_info_phase,
|
2004-04-17 17:08:31 +00:00
|
|
|
&vf_info_divtc,
|
2004-04-28 04:02:46 +00:00
|
|
|
&vf_info_harddup,
|
2004-04-28 04:29:17 +00:00
|
|
|
&vf_info_softskip,
|
2008-07-30 12:01:30 +00:00
|
|
|
#ifdef CONFIG_ASS
|
2006-07-07 18:26:51 +00:00
|
|
|
&vf_info_ass,
|
2005-09-11 06:42:32 +00:00
|
|
|
#endif
|
2006-06-06 23:30:23 +00:00
|
|
|
&vf_info_yadif,
|
2006-07-15 09:18:44 +00:00
|
|
|
&vf_info_blackframe,
|
2007-10-03 23:50:54 +00:00
|
|
|
&vf_info_ow,
|
2010-03-05 23:13:08 +00:00
|
|
|
&vf_info_fixpts,
|
2010-10-22 17:46:12 +00:00
|
|
|
&vf_info_stereo3d,
|
2002-04-06 22:05:01 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2003-03-15 18:01:02 +00:00
|
|
|
// For the vf option
|
2007-11-09 06:57:24 +00:00
|
|
|
const m_obj_list_t vf_obj_list = {
|
2011-11-03 13:21:53 +00:00
|
|
|
(void **)filter_list,
|
|
|
|
M_ST_OFF(vf_info_t, name),
|
|
|
|
M_ST_OFF(vf_info_t, info),
|
|
|
|
M_ST_OFF(vf_info_t, opts)
|
2003-03-15 18:01:02 +00:00
|
|
|
};
|
|
|
|
|
2002-04-06 22:05:01 +00:00
|
|
|
//============================================================================
|
|
|
|
// mpi stuff:
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
void vf_mpi_clear(mp_image_t *mpi, int x0, int y0, int w, int h)
|
|
|
|
{
|
2002-04-17 19:05:14 +00:00
|
|
|
int y;
|
2011-11-03 13:21:53 +00:00
|
|
|
if (mpi->flags & MP_IMGFLAG_PLANAR) {
|
|
|
|
y0 &= ~1;
|
|
|
|
h += h & 1;
|
|
|
|
if (x0 == 0 && w == mpi->width) {
|
|
|
|
// full width clear:
|
|
|
|
memset(mpi->planes[0] + mpi->stride[0] * y0, 0, mpi->stride[0] * h);
|
|
|
|
memset(mpi->planes[1] + mpi->stride[1] *(y0 >> mpi->chroma_y_shift),
|
|
|
|
128, mpi->stride[1] * (h >> mpi->chroma_y_shift));
|
|
|
|
memset(mpi->planes[2] + mpi->stride[2] *(y0 >> mpi->chroma_y_shift),
|
|
|
|
128, mpi->stride[2] * (h >> mpi->chroma_y_shift));
|
|
|
|
} else
|
|
|
|
for (y = y0; y < y0 + h; y += 2) {
|
|
|
|
memset(mpi->planes[0] + x0 + mpi->stride[0] * y, 0, w);
|
|
|
|
memset(mpi->planes[0] + x0 + mpi->stride[0] * (y + 1), 0, w);
|
|
|
|
memset(mpi->planes[1] + (x0 >> mpi->chroma_x_shift) +
|
|
|
|
mpi->stride[1] * (y >> mpi->chroma_y_shift),
|
|
|
|
128, (w >> mpi->chroma_x_shift));
|
|
|
|
memset(mpi->planes[2] + (x0 >> mpi->chroma_x_shift) +
|
|
|
|
mpi->stride[2] * (y >> mpi->chroma_y_shift),
|
|
|
|
128, (w >> mpi->chroma_x_shift));
|
|
|
|
}
|
|
|
|
return;
|
2002-04-17 19:05:14 +00:00
|
|
|
}
|
|
|
|
// packed:
|
2011-11-03 13:21:53 +00:00
|
|
|
for (y = y0; y < y0 + h; y++) {
|
|
|
|
unsigned char *dst = mpi->planes[0] + mpi->stride[0] * y +
|
|
|
|
(mpi->bpp >> 3) * x0;
|
|
|
|
if (mpi->flags & MP_IMGFLAG_YUV) {
|
|
|
|
unsigned int *p = (unsigned int *) dst;
|
|
|
|
int size = (mpi->bpp >> 3) * w / 4;
|
|
|
|
int i;
|
2009-07-26 19:53:00 +00:00
|
|
|
#if HAVE_BIGENDIAN
|
2004-05-31 15:07:58 +00:00
|
|
|
#define CLEAR_PACKEDYUV_PATTERN 0x00800080
|
|
|
|
#define CLEAR_PACKEDYUV_PATTERN_SWAPPED 0x80008000
|
|
|
|
#else
|
|
|
|
#define CLEAR_PACKEDYUV_PATTERN 0x80008000
|
|
|
|
#define CLEAR_PACKEDYUV_PATTERN_SWAPPED 0x00800080
|
|
|
|
#endif
|
2011-11-03 13:21:53 +00:00
|
|
|
if (mpi->flags & MP_IMGFLAG_SWAPPED) {
|
|
|
|
for (i = 0; i < size - 3; i += 4)
|
|
|
|
p[i] = p[i + 1] = p[i + 2] = p[i + 3] = CLEAR_PACKEDYUV_PATTERN_SWAPPED;
|
|
|
|
for (; i < size; i++)
|
|
|
|
p[i] = CLEAR_PACKEDYUV_PATTERN_SWAPPED;
|
|
|
|
} else {
|
|
|
|
for (i = 0; i < size - 3; i += 4)
|
|
|
|
p[i] = p[i + 1] = p[i + 2] = p[i + 3] = CLEAR_PACKEDYUV_PATTERN;
|
|
|
|
for (; i < size; i++)
|
|
|
|
p[i] = CLEAR_PACKEDYUV_PATTERN;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
memset(dst, 0, (mpi->bpp >> 3) * w);
|
2002-04-17 19:05:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
mp_image_t *vf_get_image(vf_instance_t *vf, unsigned int outfmt,
|
|
|
|
int mp_imgtype, int mp_imgflag, int w, int h)
|
|
|
|
{
|
|
|
|
mp_image_t *mpi = NULL;
|
|
|
|
int w2;
|
|
|
|
int number = mp_imgtype >> 16;
|
|
|
|
|
|
|
|
assert(w == -1 || w >= vf->w);
|
|
|
|
assert(h == -1 || h >= vf->h);
|
|
|
|
assert(vf->w > 0);
|
|
|
|
assert(vf->h > 0);
|
|
|
|
|
|
|
|
if (w == -1)
|
|
|
|
w = vf->w;
|
|
|
|
if (h == -1)
|
|
|
|
h = vf->h;
|
|
|
|
|
|
|
|
w2 = (mp_imgflag & MP_IMGFLAG_ACCEPT_ALIGNED_STRIDE) ?
|
|
|
|
((w + 15) & (~15)) : w;
|
|
|
|
|
|
|
|
if (vf->put_image == vf_next_put_image) {
|
|
|
|
// passthru mode, if the filter uses the fallback/default put_image()
|
|
|
|
return vf_get_image(vf->next, outfmt, mp_imgtype, mp_imgflag, w, h);
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
2011-11-03 13:21:53 +00:00
|
|
|
|
|
|
|
// Note: we should call libvo first to check if it supports direct rendering
|
|
|
|
// and if not, then fallback to software buffers:
|
|
|
|
switch (mp_imgtype & 0xff) {
|
|
|
|
case MP_IMGTYPE_EXPORT:
|
|
|
|
if (!vf->imgctx.export_images[0])
|
|
|
|
vf->imgctx.export_images[0] = new_mp_image(w2, h);
|
|
|
|
mpi = vf->imgctx.export_images[0];
|
|
|
|
break;
|
|
|
|
case MP_IMGTYPE_STATIC:
|
|
|
|
if (!vf->imgctx.static_images[0])
|
|
|
|
vf->imgctx.static_images[0] = new_mp_image(w2, h);
|
|
|
|
mpi = vf->imgctx.static_images[0];
|
|
|
|
break;
|
|
|
|
case MP_IMGTYPE_TEMP:
|
|
|
|
if (!vf->imgctx.temp_images[0])
|
|
|
|
vf->imgctx.temp_images[0] = new_mp_image(w2, h);
|
|
|
|
mpi = vf->imgctx.temp_images[0];
|
|
|
|
break;
|
|
|
|
case MP_IMGTYPE_IPB:
|
|
|
|
if (!(mp_imgflag & MP_IMGFLAG_READABLE)) { // B frame:
|
|
|
|
if (!vf->imgctx.temp_images[0])
|
|
|
|
vf->imgctx.temp_images[0] = new_mp_image(w2, h);
|
|
|
|
mpi = vf->imgctx.temp_images[0];
|
|
|
|
break;
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
2011-11-03 13:21:53 +00:00
|
|
|
case MP_IMGTYPE_IP:
|
|
|
|
if (!vf->imgctx.static_images[vf->imgctx.static_idx])
|
|
|
|
vf->imgctx.static_images[vf->imgctx.static_idx] = new_mp_image(w2, h);
|
|
|
|
mpi = vf->imgctx.static_images[vf->imgctx.static_idx];
|
|
|
|
vf->imgctx.static_idx ^= 1;
|
|
|
|
break;
|
|
|
|
case MP_IMGTYPE_NUMBERED:
|
|
|
|
if (number == -1) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < NUM_NUMBERED_MPI; i++)
|
|
|
|
if (!vf->imgctx.numbered_images[i] ||
|
|
|
|
!vf->imgctx.numbered_images[i]->usage_count)
|
|
|
|
break;
|
|
|
|
number = i;
|
|
|
|
}
|
|
|
|
if (number < 0 || number >= NUM_NUMBERED_MPI)
|
|
|
|
return NULL;
|
|
|
|
if (!vf->imgctx.numbered_images[number])
|
|
|
|
vf->imgctx.numbered_images[number] = new_mp_image(w2, h);
|
|
|
|
mpi = vf->imgctx.numbered_images[number];
|
|
|
|
mpi->number = number;
|
|
|
|
break;
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
2011-11-03 13:21:53 +00:00
|
|
|
if (mpi) {
|
|
|
|
mpi->type = mp_imgtype;
|
|
|
|
mpi->w = vf->w;
|
|
|
|
mpi->h = vf->h;
|
|
|
|
// keep buffer allocation status & color flags only:
|
|
|
|
mpi->flags &= MP_IMGFLAG_ALLOCATED | MP_IMGFLAG_TYPE_DISPLAYED |
|
|
|
|
MP_IMGFLAGMASK_COLORS;
|
|
|
|
// accept restrictions, draw_slice and palette flags only:
|
|
|
|
mpi->flags |= mp_imgflag & (MP_IMGFLAGMASK_RESTRICTIONS |
|
|
|
|
MP_IMGFLAG_DRAW_CALLBACK | MP_IMGFLAG_RGB_PALETTE);
|
|
|
|
if (!vf->draw_slice)
|
|
|
|
mpi->flags &= ~MP_IMGFLAG_DRAW_CALLBACK;
|
|
|
|
if (mpi->width != w2 || mpi->height != h) {
|
|
|
|
if (mpi->flags & MP_IMGFLAG_ALLOCATED) {
|
|
|
|
if (mpi->width < w2 || mpi->height < h) {
|
|
|
|
// need to re-allocate buffer memory:
|
|
|
|
av_free(mpi->planes[0]);
|
|
|
|
mpi->flags &= ~MP_IMGFLAG_ALLOCATED;
|
|
|
|
mp_msg(MSGT_VFILTER, MSGL_V,
|
|
|
|
"vf.c: have to REALLOCATE buffer memory :(\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mpi->width = w2;
|
|
|
|
mpi->chroma_width = (w2 + (1 << mpi->chroma_x_shift) - 1) >>
|
|
|
|
mpi->chroma_x_shift;
|
|
|
|
mpi->height = h;
|
|
|
|
mpi->chroma_height = (h + (1 << mpi->chroma_y_shift) - 1) >>
|
|
|
|
mpi->chroma_y_shift;
|
|
|
|
}
|
|
|
|
if (!mpi->bpp)
|
|
|
|
mp_image_setfmt(mpi, outfmt);
|
|
|
|
if (!(mpi->flags & MP_IMGFLAG_ALLOCATED) &&
|
|
|
|
mpi->type > MP_IMGTYPE_EXPORT) {
|
|
|
|
// check libvo first!
|
|
|
|
if (vf->get_image)
|
|
|
|
vf->get_image(vf, mpi);
|
|
|
|
|
|
|
|
if (!(mpi->flags & MP_IMGFLAG_DIRECT)) {
|
|
|
|
// non-direct and not yet allocated image. allocate it!
|
|
|
|
if (!mpi->bpp) { // no way we can allocate this
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_FATAL,
|
|
|
|
"vf_get_image: Tried to allocate a format that "
|
|
|
|
"can not be allocated!\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// check if codec prefer aligned stride:
|
|
|
|
if (mp_imgflag & MP_IMGFLAG_PREFER_ALIGNED_STRIDE) {
|
|
|
|
int align = (mpi->flags & MP_IMGFLAG_PLANAR &&
|
|
|
|
mpi->flags & MP_IMGFLAG_YUV) ?
|
|
|
|
(8 << mpi->chroma_x_shift) - 1 : 15; // OK?
|
|
|
|
w2 = ((w + align) & (~align));
|
|
|
|
if (mpi->width != w2) {
|
|
|
|
// we have to change width... check if we CAN co it:
|
|
|
|
int flags = vf->query_format(vf, outfmt);
|
|
|
|
// should not fail
|
2011-11-03 13:47:50 +00:00
|
|
|
if (!(flags & (VFCAP_CSP_SUPPORTED |
|
|
|
|
VFCAP_CSP_SUPPORTED_BY_HW)))
|
2011-11-03 13:21:53 +00:00
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_WARN,
|
|
|
|
"??? vf_get_image{vf->query_format(outfmt)} "
|
|
|
|
"failed!\n");
|
|
|
|
if (flags & VFCAP_ACCEPT_STRIDE) {
|
|
|
|
mpi->width = w2;
|
|
|
|
mpi->chroma_width =
|
|
|
|
(w2 + (1 << mpi->chroma_x_shift) - 1) >>
|
|
|
|
mpi->chroma_x_shift;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mp_image_alloc_planes(mpi);
|
|
|
|
vf_mpi_clear(mpi, 0, 0, mpi->width, mpi->height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)
|
|
|
|
if (vf->start_slice)
|
|
|
|
vf->start_slice(vf, mpi);
|
|
|
|
if (!(mpi->flags & MP_IMGFLAG_TYPE_DISPLAYED)) {
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_V,
|
|
|
|
"*** [%s] %s%s mp_image_t, %dx%dx%dbpp %s %s, %d bytes\n",
|
|
|
|
vf->info->name,
|
|
|
|
(mpi->type == MP_IMGTYPE_EXPORT) ? "Exporting" :
|
|
|
|
((mpi->flags & MP_IMGFLAG_DIRECT) ?
|
|
|
|
"Direct Rendering" : "Allocating"),
|
|
|
|
(mpi->flags & MP_IMGFLAG_DRAW_CALLBACK) ? " (slices)" : "",
|
|
|
|
mpi->width, mpi->height, mpi->bpp,
|
|
|
|
(mpi->flags & MP_IMGFLAG_YUV) ? "YUV" :
|
|
|
|
((mpi->flags & MP_IMGFLAG_SWAPPED) ? "BGR" : "RGB"),
|
|
|
|
(mpi->flags & MP_IMGFLAG_PLANAR) ? "planar" : "packed",
|
|
|
|
mpi->bpp * mpi->width * mpi->height / 8);
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "(imgfmt: %x, planes: %p,%p,%p "
|
|
|
|
"strides: %d,%d,%d, chroma: %dx%d, shift: h:%d,v:%d)\n",
|
|
|
|
mpi->imgfmt, mpi->planes[0], mpi->planes[1], mpi->planes[2],
|
|
|
|
mpi->stride[0], mpi->stride[1], mpi->stride[2],
|
|
|
|
mpi->chroma_width, mpi->chroma_height,
|
|
|
|
mpi->chroma_x_shift, mpi->chroma_y_shift);
|
|
|
|
mpi->flags |= MP_IMGFLAG_TYPE_DISPLAYED;
|
|
|
|
}
|
|
|
|
mpi->qscale = NULL;
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
2011-11-03 13:21:53 +00:00
|
|
|
mpi->usage_count++;
|
|
|
|
return mpi;
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//============================================================================
|
|
|
|
|
2002-10-30 17:48:39 +00:00
|
|
|
// By default vf doesn't accept MPEGPES
|
2011-11-03 13:21:53 +00:00
|
|
|
static int vf_default_query_format(struct vf_instance *vf, unsigned int fmt)
|
|
|
|
{
|
|
|
|
if (fmt == IMGFMT_MPEGPES)
|
|
|
|
return 0;
|
|
|
|
return vf_next_query_format(vf, fmt);
|
2002-10-30 17:48:39 +00:00
|
|
|
}
|
|
|
|
|
2010-01-16 18:37:13 +00:00
|
|
|
struct vf_instance *vf_open_plugin_noerr(struct MPOpts *opts,
|
2011-11-03 13:21:53 +00:00
|
|
|
const vf_info_t *const *filter_list,
|
2010-01-16 18:37:13 +00:00
|
|
|
vf_instance_t *next, const char *name,
|
|
|
|
char **args, int *retcode)
|
|
|
|
{
|
2011-11-03 13:21:53 +00:00
|
|
|
vf_instance_t *vf;
|
2002-04-06 22:05:01 +00:00
|
|
|
int i;
|
2011-11-03 13:21:53 +00:00
|
|
|
for (i = 0;; i++) {
|
|
|
|
if (!filter_list[i]) {
|
|
|
|
mp_tmsg(MSGT_VFILTER, MSGL_ERR,
|
|
|
|
"Couldn't find video filter '%s'.\n", name);
|
|
|
|
return NULL; // no such filter!
|
|
|
|
}
|
|
|
|
if (!strcmp(filter_list[i]->name, name))
|
|
|
|
break;
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
2008-04-16 03:29:04 +00:00
|
|
|
vf = calloc(1, sizeof *vf);
|
2008-04-16 04:06:44 +00:00
|
|
|
vf->opts = opts;
|
2011-11-03 13:21:53 +00:00
|
|
|
vf->info = filter_list[i];
|
|
|
|
vf->next = next;
|
|
|
|
vf->config = vf_next_config;
|
|
|
|
vf->control = vf_next_control;
|
|
|
|
vf->query_format = vf_default_query_format;
|
|
|
|
vf->put_image = vf_next_put_image;
|
|
|
|
vf->default_caps = VFCAP_ACCEPT_STRIDE;
|
|
|
|
vf->default_reqs = 0;
|
|
|
|
if (vf->info->opts) { // vf_vo get some special argument
|
|
|
|
const m_struct_t *st = vf->info->opts;
|
|
|
|
void *vf_priv = m_struct_alloc(st);
|
|
|
|
int n;
|
|
|
|
for (n = 0; args && args[2 * n]; n++)
|
|
|
|
m_struct_set(st, vf_priv, args[2 * n], bstr(args[2 * n + 1]));
|
|
|
|
vf->priv = vf_priv;
|
|
|
|
args = NULL;
|
2003-03-15 18:01:02 +00:00
|
|
|
} else // Otherwise we should have the '_oldargs_'
|
2011-11-03 13:21:53 +00:00
|
|
|
if (args && !strcmp(args[0], "_oldargs_"))
|
|
|
|
args = (char **)args[1];
|
|
|
|
else
|
|
|
|
args = NULL;
|
|
|
|
*retcode = vf->info->vf_open(vf, (char *)args);
|
2010-01-16 18:37:13 +00:00
|
|
|
if (*retcode > 0)
|
|
|
|
return vf;
|
2002-04-06 22:05:01 +00:00
|
|
|
free(vf);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-01-16 18:37:13 +00:00
|
|
|
struct vf_instance *vf_open_plugin(struct MPOpts *opts,
|
2011-11-03 13:21:53 +00:00
|
|
|
const vf_info_t *const *filter_list,
|
2010-01-16 18:37:13 +00:00
|
|
|
vf_instance_t *next, const char *name,
|
|
|
|
char **args)
|
|
|
|
{
|
|
|
|
struct vf_instance *vf = vf_open_plugin_noerr(opts, filter_list, next,
|
|
|
|
name, args, &(int){0});
|
|
|
|
if (!vf)
|
|
|
|
mp_tmsg(MSGT_VFILTER, MSGL_ERR, "Couldn't open video filter '%s'.\n",
|
|
|
|
name);
|
|
|
|
return vf;
|
|
|
|
}
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
vf_instance_t *vf_open_filter(struct MPOpts *opts, vf_instance_t *next,
|
|
|
|
const char *name, char **args)
|
|
|
|
{
|
|
|
|
if (args && strcmp(args[0], "_oldargs_")) {
|
|
|
|
int i, l = 0;
|
|
|
|
for (i = 0; args && args[2 * i]; i++)
|
|
|
|
l += 1 + strlen(args[2 * i]) + 1 + strlen(args[2 * i + 1]);
|
|
|
|
l += strlen(name);
|
|
|
|
{
|
|
|
|
char str[l + 1];
|
|
|
|
char *p = str;
|
|
|
|
p += sprintf(str, "%s", name);
|
|
|
|
for (i = 0; args && args[2 * i]; i++)
|
|
|
|
p += sprintf(p, " %s=%s", args[2 * i], args[2 * i + 1]);
|
|
|
|
mp_msg(MSGT_VFILTER, MSGL_INFO, "%s[%s]\n",
|
|
|
|
mp_gtext("Opening video filter: "), str);
|
|
|
|
}
|
|
|
|
} else if (strcmp(name, "vo")) {
|
|
|
|
if (args && strcmp(args[0], "_oldargs_") == 0)
|
|
|
|
mp_msg(MSGT_VFILTER, MSGL_INFO, "%s[%s=%s]\n",
|
|
|
|
mp_gtext("Opening video filter: "), name, args[1]);
|
|
|
|
else
|
|
|
|
mp_msg(MSGT_VFILTER, MSGL_INFO, "%s[%s]\n",
|
|
|
|
mp_gtext("Opening video filter: "), name);
|
2003-03-15 18:01:02 +00:00
|
|
|
}
|
2011-11-03 13:21:53 +00:00
|
|
|
return vf_open_plugin(opts, filter_list, next, name, args);
|
2002-04-10 23:23:36 +00:00
|
|
|
}
|
|
|
|
|
2004-12-18 14:06:35 +00:00
|
|
|
/**
|
|
|
|
* \brief adds a filter before the last one (which should be the vo filter).
|
|
|
|
* \param vf start of the filter chain.
|
|
|
|
* \param name name of the filter to add.
|
|
|
|
* \param args argument list for the filter.
|
|
|
|
* \return pointer to the filter instance that was created.
|
|
|
|
*/
|
2011-11-03 13:21:53 +00:00
|
|
|
vf_instance_t *vf_add_before_vo(vf_instance_t **vf, char *name, char **args)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = (*vf)->opts;
|
|
|
|
vf_instance_t *vo, *prev = NULL, *new;
|
|
|
|
// Find the last filter (should be vf_vo)
|
|
|
|
for (vo = *vf; vo->next; vo = vo->next)
|
|
|
|
prev = vo;
|
|
|
|
new = vf_open_filter(opts, vo, name, args);
|
|
|
|
if (prev)
|
|
|
|
prev->next = new;
|
|
|
|
else
|
|
|
|
*vf = new;
|
|
|
|
return new;
|
2004-12-18 14:06:35 +00:00
|
|
|
}
|
|
|
|
|
2002-04-06 22:05:01 +00:00
|
|
|
//============================================================================
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
unsigned int vf_match_csp(vf_instance_t **vfp, const unsigned int *list,
|
|
|
|
unsigned int preferred)
|
|
|
|
{
|
|
|
|
vf_instance_t *vf = *vfp;
|
2008-04-16 04:06:44 +00:00
|
|
|
struct MPOpts *opts = vf->opts;
|
2011-11-03 13:21:53 +00:00
|
|
|
const unsigned int *p;
|
|
|
|
unsigned int best = 0;
|
2002-04-11 20:56:17 +00:00
|
|
|
int ret;
|
2011-11-03 13:21:53 +00:00
|
|
|
if ((p = list))
|
|
|
|
while (*p) {
|
|
|
|
ret = vf->query_format(vf, *p);
|
2011-11-03 13:47:50 +00:00
|
|
|
mp_msg(MSGT_VFILTER, MSGL_V, "[%s] query(%s) -> %x\n",
|
|
|
|
vf->info->name, vo_format_name(*p), ret);
|
|
|
|
if (ret & VFCAP_CSP_SUPPORTED_BY_HW) {
|
2011-11-03 13:21:53 +00:00
|
|
|
best = *p;
|
|
|
|
break;
|
2011-11-03 13:47:50 +00:00
|
|
|
}
|
|
|
|
if (ret & VFCAP_CSP_SUPPORTED && !best)
|
|
|
|
best = *p;
|
2011-11-03 13:21:53 +00:00
|
|
|
++p;
|
|
|
|
}
|
|
|
|
if (best)
|
|
|
|
return best; // bingo, they have common csp!
|
2002-04-11 20:56:17 +00:00
|
|
|
// ok, then try with scale:
|
2011-11-03 13:21:53 +00:00
|
|
|
if (vf->info == &vf_info_scale)
|
|
|
|
return 0; // avoid infinite recursion!
|
|
|
|
vf = vf_open_filter(opts, vf, "scale", NULL);
|
|
|
|
if (!vf)
|
|
|
|
return 0; // failed to init "scale"
|
2002-04-11 20:56:17 +00:00
|
|
|
// try the preferred csp first:
|
2011-11-03 13:21:53 +00:00
|
|
|
if (preferred && vf->query_format(vf, preferred))
|
|
|
|
best = preferred;
|
|
|
|
else
|
|
|
|
// try the list again, now with "scaler" :
|
|
|
|
if ((p = list))
|
|
|
|
while (*p) {
|
|
|
|
ret = vf->query_format(vf, *p);
|
2011-11-03 13:47:50 +00:00
|
|
|
mp_msg(MSGT_VFILTER, MSGL_V, "[%s] query(%s) -> %x\n",
|
|
|
|
vf->info->name, vo_format_name(*p), ret);
|
|
|
|
if (ret & VFCAP_CSP_SUPPORTED_BY_HW) {
|
2011-11-03 13:21:53 +00:00
|
|
|
best = *p;
|
|
|
|
break;
|
|
|
|
}
|
2011-11-03 13:47:50 +00:00
|
|
|
if (ret & VFCAP_CSP_SUPPORTED && !best)
|
|
|
|
best = *p;
|
2011-11-03 13:21:53 +00:00
|
|
|
++p;
|
|
|
|
}
|
|
|
|
if (best)
|
|
|
|
*vfp = vf; // else uninit vf !FIXME!
|
2002-04-11 20:56:17 +00:00
|
|
|
return best;
|
|
|
|
}
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
void vf_clone_mpi_attributes(mp_image_t *dst, mp_image_t *src)
|
|
|
|
{
|
|
|
|
dst->pict_type = src->pict_type;
|
2003-08-18 14:49:06 +00:00
|
|
|
dst->fields = src->fields;
|
2011-11-03 13:21:53 +00:00
|
|
|
dst->qscale_type = src->qscale_type;
|
|
|
|
if (dst->width == src->width && dst->height == src->height) {
|
|
|
|
dst->qstride = src->qstride;
|
|
|
|
dst->qscale = src->qscale;
|
2003-04-19 02:48:53 +00:00
|
|
|
}
|
|
|
|
}
|
2006-07-06 06:58:17 +00:00
|
|
|
|
|
|
|
void vf_queue_frame(vf_instance_t *vf, int (*func)(vf_instance_t *))
|
|
|
|
{
|
|
|
|
vf->continue_buffered_image = func;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Output the next buffered image (if any) from the filter chain.
|
|
|
|
// The queue could be kept as a simple stack/list instead avoiding the
|
|
|
|
// looping here, but there's currently no good context variable where
|
|
|
|
// that could be stored so this was easier to implement.
|
|
|
|
|
|
|
|
int vf_output_queued_frame(vf_instance_t *vf)
|
|
|
|
{
|
|
|
|
while (1) {
|
2011-11-03 13:21:53 +00:00
|
|
|
int ret;
|
|
|
|
vf_instance_t *current;
|
|
|
|
vf_instance_t *last = NULL;
|
|
|
|
int (*tmp)(vf_instance_t *);
|
|
|
|
for (current = vf; current; current = current->next)
|
|
|
|
if (current->continue_buffered_image)
|
|
|
|
last = current;
|
|
|
|
if (!last)
|
|
|
|
return 0;
|
|
|
|
tmp = last->continue_buffered_image;
|
|
|
|
last->continue_buffered_image = NULL;
|
|
|
|
ret = tmp(last);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2006-07-06 06:58:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-03-01 20:21:58 +00:00
|
|
|
/**
|
|
|
|
* \brief Video config() function wrapper
|
|
|
|
*
|
|
|
|
* Blocks config() calls with different size or format for filters
|
|
|
|
* with VFCAP_CONSTANT
|
|
|
|
*
|
|
|
|
* First call is redirected to vf->config.
|
|
|
|
*
|
|
|
|
* In following calls, it verifies that the configuration parameters
|
|
|
|
* are unchanged, and returns either success or error.
|
|
|
|
*
|
2011-11-03 13:21:53 +00:00
|
|
|
*/
|
2010-05-29 14:15:55 +00:00
|
|
|
int vf_config_wrapper(struct vf_instance *vf,
|
2011-11-03 13:21:53 +00:00
|
|
|
int width, int height, int d_width, int d_height,
|
|
|
|
unsigned int flags, unsigned int outfmt)
|
2005-03-01 20:21:58 +00:00
|
|
|
{
|
2005-12-16 18:32:58 +00:00
|
|
|
int r;
|
2011-11-03 13:21:53 +00:00
|
|
|
if ((vf->default_caps & VFCAP_CONSTANT) && vf->fmt.have_configured) {
|
2005-03-01 20:21:58 +00:00
|
|
|
if ((vf->fmt.orig_width != width)
|
2011-11-03 13:21:53 +00:00
|
|
|
|| (vf->fmt.orig_height != height)
|
|
|
|
|| (vf->fmt.orig_fmt != outfmt)) {
|
|
|
|
mp_tmsg(MSGT_VFILTER, MSGL_ERR, "\nNew video file has different "
|
|
|
|
"resolution or colorspace than the previous one.\n");
|
2005-03-01 20:21:58 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
vf->fmt.have_configured = 1;
|
|
|
|
vf->fmt.orig_height = height;
|
|
|
|
vf->fmt.orig_width = width;
|
|
|
|
vf->fmt.orig_fmt = outfmt;
|
2005-12-16 18:32:58 +00:00
|
|
|
r = vf->config(vf, width, height, d_width, d_height, flags, outfmt);
|
2011-11-03 13:21:53 +00:00
|
|
|
if (!r)
|
|
|
|
vf->fmt.have_configured = 0;
|
2005-12-16 18:32:58 +00:00
|
|
|
return r;
|
2005-03-01 20:21:58 +00:00
|
|
|
}
|
2003-04-19 02:48:53 +00:00
|
|
|
|
2010-05-29 14:15:55 +00:00
|
|
|
int vf_next_config(struct vf_instance *vf,
|
2011-11-03 13:21:53 +00:00
|
|
|
int width, int height, int d_width, int d_height,
|
|
|
|
unsigned int voflags, unsigned int outfmt)
|
|
|
|
{
|
2008-04-16 04:06:44 +00:00
|
|
|
struct MPOpts *opts = vf->opts;
|
2002-04-11 20:56:17 +00:00
|
|
|
int miss;
|
2011-11-03 13:21:53 +00:00
|
|
|
int flags = vf->next->query_format(vf->next, outfmt);
|
|
|
|
if (!flags) {
|
|
|
|
// hmm. colorspace mismatch!!!
|
|
|
|
// let's insert the 'scale' filter, it does the job for us:
|
|
|
|
vf_instance_t *vf2;
|
|
|
|
if (vf->next->info == &vf_info_scale)
|
|
|
|
return 0; // scale->scale
|
|
|
|
vf2 = vf_open_filter(opts, vf->next, "scale", NULL);
|
|
|
|
if (!vf2)
|
|
|
|
return 0; // shouldn't happen!
|
|
|
|
vf->next = vf2;
|
|
|
|
flags = vf->next->query_format(vf->next, outfmt);
|
|
|
|
if (!flags) {
|
|
|
|
mp_tmsg(MSGT_VFILTER, MSGL_ERR, "Cannot find matching colorspace, "
|
|
|
|
"even by inserting 'scale' :(\n");
|
|
|
|
return 0; // FAIL
|
|
|
|
}
|
2002-04-11 20:56:17 +00:00
|
|
|
}
|
2011-11-03 13:21:53 +00:00
|
|
|
mp_msg(MSGT_VFILTER, MSGL_V, "REQ: flags=0x%X req=0x%X \n",
|
|
|
|
flags, vf->default_reqs);
|
|
|
|
miss = vf->default_reqs - (flags & vf->default_reqs);
|
|
|
|
if (miss & VFCAP_ACCEPT_STRIDE) {
|
|
|
|
// vf requires stride support but vf->next doesn't support it!
|
|
|
|
// let's insert the 'expand' filter, it does the job for us:
|
|
|
|
vf_instance_t *vf2 = vf_open_filter(opts, vf->next, "expand", NULL);
|
|
|
|
if (!vf2)
|
|
|
|
return 0; // shouldn't happen!
|
|
|
|
vf->next = vf2;
|
2002-04-11 20:56:17 +00:00
|
|
|
}
|
2011-11-03 13:21:53 +00:00
|
|
|
vf->next->w = width;
|
|
|
|
vf->next->h = height;
|
|
|
|
return vf_config_wrapper(vf->next, width, height, d_width, d_height,
|
|
|
|
voflags, outfmt);
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
int vf_next_control(struct vf_instance *vf, int request, void *data)
|
|
|
|
{
|
|
|
|
return vf->next->control(vf->next, request, data);
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
int vf_next_query_format(struct vf_instance *vf, unsigned int fmt)
|
|
|
|
{
|
|
|
|
int flags = vf->next->query_format(vf->next, fmt);
|
|
|
|
if (flags)
|
|
|
|
flags |= vf->default_caps;
|
2002-04-11 20:56:17 +00:00
|
|
|
return flags;
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
int vf_next_put_image(struct vf_instance *vf, mp_image_t *mpi, double pts)
|
|
|
|
{
|
|
|
|
return vf->next->put_image(vf->next, mpi, pts);
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
void vf_next_draw_slice(struct vf_instance *vf, unsigned char **src,
|
|
|
|
int *stride, int w, int h, int x, int y)
|
|
|
|
{
|
2003-05-20 17:42:33 +00:00
|
|
|
if (vf->next->draw_slice) {
|
2011-11-03 13:21:53 +00:00
|
|
|
vf->next->draw_slice(vf->next, src, stride, w, h, x, y);
|
|
|
|
return;
|
2003-05-20 17:42:33 +00:00
|
|
|
}
|
|
|
|
if (!vf->dmpi) {
|
2011-11-03 13:21:53 +00:00
|
|
|
mp_msg(MSGT_VFILTER, MSGL_ERR,
|
|
|
|
"draw_slice: dmpi not stored by vf_%s\n", vf->info->name);
|
|
|
|
return;
|
2003-05-20 17:42:33 +00:00
|
|
|
}
|
|
|
|
if (!(vf->dmpi->flags & MP_IMGFLAG_PLANAR)) {
|
2011-11-03 13:21:53 +00:00
|
|
|
memcpy_pic(vf->dmpi->planes[0] + y * vf->dmpi->stride[0] +
|
|
|
|
vf->dmpi->bpp / 8 * x,
|
|
|
|
src[0], vf->dmpi->bpp / 8 * w, h, vf->dmpi->stride[0],
|
|
|
|
stride[0]);
|
|
|
|
return;
|
2003-05-20 17:42:33 +00:00
|
|
|
}
|
2011-11-03 13:21:53 +00:00
|
|
|
memcpy_pic(vf->dmpi->planes[0] + y * vf->dmpi->stride[0] + x, src[0],
|
|
|
|
w, h, vf->dmpi->stride[0], stride[0]);
|
|
|
|
memcpy_pic(vf->dmpi->planes[1]
|
|
|
|
+ (y >> vf->dmpi->chroma_y_shift) * vf->dmpi->stride[1]
|
|
|
|
+ (x >> vf->dmpi->chroma_x_shift),
|
|
|
|
src[1], w >> vf->dmpi->chroma_x_shift,
|
|
|
|
h >> vf->dmpi->chroma_y_shift, vf->dmpi->stride[1], stride[1]);
|
|
|
|
memcpy_pic(vf->dmpi->planes[2]
|
|
|
|
+ (y >> vf->dmpi->chroma_y_shift) * vf->dmpi->stride[2]
|
|
|
|
+ (x >> vf->dmpi->chroma_x_shift),
|
|
|
|
src[2], w >> vf->dmpi->chroma_x_shift,
|
|
|
|
h >> vf->dmpi->chroma_y_shift, vf->dmpi->stride[2], stride[2]);
|
2002-12-05 00:22:37 +00:00
|
|
|
}
|
|
|
|
|
2002-04-06 22:05:01 +00:00
|
|
|
//============================================================================
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
vf_instance_t *append_filters(vf_instance_t *last,
|
2008-04-25 10:58:12 +00:00
|
|
|
struct m_obj_settings *vf_settings)
|
|
|
|
{
|
2011-11-03 13:21:53 +00:00
|
|
|
struct MPOpts *opts = last->opts;
|
|
|
|
vf_instance_t *vf;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (vf_settings) {
|
|
|
|
// We want to add them in the 'right order'
|
|
|
|
for (i = 0; vf_settings[i].name; i++)
|
|
|
|
/* NOP */;
|
|
|
|
for (i--; i >= 0; i--) {
|
|
|
|
//printf("Open filter %s\n",vf_settings[i].name);
|
|
|
|
vf = vf_open_filter(opts, last, vf_settings[i].name,
|
|
|
|
vf_settings[i].attribs);
|
|
|
|
if (vf)
|
|
|
|
last = vf;
|
|
|
|
}
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
2011-11-03 13:21:53 +00:00
|
|
|
return last;
|
2002-04-06 22:05:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//============================================================================
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
void vf_uninit_filter(vf_instance_t *vf)
|
|
|
|
{
|
|
|
|
if (vf->uninit)
|
|
|
|
vf->uninit(vf);
|
2002-04-20 22:24:19 +00:00
|
|
|
free_mp_image(vf->imgctx.static_images[0]);
|
|
|
|
free_mp_image(vf->imgctx.static_images[1]);
|
|
|
|
free_mp_image(vf->imgctx.temp_images[0]);
|
|
|
|
free_mp_image(vf->imgctx.export_images[0]);
|
2009-09-18 03:16:22 +00:00
|
|
|
for (int i = 0; i < NUM_NUMBERED_MPI; i++)
|
|
|
|
free_mp_image(vf->imgctx.numbered_images[i]);
|
2002-04-20 22:24:19 +00:00
|
|
|
free(vf);
|
|
|
|
}
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
void vf_uninit_filter_chain(vf_instance_t *vf)
|
|
|
|
{
|
|
|
|
while (vf) {
|
|
|
|
vf_instance_t *next = vf->next;
|
|
|
|
vf_uninit_filter(vf);
|
|
|
|
vf = next;
|
2002-04-20 22:24:19 +00:00
|
|
|
}
|
|
|
|
}
|
vf_*: fix pts values passed to the next filter
Many video filters failed to calculate or even just pass through pts
values for their output frames. Fix this, and also make the two
remaining filters that called vf_next_put_image() twice for the same
input frame (vf_softpulldown, vf_telecine) use vf_queue_frame() so
that e.g. framestepping properly sees both frames.
Changed filters: vf_bmovl, vf_detc, vf_divtc, vf_filmdint, vf_ivtc,
vf_lavc, vf_phase, vf_pullup, vf_softpulldown, vf_telecine, vf_tile,
vf_tinterlace.
2011-04-23 16:56:47 +00:00
|
|
|
|
|
|
|
void vf_detc_init_pts_buf(struct vf_detc_pts_buf *p)
|
|
|
|
{
|
|
|
|
p->inpts_prev = MP_NOPTS_VALUE;
|
|
|
|
p->outpts_prev = MP_NOPTS_VALUE;
|
|
|
|
p->lastdelta = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static double vf_detc_adjust_pts_internal(struct vf_detc_pts_buf *p,
|
|
|
|
double pts, bool reset_pattern,
|
|
|
|
bool skip_frame, double delta,
|
|
|
|
double boundfactor_minus,
|
|
|
|
double increasefactor,
|
|
|
|
double boundfactor_plus)
|
|
|
|
{
|
|
|
|
double newpts;
|
|
|
|
|
|
|
|
if (pts == MP_NOPTS_VALUE)
|
|
|
|
return pts;
|
|
|
|
|
|
|
|
if (delta <= 0) {
|
|
|
|
if (p->inpts_prev == MP_NOPTS_VALUE)
|
|
|
|
delta = 0;
|
2011-11-03 13:21:53 +00:00
|
|
|
else if (pts == p->inpts_prev)
|
vf_*: fix pts values passed to the next filter
Many video filters failed to calculate or even just pass through pts
values for their output frames. Fix this, and also make the two
remaining filters that called vf_next_put_image() twice for the same
input frame (vf_softpulldown, vf_telecine) use vf_queue_frame() so
that e.g. framestepping properly sees both frames.
Changed filters: vf_bmovl, vf_detc, vf_divtc, vf_filmdint, vf_ivtc,
vf_lavc, vf_phase, vf_pullup, vf_softpulldown, vf_telecine, vf_tile,
vf_tinterlace.
2011-04-23 16:56:47 +00:00
|
|
|
delta = p->lastdelta;
|
|
|
|
else
|
|
|
|
delta = pts - p->inpts_prev;
|
|
|
|
}
|
|
|
|
p->inpts_prev = pts;
|
|
|
|
p->lastdelta = delta;
|
|
|
|
|
|
|
|
if (skip_frame)
|
|
|
|
return MP_NOPTS_VALUE;
|
|
|
|
|
2011-11-03 13:21:53 +00:00
|
|
|
/* detect bogus deltas and then passthru pts (possibly caused by seeking,
|
|
|
|
* or bad input) */
|
|
|
|
if (p->outpts_prev == MP_NOPTS_VALUE || reset_pattern || delta <= 0.0 ||
|
|
|
|
delta >= 0.5)
|
vf_*: fix pts values passed to the next filter
Many video filters failed to calculate or even just pass through pts
values for their output frames. Fix this, and also make the two
remaining filters that called vf_next_put_image() twice for the same
input frame (vf_softpulldown, vf_telecine) use vf_queue_frame() so
that e.g. framestepping properly sees both frames.
Changed filters: vf_bmovl, vf_detc, vf_divtc, vf_filmdint, vf_ivtc,
vf_lavc, vf_phase, vf_pullup, vf_softpulldown, vf_telecine, vf_tile,
vf_tinterlace.
2011-04-23 16:56:47 +00:00
|
|
|
newpts = pts;
|
2011-11-03 13:21:53 +00:00
|
|
|
else {
|
vf_*: fix pts values passed to the next filter
Many video filters failed to calculate or even just pass through pts
values for their output frames. Fix this, and also make the two
remaining filters that called vf_next_put_image() twice for the same
input frame (vf_softpulldown, vf_telecine) use vf_queue_frame() so
that e.g. framestepping properly sees both frames.
Changed filters: vf_bmovl, vf_detc, vf_divtc, vf_filmdint, vf_ivtc,
vf_lavc, vf_phase, vf_pullup, vf_softpulldown, vf_telecine, vf_tile,
vf_tinterlace.
2011-04-23 16:56:47 +00:00
|
|
|
// turn 5 frames into 4
|
|
|
|
newpts = p->outpts_prev + delta * increasefactor;
|
|
|
|
|
|
|
|
// bound to input pts in a sensible way; these numbers come because we
|
|
|
|
// map frames the following way when ivtc'ing:
|
|
|
|
// 0/30 -> 0/24 diff=0
|
|
|
|
// 1/30 -> 1/24 diff=1/120
|
|
|
|
// 2/30 -> -
|
|
|
|
// 3/30 -> 2/24 diff=-1/60
|
|
|
|
// 4/30 -> 3/24 diff=-1/120
|
|
|
|
if (newpts < pts - delta * boundfactor_minus)
|
|
|
|
newpts = pts - delta * boundfactor_minus;
|
|
|
|
if (newpts > pts + delta * boundfactor_plus)
|
|
|
|
newpts = pts + delta * boundfactor_plus;
|
|
|
|
if (newpts < p->outpts_prev)
|
2011-11-03 13:21:53 +00:00
|
|
|
newpts = p->outpts_prev; // damage control
|
vf_*: fix pts values passed to the next filter
Many video filters failed to calculate or even just pass through pts
values for their output frames. Fix this, and also make the two
remaining filters that called vf_next_put_image() twice for the same
input frame (vf_softpulldown, vf_telecine) use vf_queue_frame() so
that e.g. framestepping properly sees both frames.
Changed filters: vf_bmovl, vf_detc, vf_divtc, vf_filmdint, vf_ivtc,
vf_lavc, vf_phase, vf_pullup, vf_softpulldown, vf_telecine, vf_tile,
vf_tinterlace.
2011-04-23 16:56:47 +00:00
|
|
|
}
|
|
|
|
p->outpts_prev = newpts;
|
|
|
|
|
|
|
|
return newpts;
|
|
|
|
}
|
|
|
|
|
|
|
|
double vf_detc_adjust_pts(struct vf_detc_pts_buf *p, double pts,
|
|
|
|
bool reset_pattern, bool skip_frame)
|
|
|
|
{
|
|
|
|
// standard telecine (see above)
|
|
|
|
return vf_detc_adjust_pts_internal(p, pts, reset_pattern, skip_frame,
|
|
|
|
0, 0.5, 1.25, 0.25);
|
|
|
|
}
|
|
|
|
|
|
|
|
double vf_softpulldown_adjust_pts(struct vf_detc_pts_buf *p, double pts,
|
|
|
|
bool reset_pattern, bool skip_frame,
|
|
|
|
int last_frame_duration)
|
|
|
|
{
|
|
|
|
// for the softpulldown filter we get:
|
|
|
|
// 0/60 -> 0/30
|
|
|
|
// 2/60 -> 1/30
|
|
|
|
// 5/60 -> 2/30
|
|
|
|
// 7/60 -> 3/30, 4/30
|
|
|
|
return vf_detc_adjust_pts_internal(p, pts, reset_pattern, skip_frame,
|
|
|
|
0, 1.0 / last_frame_duration,
|
|
|
|
2.0 / last_frame_duration,
|
|
|
|
1.0 / last_frame_duration);
|
|
|
|
}
|