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.
|
|
|
|
*/
|
|
|
|
|
2003-04-19 01:39:37 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
2005-11-18 14:39:25 +00:00
|
|
|
#include "config.h"
|
|
|
|
#include "mp_msg.h"
|
|
|
|
#include "cpudetect.h"
|
2003-04-19 01:39:37 +00:00
|
|
|
|
|
|
|
#include "img_format.h"
|
|
|
|
#include "mp_image.h"
|
|
|
|
#include "vf.h"
|
|
|
|
|
2005-11-18 14:39:25 +00:00
|
|
|
#include "libvo/fastmemcpy.h"
|
2003-04-19 01:39:37 +00:00
|
|
|
|
|
|
|
|
|
|
|
struct metrics {
|
|
|
|
/* difference: total, even lines, odd lines */
|
|
|
|
int d, e, o;
|
|
|
|
/* noise: temporal, spacial (current), spacial (past) */
|
|
|
|
int t, s, p;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct frameinfo {
|
|
|
|
/* peak, relative, mean */
|
|
|
|
struct metrics p, r, m;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct vf_priv_s {
|
|
|
|
struct frameinfo fi[2];
|
|
|
|
mp_image_t *dmpi;
|
|
|
|
int first;
|
|
|
|
int drop, lastdrop, dropnext;
|
|
|
|
int inframes, outframes;
|
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
|
|
|
struct vf_detc_pts_buf ptsbuf;
|
2003-04-19 01:39:37 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
F_DROP,
|
|
|
|
F_MERGE,
|
|
|
|
F_NEXT,
|
|
|
|
F_SHOW
|
|
|
|
};
|
|
|
|
|
2009-09-14 14:47:56 +00:00
|
|
|
#if HAVE_MMX && HAVE_EBX_AVAILABLE
|
2003-04-19 01:39:37 +00:00
|
|
|
static void block_diffs_MMX(struct metrics *m, unsigned char *old, unsigned char *new, int os, int ns)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
short out[24]; // output buffer for the partial metrics from the mmx code
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2008-10-16 18:59:27 +00:00
|
|
|
__asm__ (
|
2003-04-19 01:39:37 +00:00
|
|
|
"movl $4, %%ecx \n\t"
|
|
|
|
"pxor %%mm4, %%mm4 \n\t" // 4 even difference sums
|
|
|
|
"pxor %%mm5, %%mm5 \n\t" // 4 odd difference sums
|
|
|
|
"pxor %%mm7, %%mm7 \n\t" // all zeros
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2006-08-13 00:21:14 +00:00
|
|
|
ASMALIGN(4)
|
2003-04-19 01:39:37 +00:00
|
|
|
"1: \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-19 01:39:37 +00:00
|
|
|
// Even difference
|
2004-10-21 11:55:20 +00:00
|
|
|
"movq (%%"REG_S"), %%mm0 \n\t"
|
|
|
|
"movq (%%"REG_S"), %%mm2 \n\t"
|
|
|
|
"add %%"REG_a", %%"REG_S" \n\t"
|
|
|
|
"movq (%%"REG_D"), %%mm1 \n\t"
|
|
|
|
"add %%"REG_b", %%"REG_D" \n\t"
|
2003-04-19 01:39:37 +00:00
|
|
|
"psubusb %%mm1, %%mm2 \n\t"
|
|
|
|
"psubusb %%mm0, %%mm1 \n\t"
|
|
|
|
"movq %%mm2, %%mm0 \n\t"
|
|
|
|
"movq %%mm1, %%mm3 \n\t"
|
|
|
|
"punpcklbw %%mm7, %%mm0 \n\t"
|
|
|
|
"punpcklbw %%mm7, %%mm1 \n\t"
|
|
|
|
"punpckhbw %%mm7, %%mm2 \n\t"
|
|
|
|
"punpckhbw %%mm7, %%mm3 \n\t"
|
|
|
|
"paddw %%mm0, %%mm4 \n\t"
|
|
|
|
"paddw %%mm1, %%mm4 \n\t"
|
|
|
|
"paddw %%mm2, %%mm4 \n\t"
|
|
|
|
"paddw %%mm3, %%mm4 \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-19 01:39:37 +00:00
|
|
|
// Odd difference
|
2004-10-21 11:55:20 +00:00
|
|
|
"movq (%%"REG_S"), %%mm0 \n\t"
|
|
|
|
"movq (%%"REG_S"), %%mm2 \n\t"
|
|
|
|
"add %%"REG_a", %%"REG_S" \n\t"
|
|
|
|
"movq (%%"REG_D"), %%mm1 \n\t"
|
|
|
|
"add %%"REG_b", %%"REG_D" \n\t"
|
2003-04-19 01:39:37 +00:00
|
|
|
"psubusb %%mm1, %%mm2 \n\t"
|
|
|
|
"psubusb %%mm0, %%mm1 \n\t"
|
|
|
|
"movq %%mm2, %%mm0 \n\t"
|
|
|
|
"movq %%mm1, %%mm3 \n\t"
|
|
|
|
"punpcklbw %%mm7, %%mm0 \n\t"
|
|
|
|
"punpcklbw %%mm7, %%mm1 \n\t"
|
|
|
|
"punpckhbw %%mm7, %%mm2 \n\t"
|
|
|
|
"punpckhbw %%mm7, %%mm3 \n\t"
|
|
|
|
"paddw %%mm0, %%mm5 \n\t"
|
|
|
|
"paddw %%mm1, %%mm5 \n\t"
|
|
|
|
"paddw %%mm2, %%mm5 \n\t"
|
|
|
|
"paddw %%mm3, %%mm5 \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-19 01:39:37 +00:00
|
|
|
"decl %%ecx \n\t"
|
|
|
|
"jnz 1b \n\t"
|
2004-10-21 11:55:20 +00:00
|
|
|
"movq %%mm4, (%%"REG_d") \n\t"
|
|
|
|
"movq %%mm5, 8(%%"REG_d") \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
:
|
2003-04-19 01:39:37 +00:00
|
|
|
: "S" (old), "D" (new), "a" (os), "b" (ns), "d" (out)
|
|
|
|
: "memory"
|
|
|
|
);
|
|
|
|
m->e = out[0]+out[1]+out[2]+out[3];
|
|
|
|
m->o = out[4]+out[5]+out[6]+out[7];
|
|
|
|
m->d = m->e + m->o;
|
|
|
|
|
2008-10-16 18:59:27 +00:00
|
|
|
__asm__ (
|
2003-04-19 01:39:37 +00:00
|
|
|
// First loop to measure first four columns
|
|
|
|
"movl $4, %%ecx \n\t"
|
|
|
|
"pxor %%mm4, %%mm4 \n\t" // Past spacial noise
|
|
|
|
"pxor %%mm5, %%mm5 \n\t" // Temporal noise
|
|
|
|
"pxor %%mm6, %%mm6 \n\t" // Current spacial noise
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2006-08-13 00:21:14 +00:00
|
|
|
ASMALIGN(4)
|
2003-04-19 01:39:37 +00:00
|
|
|
"2: \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2004-10-21 11:55:20 +00:00
|
|
|
"movq (%%"REG_S"), %%mm0 \n\t"
|
|
|
|
"movq (%%"REG_S",%%"REG_a"), %%mm1 \n\t"
|
|
|
|
"add %%"REG_a", %%"REG_S" \n\t"
|
|
|
|
"add %%"REG_a", %%"REG_S" \n\t"
|
|
|
|
"movq (%%"REG_D"), %%mm2 \n\t"
|
|
|
|
"movq (%%"REG_D",%%"REG_b"), %%mm3 \n\t"
|
|
|
|
"add %%"REG_b", %%"REG_D" \n\t"
|
|
|
|
"add %%"REG_b", %%"REG_D" \n\t"
|
2003-04-19 01:39:37 +00:00
|
|
|
"punpcklbw %%mm7, %%mm0 \n\t"
|
|
|
|
"punpcklbw %%mm7, %%mm1 \n\t"
|
|
|
|
"punpcklbw %%mm7, %%mm2 \n\t"
|
|
|
|
"punpcklbw %%mm7, %%mm3 \n\t"
|
|
|
|
"paddw %%mm1, %%mm4 \n\t"
|
|
|
|
"paddw %%mm1, %%mm5 \n\t"
|
|
|
|
"paddw %%mm3, %%mm6 \n\t"
|
|
|
|
"psubw %%mm0, %%mm4 \n\t"
|
|
|
|
"psubw %%mm2, %%mm5 \n\t"
|
|
|
|
"psubw %%mm2, %%mm6 \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-19 01:39:37 +00:00
|
|
|
"decl %%ecx \n\t"
|
|
|
|
"jnz 2b \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-26 05:59:28 +00:00
|
|
|
"movq %%mm0, %%mm1 \n\t"
|
|
|
|
"movq %%mm0, %%mm2 \n\t"
|
|
|
|
"movq %%mm0, %%mm3 \n\t"
|
|
|
|
"pcmpgtw %%mm4, %%mm1 \n\t"
|
|
|
|
"pcmpgtw %%mm5, %%mm2 \n\t"
|
|
|
|
"pcmpgtw %%mm6, %%mm3 \n\t"
|
|
|
|
"pxor %%mm1, %%mm4 \n\t"
|
|
|
|
"pxor %%mm2, %%mm5 \n\t"
|
|
|
|
"pxor %%mm3, %%mm6 \n\t"
|
|
|
|
"psubw %%mm1, %%mm4 \n\t"
|
|
|
|
"psubw %%mm2, %%mm5 \n\t"
|
|
|
|
"psubw %%mm3, %%mm6 \n\t"
|
2004-10-21 11:55:20 +00:00
|
|
|
"movq %%mm4, (%%"REG_d") \n\t"
|
|
|
|
"movq %%mm5, 16(%%"REG_d") \n\t"
|
|
|
|
"movq %%mm6, 32(%%"REG_d") \n\t"
|
2003-04-19 01:39:37 +00:00
|
|
|
|
2004-10-21 11:55:20 +00:00
|
|
|
"mov %%"REG_a", %%"REG_c" \n\t"
|
|
|
|
"shl $3, %%"REG_c" \n\t"
|
|
|
|
"sub %%"REG_c", %%"REG_S" \n\t"
|
|
|
|
"mov %%"REG_b", %%"REG_c" \n\t"
|
|
|
|
"shl $3, %%"REG_c" \n\t"
|
|
|
|
"sub %%"REG_c", %%"REG_D" \n\t"
|
2003-04-19 01:39:37 +00:00
|
|
|
|
|
|
|
// Second loop for the last four columns
|
|
|
|
"movl $4, %%ecx \n\t"
|
|
|
|
"pxor %%mm4, %%mm4 \n\t"
|
|
|
|
"pxor %%mm5, %%mm5 \n\t"
|
|
|
|
"pxor %%mm6, %%mm6 \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2006-08-13 00:21:14 +00:00
|
|
|
ASMALIGN(4)
|
2003-04-19 01:39:37 +00:00
|
|
|
"3: \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2004-10-21 11:55:20 +00:00
|
|
|
"movq (%%"REG_S"), %%mm0 \n\t"
|
|
|
|
"movq (%%"REG_S",%%"REG_a"), %%mm1 \n\t"
|
|
|
|
"add %%"REG_a", %%"REG_S" \n\t"
|
|
|
|
"add %%"REG_a", %%"REG_S" \n\t"
|
|
|
|
"movq (%%"REG_D"), %%mm2 \n\t"
|
|
|
|
"movq (%%"REG_D",%%"REG_b"), %%mm3 \n\t"
|
|
|
|
"add %%"REG_b", %%"REG_D" \n\t"
|
|
|
|
"add %%"REG_b", %%"REG_D" \n\t"
|
2003-04-19 01:39:37 +00:00
|
|
|
"punpckhbw %%mm7, %%mm0 \n\t"
|
|
|
|
"punpckhbw %%mm7, %%mm1 \n\t"
|
|
|
|
"punpckhbw %%mm7, %%mm2 \n\t"
|
|
|
|
"punpckhbw %%mm7, %%mm3 \n\t"
|
|
|
|
"paddw %%mm1, %%mm4 \n\t"
|
|
|
|
"paddw %%mm1, %%mm5 \n\t"
|
|
|
|
"paddw %%mm3, %%mm6 \n\t"
|
|
|
|
"psubw %%mm0, %%mm4 \n\t"
|
|
|
|
"psubw %%mm2, %%mm5 \n\t"
|
|
|
|
"psubw %%mm2, %%mm6 \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-19 01:39:37 +00:00
|
|
|
"decl %%ecx \n\t"
|
|
|
|
"jnz 3b \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-26 05:59:28 +00:00
|
|
|
"movq %%mm0, %%mm1 \n\t"
|
|
|
|
"movq %%mm0, %%mm2 \n\t"
|
|
|
|
"movq %%mm0, %%mm3 \n\t"
|
|
|
|
"pcmpgtw %%mm4, %%mm1 \n\t"
|
|
|
|
"pcmpgtw %%mm5, %%mm2 \n\t"
|
|
|
|
"pcmpgtw %%mm6, %%mm3 \n\t"
|
|
|
|
"pxor %%mm1, %%mm4 \n\t"
|
|
|
|
"pxor %%mm2, %%mm5 \n\t"
|
|
|
|
"pxor %%mm3, %%mm6 \n\t"
|
|
|
|
"psubw %%mm1, %%mm4 \n\t"
|
|
|
|
"psubw %%mm2, %%mm5 \n\t"
|
|
|
|
"psubw %%mm3, %%mm6 \n\t"
|
2004-10-21 11:55:20 +00:00
|
|
|
"movq %%mm4, 8(%%"REG_d") \n\t"
|
|
|
|
"movq %%mm5, 24(%%"REG_d") \n\t"
|
|
|
|
"movq %%mm6, 40(%%"REG_d") \n\t"
|
2003-04-19 01:39:37 +00:00
|
|
|
|
|
|
|
"emms \n\t"
|
2009-07-06 23:26:13 +00:00
|
|
|
:
|
2004-10-21 11:55:20 +00:00
|
|
|
: "S" (old), "D" (new), "a" ((long)os), "b" ((long)ns), "d" (out)
|
2003-04-19 01:39:37 +00:00
|
|
|
: "memory"
|
|
|
|
);
|
|
|
|
m->p = m->t = m->s = 0;
|
|
|
|
for (i=0; i<8; i++) {
|
2003-04-26 05:59:28 +00:00
|
|
|
m->p += out[i];
|
|
|
|
m->t += out[8+i];
|
|
|
|
m->s += out[16+i];
|
2003-04-19 01:39:37 +00:00
|
|
|
}
|
|
|
|
//printf("e=%d o=%d d=%d p=%d t=%d s=%d\n", m->e, m->o, m->d, m->p, m->t, m->s);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//#define MAG(a) ((a)*(a))
|
2003-04-26 18:31:08 +00:00
|
|
|
//#define MAG(a) (abs(a))
|
|
|
|
#define MAG(a) (((a)^((a)>>31))-((a)>>31))
|
2003-04-19 01:39:37 +00:00
|
|
|
|
|
|
|
//#define LOWPASS(s) (((s)[-2] + 4*(s)[-1] + 6*(s)[0] + 4*(s)[1] + (s)[2])>>4)
|
|
|
|
//#define LOWPASS(s) (((s)[-1] + 2*(s)[0] + (s)[1])>>2)
|
|
|
|
#define LOWPASS(s) ((s)[0])
|
|
|
|
|
|
|
|
|
|
|
|
static void block_diffs_C(struct metrics *m, unsigned char *old, unsigned char *new, int os, int ns)
|
|
|
|
{
|
|
|
|
int x, y, e=0, o=0, s=0, p=0, t=0;
|
|
|
|
unsigned char *oldp, *newp;
|
|
|
|
m->s = m->p = m->t = 0;
|
|
|
|
for (x = 8; x; x--) {
|
|
|
|
oldp = old++;
|
|
|
|
newp = new++;
|
|
|
|
s = p = t = 0;
|
|
|
|
for (y = 4; y; y--) {
|
|
|
|
e += MAG(newp[0]-oldp[0]);
|
|
|
|
o += MAG(newp[ns]-oldp[os]);
|
|
|
|
s += newp[ns]-newp[0];
|
|
|
|
p += oldp[os]-oldp[0];
|
|
|
|
t += oldp[os]-newp[0];
|
|
|
|
oldp += os<<1;
|
|
|
|
newp += ns<<1;
|
|
|
|
}
|
|
|
|
m->s += MAG(s);
|
|
|
|
m->p += MAG(p);
|
|
|
|
m->t += MAG(t);
|
|
|
|
}
|
|
|
|
m->e = e;
|
|
|
|
m->o = o;
|
|
|
|
m->d = e+o;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void (*block_diffs)(struct metrics *, unsigned char *, unsigned char *, int, int);
|
|
|
|
|
|
|
|
#define MAXUP(a,b) ((a) = ((a)>(b)) ? (a) : (b))
|
|
|
|
|
|
|
|
static void diff_planes(struct frameinfo *fi,
|
|
|
|
unsigned char *old, unsigned char *new, int w, int h, int os, int ns)
|
|
|
|
{
|
|
|
|
int x, y;
|
|
|
|
struct metrics l;
|
|
|
|
struct metrics *peak=&fi->p, *rel=&fi->r, *mean=&fi->m;
|
|
|
|
memset(peak, 0, sizeof(struct metrics));
|
|
|
|
memset(rel, 0, sizeof(struct metrics));
|
|
|
|
memset(mean, 0, sizeof(struct metrics));
|
|
|
|
for (y = 0; y < h-7; y += 8) {
|
|
|
|
for (x = 8; x < w-8-7; x += 8) {
|
|
|
|
block_diffs(&l, old+x+y*os, new+x+y*ns, os, ns);
|
|
|
|
mean->d += l.d;
|
|
|
|
mean->e += l.e;
|
|
|
|
mean->o += l.o;
|
|
|
|
mean->s += l.s;
|
|
|
|
mean->p += l.p;
|
|
|
|
mean->t += l.t;
|
|
|
|
MAXUP(peak->d, l.d);
|
|
|
|
MAXUP(peak->e, l.e);
|
|
|
|
MAXUP(peak->o, l.o);
|
|
|
|
MAXUP(peak->s, l.s);
|
|
|
|
MAXUP(peak->p, l.p);
|
|
|
|
MAXUP(peak->t, l.t);
|
|
|
|
MAXUP(rel->e, l.e-l.o);
|
|
|
|
MAXUP(rel->o, l.o-l.e);
|
|
|
|
MAXUP(rel->s, l.s-l.t);
|
|
|
|
MAXUP(rel->p, l.p-l.t);
|
|
|
|
MAXUP(rel->t, l.t-l.p);
|
|
|
|
MAXUP(rel->d, l.t-l.s); /* hack */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
x = (w/8-2)*(h/8);
|
|
|
|
mean->d /= x;
|
|
|
|
mean->e /= x;
|
|
|
|
mean->o /= x;
|
|
|
|
mean->s /= x;
|
|
|
|
mean->p /= x;
|
|
|
|
mean->t /= x;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void diff_fields(struct frameinfo *fi, mp_image_t *old, mp_image_t *new)
|
|
|
|
{
|
|
|
|
diff_planes(fi, old->planes[0], new->planes[0],
|
|
|
|
new->w, new->h, old->stride[0], new->stride[0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stats(struct frameinfo *f)
|
|
|
|
{
|
|
|
|
mp_msg(MSGT_VFILTER, MSGL_V, " pd=%d re=%d ro=%d rp=%d rt=%d rs=%d rd=%d pp=%d pt=%d ps=%d\r",
|
|
|
|
f->p.d, f->r.e, f->r.o, f->r.p, f->r.t, f->r.s, f->r.d, f->p.p, f->p.t, f->p.s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int foo(struct vf_priv_s *p, mp_image_t *new, mp_image_t *cur)
|
|
|
|
{
|
|
|
|
struct frameinfo *f = p->fi;
|
|
|
|
|
|
|
|
f[0] = f[1];
|
|
|
|
diff_fields(&f[1], cur, new);
|
|
|
|
stats(&f[1]);
|
|
|
|
|
|
|
|
// Immediately drop this frame if it's already been used.
|
|
|
|
if (p->dropnext) {
|
|
|
|
p->dropnext = 0;
|
|
|
|
return F_DROP;
|
|
|
|
}
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-19 01:39:37 +00:00
|
|
|
// Sometimes a pulldown frame comes all by itself, so both
|
|
|
|
// its top and bottom field are duplicates from the adjacent
|
|
|
|
// two frames. We can just drop such a frame, but we
|
|
|
|
// immediately show the next frame instead to keep the frame
|
|
|
|
// drops evenly spaced during normal 3:2 pulldown sequences.
|
|
|
|
if ((3*f[1].r.o < f[1].r.e) && (f[1].r.s < f[1].r.d)) {
|
|
|
|
p->dropnext = 1;
|
|
|
|
return F_NEXT;
|
|
|
|
}
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-19 01:39:37 +00:00
|
|
|
// If none of these conditions hold, we will consider the frame
|
|
|
|
// progressive and just show it as-is.
|
|
|
|
if (!( (3*f[0].r.e < f[0].r.o) ||
|
|
|
|
((2*f[0].r.d < f[0].r.s) && (f[0].r.s > 1200)) ||
|
|
|
|
((2*f[1].r.t < f[1].r.p) && (f[1].r.p > 1200)) ))
|
|
|
|
return F_SHOW;
|
|
|
|
|
|
|
|
// Otherwise, we have to decide whether to merge or drop.
|
|
|
|
// If the noise metric only increases minimally, we're off
|
|
|
|
// to a good start...
|
|
|
|
if (((2*f[1].r.t < 3*f[1].r.p) && (f[1].r.t < 3600)) ||
|
|
|
|
(f[1].r.t < 900) || (f[1].r.d < 900)) {
|
|
|
|
// ...and if noise decreases or the duplicate even field
|
|
|
|
// is detected, we go ahead with the merge.
|
|
|
|
if ((3*f[0].r.e < f[0].r.o) || (2*f[1].r.t < f[1].r.p)) {
|
|
|
|
p->dropnext = 1;
|
|
|
|
return F_MERGE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return F_DROP;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void copy_image(mp_image_t *dmpi, mp_image_t *mpi, int field)
|
|
|
|
{
|
|
|
|
switch (field) {
|
|
|
|
case 0:
|
|
|
|
my_memcpy_pic(dmpi->planes[0], mpi->planes[0], mpi->w, mpi->h/2,
|
|
|
|
dmpi->stride[0]*2, mpi->stride[0]*2);
|
|
|
|
if (mpi->flags & MP_IMGFLAG_PLANAR) {
|
|
|
|
my_memcpy_pic(dmpi->planes[1], mpi->planes[1],
|
|
|
|
mpi->chroma_width, mpi->chroma_height/2,
|
|
|
|
dmpi->stride[1]*2, mpi->stride[1]*2);
|
|
|
|
my_memcpy_pic(dmpi->planes[2], mpi->planes[2],
|
|
|
|
mpi->chroma_width, mpi->chroma_height/2,
|
|
|
|
dmpi->stride[2]*2, mpi->stride[2]*2);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
my_memcpy_pic(dmpi->planes[0]+dmpi->stride[0],
|
|
|
|
mpi->planes[0]+mpi->stride[0], mpi->w, mpi->h/2,
|
|
|
|
dmpi->stride[0]*2, mpi->stride[0]*2);
|
|
|
|
if (mpi->flags & MP_IMGFLAG_PLANAR) {
|
|
|
|
my_memcpy_pic(dmpi->planes[1]+dmpi->stride[1],
|
|
|
|
mpi->planes[1]+mpi->stride[1],
|
|
|
|
mpi->chroma_width, mpi->chroma_height/2,
|
|
|
|
dmpi->stride[1]*2, mpi->stride[1]*2);
|
|
|
|
my_memcpy_pic(dmpi->planes[2]+dmpi->stride[2],
|
|
|
|
mpi->planes[2]+mpi->stride[2],
|
|
|
|
mpi->chroma_width, mpi->chroma_height/2,
|
|
|
|
dmpi->stride[2]*2, mpi->stride[2]*2);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
memcpy_pic(dmpi->planes[0], mpi->planes[0], mpi->w, mpi->h,
|
|
|
|
dmpi->stride[0], mpi->stride[0]);
|
|
|
|
if (mpi->flags & MP_IMGFLAG_PLANAR) {
|
|
|
|
memcpy_pic(dmpi->planes[1], mpi->planes[1],
|
|
|
|
mpi->chroma_width, mpi->chroma_height,
|
|
|
|
dmpi->stride[1], mpi->stride[1]);
|
|
|
|
memcpy_pic(dmpi->planes[2], mpi->planes[2],
|
|
|
|
mpi->chroma_width, mpi->chroma_height,
|
|
|
|
dmpi->stride[2], mpi->stride[2]);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
static int do_put_image(struct vf_instance *vf, mp_image_t *dmpi, double pts)
|
2003-04-19 01:39:37 +00:00
|
|
|
{
|
|
|
|
struct vf_priv_s *p = vf->priv;
|
2006-03-12 18:31:50 +00:00
|
|
|
int dropflag=0;
|
2003-04-19 01:39:37 +00:00
|
|
|
|
2006-03-12 18:31:50 +00:00
|
|
|
if (!p->dropnext) switch (p->drop) {
|
2003-04-19 01:39:37 +00:00
|
|
|
case 0:
|
|
|
|
dropflag = 0;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
dropflag = (++p->lastdrop >= 5);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
dropflag = (++p->lastdrop >= 5) && (4*p->inframes <= 5*p->outframes);
|
|
|
|
break;
|
|
|
|
}
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-19 01:39:37 +00:00
|
|
|
if (dropflag) {
|
|
|
|
//mp_msg(MSGT_VFILTER, MSGL_V, "drop! [%d/%d=%g]\n",
|
|
|
|
// p->outframes, p->inframes, (float)p->outframes/p->inframes);
|
|
|
|
mp_msg(MSGT_VFILTER, MSGL_V, "!");
|
|
|
|
p->lastdrop = 0;
|
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
|
|
|
vf_detc_adjust_pts(&p->ptsbuf, pts, 0, 1);
|
2003-04-19 01:39:37 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
p->outframes++;
|
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
|
|
|
return vf_next_put_image(vf, dmpi, vf_detc_adjust_pts(&p->ptsbuf, pts, 0, 0));
|
2003-04-19 01:39:37 +00:00
|
|
|
}
|
|
|
|
|
2010-05-29 14:15:55 +00:00
|
|
|
static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts)
|
2003-04-19 01:39:37 +00:00
|
|
|
{
|
|
|
|
int ret=0;
|
|
|
|
struct vf_priv_s *p = vf->priv;
|
|
|
|
|
|
|
|
p->inframes++;
|
|
|
|
|
|
|
|
if (p->first) { /* hack */
|
|
|
|
p->first = 0;
|
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
|
|
|
vf_detc_adjust_pts(&p->ptsbuf, pts, 0, 1);
|
2003-04-19 01:39:37 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!p->dmpi) p->dmpi = vf_get_image(vf->next, mpi->imgfmt,
|
|
|
|
MP_IMGTYPE_STATIC, MP_IMGFLAG_ACCEPT_STRIDE |
|
|
|
|
MP_IMGFLAG_PRESERVE | MP_IMGFLAG_READABLE,
|
|
|
|
mpi->width, mpi->height);
|
|
|
|
/* FIXME -- not correct, off by one frame! */
|
|
|
|
p->dmpi->qscale = mpi->qscale;
|
|
|
|
p->dmpi->qstride = mpi->qstride;
|
|
|
|
p->dmpi->qscale_type = mpi->qscale_type;
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2003-04-19 01:39:37 +00:00
|
|
|
switch (foo(p, mpi, p->dmpi)) {
|
|
|
|
case F_DROP:
|
|
|
|
copy_image(p->dmpi, mpi, 2);
|
|
|
|
ret = 0;
|
|
|
|
p->lastdrop = 0;
|
|
|
|
mp_msg(MSGT_VFILTER, MSGL_V, "DROP\n");
|
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
|
|
|
vf_detc_adjust_pts(&p->ptsbuf, pts, 0, 1);
|
2003-04-19 01:39:37 +00:00
|
|
|
break;
|
|
|
|
case F_MERGE:
|
|
|
|
copy_image(p->dmpi, mpi, 0);
|
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
|
|
|
ret = do_put_image(vf, p->dmpi, pts);
|
2003-04-19 01:39:37 +00:00
|
|
|
copy_image(p->dmpi, mpi, 1);
|
|
|
|
mp_msg(MSGT_VFILTER, MSGL_V, "MERGE\n");
|
|
|
|
p->dmpi = NULL;
|
|
|
|
break;
|
|
|
|
case F_NEXT:
|
|
|
|
copy_image(p->dmpi, mpi, 2);
|
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
|
|
|
ret = do_put_image(vf, p->dmpi, pts);
|
2003-04-19 01:39:37 +00:00
|
|
|
mp_msg(MSGT_VFILTER, MSGL_V, "NEXT\n");
|
|
|
|
p->dmpi = NULL;
|
|
|
|
break;
|
|
|
|
case F_SHOW:
|
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
|
|
|
ret = do_put_image(vf, p->dmpi, pts);
|
2003-04-19 01:39:37 +00:00
|
|
|
copy_image(p->dmpi, mpi, 2);
|
|
|
|
mp_msg(MSGT_VFILTER, MSGL_V, "OK\n");
|
|
|
|
p->dmpi = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-05-29 14:15:55 +00:00
|
|
|
static int query_format(struct vf_instance *vf, unsigned int fmt)
|
2003-04-19 01:39:37 +00:00
|
|
|
{
|
|
|
|
switch (fmt) {
|
|
|
|
case IMGFMT_YV12:
|
|
|
|
case IMGFMT_IYUV:
|
|
|
|
case IMGFMT_I420:
|
|
|
|
return vf_next_query_format(vf, fmt);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-29 14:15:55 +00:00
|
|
|
static void uninit(struct vf_instance *vf)
|
2003-04-19 01:39:37 +00:00
|
|
|
{
|
|
|
|
free(vf->priv);
|
|
|
|
}
|
|
|
|
|
2010-02-21 13:40:49 +00:00
|
|
|
static int vf_open(vf_instance_t *vf, char *args)
|
2003-04-19 01:39:37 +00:00
|
|
|
{
|
|
|
|
struct vf_priv_s *p;
|
|
|
|
vf->put_image = put_image;
|
|
|
|
vf->query_format = query_format;
|
|
|
|
vf->uninit = uninit;
|
|
|
|
vf->default_reqs = VFCAP_ACCEPT_STRIDE;
|
|
|
|
vf->priv = p = calloc(1, sizeof(struct vf_priv_s));
|
|
|
|
p->drop = 0;
|
|
|
|
p->first = 1;
|
|
|
|
if (args) sscanf(args, "%d", &p->drop);
|
|
|
|
block_diffs = block_diffs_C;
|
2009-09-14 14:47:56 +00:00
|
|
|
#if HAVE_MMX && HAVE_EBX_AVAILABLE
|
2003-04-19 01:39:37 +00:00
|
|
|
if(gCpuCaps.hasMMX) block_diffs = block_diffs_MMX;
|
|
|
|
#endif
|
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
|
|
|
vf_detc_init_pts_buf(&p->ptsbuf);
|
2003-04-19 01:39:37 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-12-02 14:57:15 +00:00
|
|
|
const vf_info_t vf_info_ivtc = {
|
2003-04-19 01:39:37 +00:00
|
|
|
"inverse telecine, take 2",
|
|
|
|
"ivtc",
|
|
|
|
"Rich Felker",
|
|
|
|
"",
|
2010-02-21 13:40:49 +00:00
|
|
|
vf_open,
|
2003-04-19 01:39:37 +00:00
|
|
|
NULL
|
|
|
|
};
|