807 lines
24 KiB
C
807 lines
24 KiB
C
/*
|
|
============================================================================
|
|
Name : maskingmv.c
|
|
Author : jimbankoski
|
|
Version :
|
|
Copyright : Your copyright notice
|
|
Description : Hello World in C, Ansi-style
|
|
============================================================================
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
extern unsigned int vp9_sad16x16_sse3(
|
|
unsigned char *src_ptr,
|
|
int src_stride,
|
|
unsigned char *ref_ptr,
|
|
int ref_stride,
|
|
int max_err);
|
|
|
|
extern void vp9_sad16x16x3_sse3(
|
|
unsigned char *src_ptr,
|
|
int src_stride,
|
|
unsigned char *ref_ptr,
|
|
int ref_stride,
|
|
int *results);
|
|
|
|
extern int vp8_growmaskmb_sse3(
|
|
unsigned char *om,
|
|
unsigned char *nm);
|
|
|
|
extern void vp8_makemask_sse3(
|
|
unsigned char *y,
|
|
unsigned char *u,
|
|
unsigned char *v,
|
|
unsigned char *ym,
|
|
int yp,
|
|
int uvp,
|
|
int ys,
|
|
int us,
|
|
int vs,
|
|
int yt,
|
|
int ut,
|
|
int vt);
|
|
|
|
unsigned int vp9_sad16x16_unmasked_wmt(
|
|
unsigned char *src_ptr,
|
|
int src_stride,
|
|
unsigned char *ref_ptr,
|
|
int ref_stride,
|
|
unsigned char *mask);
|
|
|
|
unsigned int vp9_sad16x16_masked_wmt(
|
|
unsigned char *src_ptr,
|
|
int src_stride,
|
|
unsigned char *ref_ptr,
|
|
int ref_stride,
|
|
unsigned char *mask);
|
|
|
|
unsigned int vp8_masked_predictor_wmt(
|
|
unsigned char *masked,
|
|
unsigned char *unmasked,
|
|
int src_stride,
|
|
unsigned char *dst_ptr,
|
|
int dst_stride,
|
|
unsigned char *mask);
|
|
unsigned int vp8_masked_predictor_uv_wmt(
|
|
unsigned char *masked,
|
|
unsigned char *unmasked,
|
|
int src_stride,
|
|
unsigned char *dst_ptr,
|
|
int dst_stride,
|
|
unsigned char *mask);
|
|
unsigned int vp8_uv_from_y_mask(
|
|
unsigned char *ymask,
|
|
unsigned char *uvmask);
|
|
int yp = 16;
|
|
unsigned char sxy[] = {
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90,
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 80, 120, 120, 90, 90, 90, 90, 90, 80, 120, 120, 90, 90, 90, 90, 90
|
|
};
|
|
|
|
unsigned char sts[] = {
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
};
|
|
unsigned char str[] = {
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
|
|
};
|
|
|
|
unsigned char y[] = {
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40,
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40,
|
|
40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40,
|
|
40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40,
|
|
40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40,
|
|
60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40,
|
|
60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40,
|
|
60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40,
|
|
40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40,
|
|
40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40, 40,
|
|
40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40,
|
|
40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40, 40,
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40,
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40,
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40,
|
|
40, 40, 40, 60, 60, 60, 60, 40, 40, 40, 40, 60, 60, 60, 60, 40
|
|
};
|
|
int uvp = 8;
|
|
unsigned char u[] = {
|
|
90, 80, 70, 70, 90, 90, 90, 17,
|
|
90, 80, 70, 70, 90, 90, 90, 17,
|
|
84, 70, 70, 90, 90, 90, 17, 17,
|
|
84, 70, 70, 90, 90, 90, 17, 17,
|
|
80, 70, 70, 90, 90, 90, 17, 17,
|
|
90, 80, 70, 70, 90, 90, 90, 17,
|
|
90, 80, 70, 70, 90, 90, 90, 17,
|
|
90, 80, 70, 70, 90, 90, 90, 17
|
|
};
|
|
|
|
unsigned char v[] = {
|
|
80, 80, 80, 80, 80, 80, 80, 80,
|
|
80, 80, 80, 80, 80, 80, 80, 80,
|
|
80, 80, 80, 80, 80, 80, 80, 80,
|
|
80, 80, 80, 80, 80, 80, 80, 80,
|
|
80, 80, 80, 80, 80, 80, 80, 80,
|
|
80, 80, 80, 80, 80, 80, 80, 80,
|
|
80, 80, 80, 80, 80, 80, 80, 80,
|
|
80, 80, 80, 80, 80, 80, 80, 80
|
|
};
|
|
|
|
unsigned char ym[256];
|
|
unsigned char uvm[64];
|
|
typedef struct {
|
|
unsigned char y;
|
|
unsigned char yt;
|
|
unsigned char u;
|
|
unsigned char ut;
|
|
unsigned char v;
|
|
unsigned char vt;
|
|
unsigned char use;
|
|
} COLOR_SEG_ELEMENT;
|
|
|
|
/*
|
|
COLOR_SEG_ELEMENT segmentation[]=
|
|
{
|
|
{ 60,4,80,17,80,10, 1},
|
|
{ 40,4,15,10,80,10, 1},
|
|
};
|
|
*/
|
|
|
|
COLOR_SEG_ELEMENT segmentation[] = {
|
|
{ 79, 44, 92, 44, 237, 60, 1},
|
|
};
|
|
|
|
unsigned char pixel_mask(unsigned char y, unsigned char u, unsigned char v,
|
|
COLOR_SEG_ELEMENT sgm[],
|
|
int c) {
|
|
COLOR_SEG_ELEMENT *s = sgm;
|
|
unsigned char m = 0;
|
|
int i;
|
|
for (i = 0; i < c; i++, s++)
|
|
m |= (abs(y - s->y) < s->yt &&
|
|
abs(u - s->u) < s->ut &&
|
|
abs(v - s->v) < s->vt ? 255 : 0);
|
|
|
|
return m;
|
|
}
|
|
int neighbors[256][8];
|
|
int makeneighbors(void) {
|
|
int i, j;
|
|
for (i = 0; i < 256; i++) {
|
|
int r = (i >> 4), c = (i & 15);
|
|
int ni = 0;
|
|
for (j = 0; j < 8; j++)
|
|
neighbors[i][j] = i;
|
|
for (j = 0; j < 256; j++) {
|
|
int nr = (j >> 4), nc = (j & 15);
|
|
if (abs(nr - r) < 2 && abs(nc - c) < 2)
|
|
neighbors[i][ni++] = j;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
void grow_ymask(unsigned char *ym) {
|
|
unsigned char nym[256];
|
|
int i, j;
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
nym[i] = ym[i];
|
|
for (j = 0; j < 8; j++) {
|
|
nym[i] |= ym[neighbors[i][j]];
|
|
}
|
|
}
|
|
for (i = 0; i < 256; i++)
|
|
ym[i] = nym[i];
|
|
}
|
|
void make_mb_mask(unsigned char *y, unsigned char *u, unsigned char *v,
|
|
unsigned char *ym, unsigned char *uvm,
|
|
int yp, int uvp,
|
|
COLOR_SEG_ELEMENT sgm[],
|
|
int count) {
|
|
int r, c;
|
|
unsigned char *oym = ym;
|
|
|
|
memset(ym, 20, 256);
|
|
for (r = 0; r < 8; r++, uvm += 8, u += uvp, v += uvp, y += (yp + yp), ym += 32)
|
|
for (c = 0; c < 8; c++) {
|
|
int y1 = y[c << 1];
|
|
int u1 = u[c];
|
|
int v1 = v[c];
|
|
int m = pixel_mask(y1, u1, v1, sgm, count);
|
|
uvm[c] = m;
|
|
ym[c << 1] = uvm[c]; // = pixel_mask(y[c<<1],u[c],v[c],sgm,count);
|
|
ym[(c << 1) + 1] = pixel_mask(y[1 + (c << 1)], u[c], v[c], sgm, count);
|
|
ym[(c << 1) + 16] = pixel_mask(y[yp + (c << 1)], u[c], v[c], sgm, count);
|
|
ym[(c << 1) + 17] = pixel_mask(y[1 + yp + (c << 1)], u[c], v[c], sgm, count);
|
|
}
|
|
grow_ymask(oym);
|
|
}
|
|
|
|
int masked_sad(unsigned char *src, int p, unsigned char *dst, int dp,
|
|
unsigned char *ym) {
|
|
int i, j;
|
|
unsigned sad = 0;
|
|
for (i = 0; i < 16; i++, src += p, dst += dp, ym += 16)
|
|
for (j = 0; j < 16; j++)
|
|
if (ym[j])
|
|
sad += abs(src[j] - dst[j]);
|
|
|
|
return sad;
|
|
}
|
|
|
|
int compare_masks(unsigned char *sym, unsigned char *ym) {
|
|
int i, j;
|
|
unsigned sad = 0;
|
|
for (i = 0; i < 16; i++, sym += 16, ym += 16)
|
|
for (j = 0; j < 16; j++)
|
|
sad += (sym[j] != ym[j] ? 1 : 0);
|
|
|
|
return sad;
|
|
}
|
|
int unmasked_sad(unsigned char *src, int p, unsigned char *dst, int dp,
|
|
unsigned char *ym) {
|
|
int i, j;
|
|
unsigned sad = 0;
|
|
for (i = 0; i < 16; i++, src += p, dst += dp, ym += 16)
|
|
for (j = 0; j < 16; j++)
|
|
if (!ym[j])
|
|
sad += abs(src[j] - dst[j]);
|
|
|
|
return sad;
|
|
}
|
|
int masked_motion_search(unsigned char *y, unsigned char *u, unsigned char *v,
|
|
int yp, int uvp,
|
|
unsigned char *dy, unsigned char *du, unsigned char *dv,
|
|
int dyp, int duvp,
|
|
COLOR_SEG_ELEMENT sgm[],
|
|
int count,
|
|
int *mi,
|
|
int *mj,
|
|
int *ui,
|
|
int *uj,
|
|
int *wm) {
|
|
int i, j;
|
|
|
|
unsigned char ym[256];
|
|
unsigned char uvm[64];
|
|
unsigned char dym[256];
|
|
unsigned char duvm[64];
|
|
unsigned int e = 0;
|
|
int beste = 256;
|
|
int bmi = -32, bmj = -32;
|
|
int bui = -32, buj = -32;
|
|
int beste1 = 256;
|
|
int bmi1 = -32, bmj1 = -32;
|
|
int bui1 = -32, buj1 = -32;
|
|
int obeste;
|
|
|
|
// first try finding best mask and then unmasked
|
|
beste = 0xffffffff;
|
|
|
|
// find best unmasked mv
|
|
for (i = -32; i < 32; i++) {
|
|
unsigned char *dyz = i * dyp + dy;
|
|
unsigned char *duz = i / 2 * duvp + du;
|
|
unsigned char *dvz = i / 2 * duvp + dv;
|
|
for (j = -32; j < 32; j++) {
|
|
// 0,0 masked destination
|
|
make_mb_mask(dyz + j, duz + j / 2, dvz + j / 2, dym, duvm, dyp, duvp, sgm, count);
|
|
|
|
e = unmasked_sad(y, yp, dyz + j, dyp, dym);
|
|
|
|
if (e < beste) {
|
|
bui = i;
|
|
buj = j;
|
|
beste = e;
|
|
}
|
|
}
|
|
}
|
|
// bui=0;buj=0;
|
|
// best mv masked destination
|
|
make_mb_mask(dy + bui * dyp + buj, du + bui / 2 * duvp + buj / 2, dv + bui / 2 * duvp + buj / 2,
|
|
dym, duvm, dyp, duvp, sgm, count);
|
|
|
|
obeste = beste;
|
|
beste = 0xffffffff;
|
|
|
|
// find best masked
|
|
for (i = -32; i < 32; i++) {
|
|
unsigned char *dyz = i * dyp + dy;
|
|
for (j = -32; j < 32; j++) {
|
|
e = masked_sad(y, yp, dyz + j, dyp, dym);
|
|
|
|
if (e < beste) {
|
|
bmi = i;
|
|
bmj = j;
|
|
beste = e;
|
|
}
|
|
}
|
|
}
|
|
beste1 = beste + obeste;
|
|
bmi1 = bmi;
|
|
bmj1 = bmj;
|
|
bui1 = bui;
|
|
buj1 = buj;
|
|
|
|
beste = 0xffffffff;
|
|
// source mask
|
|
make_mb_mask(y, u, v, ym, uvm, yp, uvp, sgm, count);
|
|
|
|
// find best mask
|
|
for (i = -32; i < 32; i++) {
|
|
unsigned char *dyz = i * dyp + dy;
|
|
unsigned char *duz = i / 2 * duvp + du;
|
|
unsigned char *dvz = i / 2 * duvp + dv;
|
|
for (j = -32; j < 32; j++) {
|
|
// 0,0 masked destination
|
|
make_mb_mask(dyz + j, duz + j / 2, dvz + j / 2, dym, duvm, dyp, duvp, sgm, count);
|
|
|
|
e = compare_masks(ym, dym);
|
|
|
|
if (e < beste) {
|
|
bmi = i;
|
|
bmj = j;
|
|
beste = e;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// best mv masked destination
|
|
make_mb_mask(dy + bmi * dyp + bmj, du + bmi / 2 * duvp + bmj / 2, dv + bmi / 2 * duvp + bmj / 2,
|
|
dym, duvm, dyp, duvp, sgm, count);
|
|
|
|
obeste = masked_sad(y, yp, dy + bmi * dyp + bmj, dyp, dym);
|
|
|
|
beste = 0xffffffff;
|
|
|
|
// find best unmasked mv
|
|
for (i = -32; i < 32; i++) {
|
|
unsigned char *dyz = i * dyp + dy;
|
|
for (j = -32; j < 32; j++) {
|
|
e = unmasked_sad(y, yp, dyz + j, dyp, dym);
|
|
|
|
if (e < beste) {
|
|
bui = i;
|
|
buj = j;
|
|
beste = e;
|
|
}
|
|
}
|
|
}
|
|
beste += obeste;
|
|
|
|
|
|
if (beste < beste1) {
|
|
*mi = bmi;
|
|
*mj = bmj;
|
|
*ui = bui;
|
|
*uj = buj;
|
|
*wm = 1;
|
|
} else {
|
|
*mi = bmi1;
|
|
*mj = bmj1;
|
|
*ui = bui1;
|
|
*uj = buj1;
|
|
*wm = 0;
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int predict(unsigned char *src, int p, unsigned char *dst, int dp,
|
|
unsigned char *ym, unsigned char *prd) {
|
|
int i, j;
|
|
for (i = 0; i < 16; i++, src += p, dst += dp, ym += 16, prd += 16)
|
|
for (j = 0; j < 16; j++)
|
|
prd[j] = (ym[j] ? src[j] : dst[j]);
|
|
return 0;
|
|
}
|
|
|
|
int fast_masked_motion_search(unsigned char *y, unsigned char *u, unsigned char *v,
|
|
int yp, int uvp,
|
|
unsigned char *dy, unsigned char *du, unsigned char *dv,
|
|
int dyp, int duvp,
|
|
COLOR_SEG_ELEMENT sgm[],
|
|
int count,
|
|
int *mi,
|
|
int *mj,
|
|
int *ui,
|
|
int *uj,
|
|
int *wm) {
|
|
int i, j;
|
|
|
|
unsigned char ym[256];
|
|
unsigned char ym2[256];
|
|
unsigned char uvm[64];
|
|
unsigned char dym2[256];
|
|
unsigned char dym[256];
|
|
unsigned char duvm[64];
|
|
unsigned int e = 0;
|
|
int beste = 256;
|
|
int bmi = -32, bmj = -32;
|
|
int bui = -32, buj = -32;
|
|
int beste1 = 256;
|
|
int bmi1 = -32, bmj1 = -32;
|
|
int bui1 = -32, buj1 = -32;
|
|
int obeste;
|
|
|
|
// first try finding best mask and then unmasked
|
|
beste = 0xffffffff;
|
|
|
|
#if 0
|
|
for (i = 0; i < 16; i++) {
|
|
unsigned char *dy = i * yp + y;
|
|
for (j = 0; j < 16; j++)
|
|
printf("%2x", dy[j]);
|
|
printf("\n");
|
|
}
|
|
printf("\n");
|
|
|
|
for (i = -32; i < 48; i++) {
|
|
unsigned char *dyz = i * dyp + dy;
|
|
for (j = -32; j < 48; j++)
|
|
printf("%2x", dyz[j]);
|
|
printf("\n");
|
|
}
|
|
#endif
|
|
|
|
// find best unmasked mv
|
|
for (i = -32; i < 32; i++) {
|
|
unsigned char *dyz = i * dyp + dy;
|
|
unsigned char *duz = i / 2 * duvp + du;
|
|
unsigned char *dvz = i / 2 * duvp + dv;
|
|
for (j = -32; j < 32; j++) {
|
|
// 0,0 masked destination
|
|
vp8_makemask_sse3(dyz + j, duz + j / 2, dvz + j / 2, dym, dyp, duvp,
|
|
sgm[0].y, sgm[0].u, sgm[0].v,
|
|
sgm[0].yt, sgm[0].ut, sgm[0].vt);
|
|
|
|
vp8_growmaskmb_sse3(dym, dym2);
|
|
|
|
e = vp9_sad16x16_unmasked_wmt(y, yp, dyz + j, dyp, dym2);
|
|
|
|
if (e < beste) {
|
|
bui = i;
|
|
buj = j;
|
|
beste = e;
|
|
}
|
|
}
|
|
}
|
|
// bui=0;buj=0;
|
|
// best mv masked destination
|
|
|
|
vp8_makemask_sse3(dy + bui * dyp + buj, du + bui / 2 * duvp + buj / 2, dv + bui / 2 * duvp + buj / 2,
|
|
dym, dyp, duvp,
|
|
sgm[0].y, sgm[0].u, sgm[0].v,
|
|
sgm[0].yt, sgm[0].ut, sgm[0].vt);
|
|
|
|
vp8_growmaskmb_sse3(dym, dym2);
|
|
|
|
obeste = beste;
|
|
beste = 0xffffffff;
|
|
|
|
// find best masked
|
|
for (i = -32; i < 32; i++) {
|
|
unsigned char *dyz = i * dyp + dy;
|
|
for (j = -32; j < 32; j++) {
|
|
e = vp9_sad16x16_masked_wmt(y, yp, dyz + j, dyp, dym2);
|
|
if (e < beste) {
|
|
bmi = i;
|
|
bmj = j;
|
|
beste = e;
|
|
}
|
|
}
|
|
}
|
|
beste1 = beste + obeste;
|
|
bmi1 = bmi;
|
|
bmj1 = bmj;
|
|
bui1 = bui;
|
|
buj1 = buj;
|
|
|
|
// source mask
|
|
vp8_makemask_sse3(y, u, v,
|
|
ym, yp, uvp,
|
|
sgm[0].y, sgm[0].u, sgm[0].v,
|
|
sgm[0].yt, sgm[0].ut, sgm[0].vt);
|
|
|
|
vp8_growmaskmb_sse3(ym, ym2);
|
|
|
|
// find best mask
|
|
for (i = -32; i < 32; i++) {
|
|
unsigned char *dyz = i * dyp + dy;
|
|
unsigned char *duz = i / 2 * duvp + du;
|
|
unsigned char *dvz = i / 2 * duvp + dv;
|
|
for (j = -32; j < 32; j++) {
|
|
// 0,0 masked destination
|
|
vp8_makemask_sse3(dyz + j, duz + j / 2, dvz + j / 2, dym, dyp, duvp,
|
|
sgm[0].y, sgm[0].u, sgm[0].v,
|
|
sgm[0].yt, sgm[0].ut, sgm[0].vt);
|
|
|
|
vp8_growmaskmb_sse3(dym, dym2);
|
|
|
|
e = compare_masks(ym2, dym2);
|
|
|
|
if (e < beste) {
|
|
bmi = i;
|
|
bmj = j;
|
|
beste = e;
|
|
}
|
|
}
|
|
}
|
|
|
|
vp8_makemask_sse3(dy + bmi * dyp + bmj, du + bmi / 2 * duvp + bmj / 2, dv + bmi / 2 * duvp + bmj / 2,
|
|
dym, dyp, duvp,
|
|
sgm[0].y, sgm[0].u, sgm[0].v,
|
|
sgm[0].yt, sgm[0].ut, sgm[0].vt);
|
|
|
|
vp8_growmaskmb_sse3(dym, dym2);
|
|
|
|
obeste = vp9_sad16x16_masked_wmt(y, yp, dy + bmi * dyp + bmj, dyp, dym2);
|
|
|
|
beste = 0xffffffff;
|
|
|
|
// find best unmasked mv
|
|
for (i = -32; i < 32; i++) {
|
|
unsigned char *dyz = i * dyp + dy;
|
|
for (j = -32; j < 32; j++) {
|
|
e = vp9_sad16x16_unmasked_wmt(y, yp, dyz + j, dyp, dym2);
|
|
|
|
if (e < beste) {
|
|
bui = i;
|
|
buj = j;
|
|
beste = e;
|
|
}
|
|
}
|
|
}
|
|
beste += obeste;
|
|
|
|
if (beste < beste1) {
|
|
*mi = bmi;
|
|
*mj = bmj;
|
|
*ui = bui;
|
|
*uj = buj;
|
|
*wm = 1;
|
|
} else {
|
|
*mi = bmi1;
|
|
*mj = bmj1;
|
|
*ui = bui1;
|
|
*uj = buj1;
|
|
*wm = 0;
|
|
beste = beste1;
|
|
|
|
}
|
|
return beste;
|
|
}
|
|
|
|
int predict_all(unsigned char *ym, unsigned char *um, unsigned char *vm,
|
|
int ymp, int uvmp,
|
|
unsigned char *yp, unsigned char *up, unsigned char *vp,
|
|
int ypp, int uvpp,
|
|
COLOR_SEG_ELEMENT sgm[],
|
|
int count,
|
|
int mi,
|
|
int mj,
|
|
int ui,
|
|
int uj,
|
|
int wm) {
|
|
int i, j;
|
|
unsigned char dym[256];
|
|
unsigned char dym2[256];
|
|
unsigned char duvm[64];
|
|
unsigned char *yu = ym, *uu = um, *vu = vm;
|
|
|
|
unsigned char *dym3 = dym2;
|
|
|
|
ym += mi * ymp + mj;
|
|
um += mi / 2 * uvmp + mj / 2;
|
|
vm += mi / 2 * uvmp + mj / 2;
|
|
|
|
yu += ui * ymp + uj;
|
|
uu += ui / 2 * uvmp + uj / 2;
|
|
vu += ui / 2 * uvmp + uj / 2;
|
|
|
|
// best mv masked destination
|
|
if (wm)
|
|
vp8_makemask_sse3(ym, um, vm, dym, ymp, uvmp,
|
|
sgm[0].y, sgm[0].u, sgm[0].v,
|
|
sgm[0].yt, sgm[0].ut, sgm[0].vt);
|
|
else
|
|
vp8_makemask_sse3(yu, uu, vu, dym, ymp, uvmp,
|
|
sgm[0].y, sgm[0].u, sgm[0].v,
|
|
sgm[0].yt, sgm[0].ut, sgm[0].vt);
|
|
|
|
vp8_growmaskmb_sse3(dym, dym2);
|
|
vp8_masked_predictor_wmt(ym, yu, ymp, yp, ypp, dym3);
|
|
vp8_uv_from_y_mask(dym3, duvm);
|
|
vp8_masked_predictor_uv_wmt(um, uu, uvmp, up, uvpp, duvm);
|
|
vp8_masked_predictor_uv_wmt(vm, vu, uvmp, vp, uvpp, duvm);
|
|
|
|
return 0;
|
|
}
|
|
|
|
unsigned char f0p[1280 * 720 * 3 / 2];
|
|
unsigned char f1p[1280 * 720 * 3 / 2];
|
|
unsigned char prd[1280 * 720 * 3 / 2];
|
|
unsigned char msk[1280 * 720 * 3 / 2];
|
|
|
|
|
|
int mainz(int argc, char *argv[]) {
|
|
|
|
FILE *f = fopen(argv[1], "rb");
|
|
FILE *g = fopen(argv[2], "wb");
|
|
int w = atoi(argv[3]), h = atoi(argv[4]);
|
|
int y_stride = w, uv_stride = w / 2;
|
|
int r, c;
|
|
unsigned char *f0 = f0p, *f1 = f1p, *t;
|
|
unsigned char ym[256], uvm[64];
|
|
unsigned char ym2[256], uvm2[64];
|
|
unsigned char ym3[256], uvm3[64];
|
|
int a, b;
|
|
|
|
COLOR_SEG_ELEMENT last = { 20, 20, 20, 20, 230, 20, 1}, best;
|
|
#if 0
|
|
makeneighbors();
|
|
COLOR_SEG_ELEMENT segmentation[] = {
|
|
{ 60, 4, 80, 17, 80, 10, 1},
|
|
{ 40, 4, 15, 10, 80, 10, 1},
|
|
};
|
|
make_mb_mask(y, u, v, ym2, uvm2, 16, 8, segmentation, 1);
|
|
|
|
vp8_makemask_sse3(y, u, v, ym, (int) 16, (int) 8,
|
|
(int) segmentation[0].y, (int) segmentation[0].u, (int) segmentation[0].v,
|
|
segmentation[0].yt, segmentation[0].ut, segmentation[0].vt);
|
|
|
|
vp8_growmaskmb_sse3(ym, ym3);
|
|
|
|
a = vp9_sad16x16_masked_wmt(str, 16, sts, 16, ym3);
|
|
b = vp9_sad16x16_unmasked_wmt(str, 16, sts, 16, ym3);
|
|
|
|
vp8_masked_predictor_wmt(str, sts, 16, ym, 16, ym3);
|
|
|
|
vp8_uv_from_y_mask(ym3, uvm3);
|
|
|
|
return 4;
|
|
#endif
|
|
makeneighbors();
|
|
|
|
|
|
memset(prd, 128, w * h * 3 / 2);
|
|
|
|
fread(f0, w * h * 3 / 2, 1, f);
|
|
|
|
while (!feof(f)) {
|
|
unsigned char *ys = f1, *yd = f0, *yp = prd;
|
|
unsigned char *us = f1 + w * h, *ud = f0 + w * h, *up = prd + w * h;
|
|
unsigned char *vs = f1 + w * h * 5 / 4, *vd = f0 + w * h * 5 / 4, *vp = prd + w * h * 5 / 4;
|
|
fread(f1, w * h * 3 / 2, 1, f);
|
|
|
|
ys += 32 * y_stride;
|
|
yd += 32 * y_stride;
|
|
yp += 32 * y_stride;
|
|
us += 16 * uv_stride;
|
|
ud += 16 * uv_stride;
|
|
up += 16 * uv_stride;
|
|
vs += 16 * uv_stride;
|
|
vd += 16 * uv_stride;
|
|
vp += 16 * uv_stride;
|
|
for (r = 32; r < h - 32; r += 16,
|
|
ys += 16 * w, yd += 16 * w, yp += 16 * w,
|
|
us += 8 * uv_stride, ud += 8 * uv_stride, up += 8 * uv_stride,
|
|
vs += 8 * uv_stride, vd += 8 * uv_stride, vp += 8 * uv_stride) {
|
|
for (c = 32; c < w - 32; c += 16) {
|
|
int mi, mj, ui, uj, wm;
|
|
int bmi, bmj, bui, buj, bwm;
|
|
unsigned char ym[256];
|
|
|
|
if (vp9_sad16x16_sse3(ys + c, y_stride, yd + c, y_stride, 0xffff) == 0)
|
|
bmi = bmj = bui = buj = bwm = 0;
|
|
else {
|
|
COLOR_SEG_ELEMENT cs[5];
|
|
int j;
|
|
unsigned int beste = 0xfffffff;
|
|
unsigned int bestj = 0;
|
|
|
|
// try color from last mb segmentation
|
|
cs[0] = last;
|
|
|
|
// try color segs from 4 pixels in mb recon as segmentation
|
|
cs[1].y = yd[c + y_stride + 1];
|
|
cs[1].u = ud[c / 2 + uv_stride];
|
|
cs[1].v = vd[c / 2 + uv_stride];
|
|
cs[1].yt = cs[1].ut = cs[1].vt = 20;
|
|
cs[2].y = yd[c + w + 14];
|
|
cs[2].u = ud[c / 2 + uv_stride + 7];
|
|
cs[2].v = vd[c / 2 + uv_stride + 7];
|
|
cs[2].yt = cs[2].ut = cs[2].vt = 20;
|
|
cs[3].y = yd[c + w * 14 + 1];
|
|
cs[3].u = ud[c / 2 + uv_stride * 7];
|
|
cs[3].v = vd[c / 2 + uv_stride * 7];
|
|
cs[3].yt = cs[3].ut = cs[3].vt = 20;
|
|
cs[4].y = yd[c + w * 14 + 14];
|
|
cs[4].u = ud[c / 2 + uv_stride * 7 + 7];
|
|
cs[4].v = vd[c / 2 + uv_stride * 7 + 7];
|
|
cs[4].yt = cs[4].ut = cs[4].vt = 20;
|
|
|
|
for (j = 0; j < 5; j++) {
|
|
int e;
|
|
|
|
e = fast_masked_motion_search(
|
|
ys + c, us + c / 2, vs + c / 2, y_stride, uv_stride,
|
|
yd + c, ud + c / 2, vd + c / 2, y_stride, uv_stride,
|
|
&cs[j], 1, &mi, &mj, &ui, &uj, &wm);
|
|
|
|
if (e < beste) {
|
|
bmi = mi;
|
|
bmj = mj;
|
|
bui = ui;
|
|
buj = uj, bwm = wm;
|
|
bestj = j;
|
|
beste = e;
|
|
}
|
|
}
|
|
best = cs[bestj];
|
|
// best = segmentation[0];
|
|
last = best;
|
|
}
|
|
predict_all(yd + c, ud + c / 2, vd + c / 2, w, uv_stride,
|
|
yp + c, up + c / 2, vp + c / 2, w, uv_stride,
|
|
&best, 1, bmi, bmj, bui, buj, bwm);
|
|
|
|
}
|
|
}
|
|
fwrite(prd, w * h * 3 / 2, 1, g);
|
|
t = f0;
|
|
f0 = f1;
|
|
f1 = t;
|
|
|
|
}
|
|
fclose(f);
|
|
fclose(g);
|
|
return;
|
|
}
|