static inline PixelType MEDIAN(PixelType a, PixelType b, PixelType c) {
PixelType mn = VSMIN(a, b);
PixelType mx = VSMAX(a, b);
PixelType m = VSMIN(mx, c);
m = VSMAX(mn, m);
return m;
}
static void interpLineFP(const uint8_t *srcp, const int width, const int pitch,
const float alpha, const float beta, const float gamma, const int nrad,
const int mdis, float *temp, uint8_t *dstp, int *dmap, const int ucubic,
const int cost3)
{
const uint8_t *src3p = srcp - 3 * pitch;
const uint8_t *src1p = srcp - 1 * pitch;
const uint8_t *src1n = srcp + 1 * pitch;
const uint8_t *src3n = srcp + 3 * pitch;
const int tpitch = mdis * 2 + 1;
float *ccosts = temp;
float *pcosts = ccosts + width * tpitch;
int *pbackt = (int *)(pcosts + width * tpitch);
int *fpath = pbackt + width * tpitch;
int k, u, v, x;
// calculate all connection costs
if(!cost3) {
for(x = 0; x < width; ++x) {
const int umax = VSMIN(VSMIN(x, width - 1 - x), mdis);
for(u = -umax; u <= umax; ++u) {
int s = 0;
for(k = -nrad; k <= nrad; ++k)
s +=
abs(src3p[x + u + k] - src1p[x - u + k]) +
abs(src1p[x + u + k] - src1n[x - u + k]) +
abs(src1n[x + u + k] - src3n[x - u + k]);
const int ip = (src1p[x + u] + src1n[x - u] + 1) >> 1; // should use cubic if ucubic=true
const int v = abs(src1p[x] - ip) + abs(src1n[x] - ip);
ccosts[x * tpitch + mdis + u] = alpha * s + beta * abs(u) + (1.0f - alpha - beta) * v;
}
}
} else {
for(x = 0; x < width; ++x) {
static const VSFrameRef *VS_CC mvflowfpsGetFrame(int n, int activationReason, void **instanceData, void **frameData, VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi) {
MVFlowFPSData *d = (MVFlowFPSData *) * instanceData;
if (activationReason == arInitial) {
int off = d->mvClipB->GetDeltaFrame(); // integer offset of reference frame
int nleft = (int)(n * d->fa / d->fb);
int nright = nleft + off;
int time256 = int( (double(n) * double(d->fa) / double(d->fb) - nleft) * 256 + 0.5);
if (off > 1)
time256 = time256 / off;
if (time256 == 0) {
vsapi->requestFrameFilter(d->vi.numFrames ? VSMIN(nleft, d->vi.numFrames - 1) : nleft, d->node, frameCtx);
return 0;
} else if (time256 == 256) {
vsapi->requestFrameFilter(d->vi.numFrames ? VSMIN(nright, d->vi.numFrames - 1) : nright, d->node, frameCtx);
return 0;
}
if ((nleft < d->vi.numFrames && nright < d->vi.numFrames) || !d->vi.numFrames) { // for the good estimation case
if (d->maskmode == 2)
vsapi->requestFrameFilter(nleft, d->mvfw, frameCtx); // requests nleft - off, nleft
vsapi->requestFrameFilter(nright, d->mvfw, frameCtx); // requests nleft, nleft + off
vsapi->requestFrameFilter(nleft, d->mvbw, frameCtx); // requests nleft, nleft + off
if (d->maskmode == 2)
vsapi->requestFrameFilter(nright, d->mvbw, frameCtx); // requests nleft + off, nleft + off + off
vsapi->requestFrameFilter(nleft, d->finest, frameCtx);
vsapi->requestFrameFilter(nright, d->finest, frameCtx);
}
vsapi->requestFrameFilter(d->vi.numFrames ? VSMIN(nleft, d->vi.numFrames - 1) : nleft, d->node, frameCtx);
if (d->blend)
vsapi->requestFrameFilter(d->vi.numFrames ? VSMIN(nright, d->vi.numFrames - 1) : nright, d->node, frameCtx);
} else if (activationReason == arAllFramesReady) {
int nleft = (int)(n * d->fa / d->fb);
// intermediate product may be very large! Now I know how to multiply int64
int time256 = int( (double(n)*double(d->fa)/double(d->fb) - nleft) * 256 + 0.5);
int off = d->mvClipB->GetDeltaFrame(); // integer offset of reference frame
// usually off must be = 1
if (off > 1)
time256 = time256 / off;
int nright = nleft + off;
if (time256 == 0) {
return vsapi->getFrameFilter(d->vi.numFrames ? VSMIN(nleft, d->vi.numFrames - 1) : nleft, d->node, frameCtx); // simply left
} else if (time256 == 256) {
return vsapi->getFrameFilter(d->vi.numFrames ? VSMIN(nright, d->vi.numFrames - 1) : nright, d->node, frameCtx); // simply right
}
MVClipBalls ballsF(d->mvClipF, vsapi);
MVClipBalls ballsB(d->mvClipB, vsapi);
bool isUsableF = false;
bool isUsableB = false;
if ((nleft < d->vi.numFrames && nright < d->vi.numFrames) || !d->vi.numFrames) {
const VSFrameRef *mvF = vsapi->getFrameFilter(nright, d->mvfw, frameCtx);
ballsF.Update(mvF);// forward from current to next
isUsableF = ballsF.IsUsable();
vsapi->freeFrame(mvF);
const VSFrameRef *mvB = vsapi->getFrameFilter(nleft, d->mvbw, frameCtx);
ballsB.Update(mvB);// backward from next to current
isUsableB = ballsB.IsUsable();
vsapi->freeFrame(mvB);
}
const int nWidth = d->bleh->nWidth;
const int nHeight = d->bleh->nHeight;
const int nWidthUV = d->nWidthUV;
const int nHeightUV = d->nHeightUV;
const int maskmode = d->maskmode;
const bool blend = d->blend;
const bool isse = d->isse;
const double ml = d->ml;
const int xRatioUV = d->bleh->xRatioUV;
const int yRatioUV = d->bleh->yRatioUV;
const int nBlkX = d->bleh->nBlkX;
const int nBlkY = d->bleh->nBlkY;
const int nBlkSizeX = d->bleh->nBlkSizeX;
const int nBlkSizeY = d->bleh->nBlkSizeY;
const int nOverlapX = d->bleh->nOverlapX;
const int nOverlapY = d->bleh->nOverlapY;
const int nVPadding = d->bleh->nVPadding;
const int nHPadding = d->bleh->nHPadding;
const int nVPaddingUV = d->nVPaddingUV;
const int nHPaddingUV = d->nHPaddingUV;
const int nPel = d->bleh->nPel;
const int VPitchY = d->VPitchY;
const int VPitchUV = d->VPitchUV;
const int nBlkXP = d->nBlkXP;
const int nBlkYP = d->nBlkYP;
SimpleResize *upsizer = d->upsizer;
SimpleResize *upsizerUV = d->upsizerUV;
int *LUTVB = d->LUTVB;
int *LUTVF = d->LUTVF;
uint8_t *VXFullYB = d->VXFullYB;
uint8_t *VXFullUVB = d->VXFullUVB;
uint8_t *VYFullYB = d->VYFullYB;
uint8_t *VYFullUVB = d->VYFullUVB;
uint8_t *VXSmallYB = d->VXSmallYB;
uint8_t *VYSmallYB = d->VYSmallYB;
uint8_t *VXSmallUVB = d->VXSmallUVB;
uint8_t *VYSmallUVB = d->VYSmallUVB;
uint8_t *VXFullYF = d->VXFullYF;
uint8_t *VXFullUVF = d->VXFullUVF;
uint8_t *VYFullYF = d->VYFullYF;
uint8_t *VYFullUVF = d->VYFullUVF;
uint8_t *VXSmallYF = d->VXSmallYF;
uint8_t *VYSmallYF = d->VYSmallYF;
uint8_t *VXSmallUVF = d->VXSmallUVF;
uint8_t *VYSmallUVF = d->VYSmallUVF;
uint8_t *VXFullYBB = d->VXFullYBB;
uint8_t *VXFullUVBB = d->VXFullUVBB;
uint8_t *VYFullYBB = d->VYFullYBB;
uint8_t *VYFullUVBB = d->VYFullUVBB;
uint8_t *VXSmallYBB = d->VXSmallYBB;
uint8_t *VYSmallYBB = d->VYSmallYBB;
uint8_t *VXSmallUVBB = d->VXSmallUVBB;
uint8_t *VYSmallUVBB = d->VYSmallUVBB;
uint8_t *VXFullYFF = d->VXFullYFF;
uint8_t *VXFullUVFF = d->VXFullUVFF;
uint8_t *VYFullYFF = d->VYFullYFF;
uint8_t *VYFullUVFF = d->VYFullUVFF;
uint8_t *VXSmallYFF = d->VXSmallYFF;
uint8_t *VYSmallYFF = d->VYSmallYFF;
uint8_t *VXSmallUVFF = d->VXSmallUVFF;
uint8_t *VYSmallUVFF = d->VYSmallUVFF;
uint8_t *MaskSmallB = d->MaskSmallB;
uint8_t *MaskFullYB = d->MaskFullYB;
uint8_t *MaskFullUVB = d->MaskFullUVB;
uint8_t *MaskSmallF = d->MaskSmallF;
uint8_t *MaskFullYF = d->MaskFullYF;
uint8_t *MaskFullUVF = d->MaskFullUVF;
int bitsPerSample = d->vi.format->bitsPerSample;
int bytesPerSample = d->vi.format->bytesPerSample;
if (isUsableB && isUsableF) {
uint8_t *pDst[3];
const uint8_t *pRef[3], *pSrc[3];
int nDstPitches[3], nRefPitches[3];
// If both are usable, that means both nleft and nright are less than numFrames, or that we don't have numFrames. Thus there is no need to check nleft and nright here.
const VSFrameRef *src = vsapi->getFrameFilter(nleft, d->finest, frameCtx);
const VSFrameRef *ref = vsapi->getFrameFilter(nright, d->finest, frameCtx);// right frame for compensation
VSFrameRef *dst = vsapi->newVideoFrame(d->vi.format, d->vi.width, d->vi.height, src, core);
Create_LUTV(time256, LUTVB, LUTVF); // lookup table
for (int i = 0; i < d->vi.format->numPlanes; i++) {
pDst[i] = vsapi->getWritePtr(dst, i);
pRef[i] = vsapi->getReadPtr(ref, i);
pSrc[i] = vsapi->getReadPtr(src, i);
nDstPitches[i] = vsapi->getStride(dst, i);
nRefPitches[i] = vsapi->getStride(ref, i);
}
int nOffsetY = nRefPitches[0] * nVPadding * nPel + nHPadding * bytesPerSample * nPel;
int nOffsetUV = nRefPitches[1] * nVPaddingUV * nPel + nHPaddingUV * bytesPerSample * nPel;
if (nright != d->nrightLast) {
// make vector vx and vy small masks
// 1. ATTENTION: vectors are assumed SHORT (|vx|, |vy| < 127) !
// 2. they will be zeroed if not
// 3. added 128 to all values
MakeVectorSmallMasks(&ballsB, nBlkX, nBlkY, VXSmallYB, nBlkXP, VYSmallYB, nBlkXP);
if (nBlkXP > nBlkX) {// fill right
for (int j=0; j<nBlkY; j++) {
VXSmallYB[j*nBlkXP + nBlkX] = VSMIN(VXSmallYB[j*nBlkXP + nBlkX-1],128);
VYSmallYB[j*nBlkXP + nBlkX] = VYSmallYB[j*nBlkXP + nBlkX-1];
}
}
if (nBlkYP > nBlkY) {// fill bottom
for (int i=0; i<nBlkXP; i++) {
VXSmallYB[nBlkXP*nBlkY +i] = VXSmallYB[nBlkXP*(nBlkY-1) +i];
VYSmallYB[nBlkXP*nBlkY +i] = VSMIN(VYSmallYB[nBlkXP*(nBlkY-1) +i],128);
}
}
upsizer->Resize(VXFullYB, VPitchY, VXSmallYB, nBlkXP);
upsizer->Resize(VYFullYB, VPitchY, VYSmallYB, nBlkXP);
if (d->vi.format->colorFamily != cmGray) {
VectorSmallMaskYToHalfUV(VXSmallYB, nBlkXP, nBlkYP, VXSmallUVB, xRatioUV);
VectorSmallMaskYToHalfUV(VYSmallYB, nBlkXP, nBlkYP, VYSmallUVB, yRatioUV);
upsizerUV->Resize(VXFullUVB, VPitchUV, VXSmallUVB, nBlkXP);
upsizerUV->Resize(VYFullUVB, VPitchUV, VYSmallUVB, nBlkXP);
}
}
// analyse vectors field to detect occlusion
// double occNormB = (256-time256)/(256*ml);
// MakeVectorOcclusionMask(mvClipB, nBlkX, nBlkY, occNormB, 1.0, nPel, MaskSmallB, nBlkXP);
MakeVectorOcclusionMaskTime(&ballsB, nBlkX, nBlkY, ml, 1.0, nPel, MaskSmallB, nBlkXP, (256-time256), nBlkSizeX - nOverlapX, nBlkSizeY - nOverlapY);
if (nBlkXP > nBlkX) // fill right
for (int j=0; j<nBlkY; j++)
MaskSmallB[j*nBlkXP + nBlkX] = MaskSmallB[j*nBlkXP + nBlkX-1];
if (nBlkYP > nBlkY) // fill bottom
for (int i=0; i<nBlkXP; i++)
MaskSmallB[nBlkXP*nBlkY +i] = MaskSmallB[nBlkXP*(nBlkY-1) +i];
upsizer->Resize(MaskFullYB, VPitchY, MaskSmallB, nBlkXP);
if (d->vi.format->colorFamily != cmGray)
upsizerUV->Resize(MaskFullUVB, VPitchUV, MaskSmallB, nBlkXP);
d->nrightLast = nright;
if (nleft != d->nleftLast) {
// make vector vx and vy small masks
// 1. ATTENTION: vectors are assumed SHORT (|vx|, |vy| < 127) !
// 2. they will be zeroed if not
// 3. added 128 to all values
MakeVectorSmallMasks(&ballsF, nBlkX, nBlkY, VXSmallYF, nBlkXP, VYSmallYF, nBlkXP);
if (nBlkXP > nBlkX) {// fill right
for (int j=0; j<nBlkY; j++) {
VXSmallYF[j*nBlkXP + nBlkX] = VSMIN(VXSmallYF[j*nBlkXP + nBlkX-1],128);
VYSmallYF[j*nBlkXP + nBlkX] = VYSmallYF[j*nBlkXP + nBlkX-1];
}
}
if (nBlkYP > nBlkY) {// fill bottom
for (int i=0; i<nBlkXP; i++) {
VXSmallYF[nBlkXP*nBlkY +i] = VXSmallYF[nBlkXP*(nBlkY-1) +i];
VYSmallYF[nBlkXP*nBlkY +i] = VSMIN(VYSmallYF[nBlkXP*(nBlkY-1) +i],128);
}
}
upsizer->Resize(VXFullYF, VPitchY, VXSmallYF, nBlkXP);
upsizer->Resize(VYFullYF, VPitchY, VYSmallYF, nBlkXP);
if (d->vi.format->colorFamily != cmGray) {
VectorSmallMaskYToHalfUV(VXSmallYF, nBlkXP, nBlkYP, VXSmallUVF, xRatioUV);
VectorSmallMaskYToHalfUV(VYSmallYF, nBlkXP, nBlkYP, VYSmallUVF, yRatioUV);
upsizerUV->Resize(VXFullUVF, VPitchUV, VXSmallUVF, nBlkXP);
upsizerUV->Resize(VYFullUVF, VPitchUV, VYSmallUVF, nBlkXP);
}
}
// analyse vectors field to detect occlusion
// double occNormF = time256/(256*ml);
// MakeVectorOcclusionMask(mvClipF, nBlkX, nBlkY, occNormF, 1.0, nPel, MaskSmallF, nBlkXP);
MakeVectorOcclusionMaskTime(&ballsF, nBlkX, nBlkY, ml, 1.0, nPel, MaskSmallF, nBlkXP, time256, nBlkSizeX - nOverlapX, nBlkSizeY - nOverlapY);
if (nBlkXP > nBlkX) // fill right
for (int j=0; j<nBlkY; j++)
MaskSmallF[j*nBlkXP + nBlkX] = MaskSmallF[j*nBlkXP + nBlkX-1];
if (nBlkYP > nBlkY) // fill bottom
for (int i=0; i<nBlkXP; i++)
MaskSmallF[nBlkXP*nBlkY +i] = MaskSmallF[nBlkXP*(nBlkY-1) +i];
upsizer->Resize(MaskFullYF, VPitchY, MaskSmallF, nBlkXP);
if (d->vi.format->colorFamily != cmGray)
upsizerUV->Resize(MaskFullUVF, VPitchUV, MaskSmallF, nBlkXP);
d->nleftLast = nleft;
if (maskmode == 2) { // These motion vectors should only be needed with maskmode 2. Why was the Avisynth plugin requesting them for all mask modes?
// Get motion info from more frames for occlusion areas
const VSFrameRef *mvFF = vsapi->getFrameFilter(nleft, d->mvfw, frameCtx);
ballsF.Update(mvFF);// forward from prev to cur
isUsableF = ballsF.IsUsable();
vsapi->freeFrame(mvFF);
const VSFrameRef *mvBB = vsapi->getFrameFilter(nright, d->mvbw, frameCtx);
ballsB.Update(mvBB);// backward from next next to next
isUsableB = ballsB.IsUsable();
vsapi->freeFrame(mvBB);
}
if (maskmode == 2 && isUsableB && isUsableF) {// slow method with extra frames
// get vector mask from extra frames
MakeVectorSmallMasks(&ballsB, nBlkX, nBlkY, VXSmallYBB, nBlkXP, VYSmallYBB, nBlkXP);
MakeVectorSmallMasks(&ballsF, nBlkX, nBlkY, VXSmallYFF, nBlkXP, VYSmallYFF, nBlkXP);
if (nBlkXP > nBlkX) {// fill right
for (int j=0; j<nBlkY; j++) {
VXSmallYBB[j*nBlkXP + nBlkX] = VSMIN(VXSmallYBB[j*nBlkXP + nBlkX-1],128);
VYSmallYBB[j*nBlkXP + nBlkX] = VYSmallYBB[j*nBlkXP + nBlkX-1];
VXSmallYFF[j*nBlkXP + nBlkX] = VSMIN(VXSmallYFF[j*nBlkXP + nBlkX-1],128);
VYSmallYFF[j*nBlkXP + nBlkX] = VYSmallYFF[j*nBlkXP + nBlkX-1];
}
}
if (nBlkYP > nBlkY) {// fill bottom
for (int i=0; i<nBlkXP; i++) {
VXSmallYBB[nBlkXP*nBlkY +i] = VXSmallYBB[nBlkXP*(nBlkY-1) +i];
VYSmallYBB[nBlkXP*nBlkY +i] = VSMIN(VYSmallYBB[nBlkXP*(nBlkY-1) +i],128);
VXSmallYFF[nBlkXP*nBlkY +i] = VXSmallYFF[nBlkXP*(nBlkY-1) +i];
VYSmallYFF[nBlkXP*nBlkY +i] = VSMIN(VYSmallYFF[nBlkXP*(nBlkY-1) +i],128);
}
}
upsizer->Resize(VXFullYBB, VPitchY, VXSmallYBB, nBlkXP);
upsizer->Resize(VYFullYBB, VPitchY, VYSmallYBB, nBlkXP);
upsizer->Resize(VXFullYFF, VPitchY, VXSmallYFF, nBlkXP);
upsizer->Resize(VYFullYFF, VPitchY, VYSmallYFF, nBlkXP);
FlowInterExtra(pDst[0], nDstPitches[0], pRef[0] + nOffsetY, pSrc[0] + nOffsetY, nRefPitches[0],
VXFullYB, VXFullYF, VYFullYB, VYFullYF, MaskFullYB, MaskFullYF, VPitchY,
nWidth, nHeight, time256, nPel, LUTVB, LUTVF, VXFullYBB, VXFullYFF, VYFullYBB, VYFullYFF, bitsPerSample);
if (d->vi.format->colorFamily != cmGray) {
VectorSmallMaskYToHalfUV(VXSmallYBB, nBlkXP, nBlkYP, VXSmallUVBB, xRatioUV);
VectorSmallMaskYToHalfUV(VYSmallYBB, nBlkXP, nBlkYP, VYSmallUVBB, yRatioUV);
VectorSmallMaskYToHalfUV(VXSmallYFF, nBlkXP, nBlkYP, VXSmallUVFF, xRatioUV);
VectorSmallMaskYToHalfUV(VYSmallYFF, nBlkXP, nBlkYP, VYSmallUVFF, yRatioUV);
upsizerUV->Resize(VXFullUVBB, VPitchUV, VXSmallUVBB, nBlkXP);
upsizerUV->Resize(VYFullUVBB, VPitchUV, VYSmallUVBB, nBlkXP);
upsizerUV->Resize(VXFullUVFF, VPitchUV, VXSmallUVFF, nBlkXP);
upsizerUV->Resize(VYFullUVFF, VPitchUV, VYSmallUVFF, nBlkXP);
FlowInterExtra(pDst[1], nDstPitches[1], pRef[1] + nOffsetUV, pSrc[1] + nOffsetUV, nRefPitches[1],
VXFullUVB, VXFullUVF, VYFullUVB, VYFullUVF, MaskFullUVB, MaskFullUVF, VPitchUV,
nWidthUV, nHeightUV, time256, nPel, LUTVB, LUTVF, VXFullUVBB, VXFullUVFF, VYFullUVBB, VYFullUVFF, bitsPerSample);
FlowInterExtra(pDst[2], nDstPitches[2], pRef[2] + nOffsetUV, pSrc[2] + nOffsetUV, nRefPitches[2],
VXFullUVB, VXFullUVF, VYFullUVB, VYFullUVF, MaskFullUVB, MaskFullUVF, VPitchUV,
nWidthUV, nHeightUV, time256, nPel, LUTVB, LUTVF, VXFullUVBB, VXFullUVFF, VYFullUVBB, VYFullUVFF, bitsPerSample);
}
} else if (maskmode == 1) {// old method without extra frames
FlowInter(pDst[0], nDstPitches[0], pRef[0] + nOffsetY, pSrc[0] + nOffsetY, nRefPitches[0],
VXFullYB, VXFullYF, VYFullYB, VYFullYF, MaskFullYB, MaskFullYF, VPitchY,
nWidth, nHeight, time256, nPel, LUTVB, LUTVF, bitsPerSample);
if (d->vi.format->colorFamily != cmGray) {
FlowInter(pDst[1], nDstPitches[1], pRef[1] + nOffsetUV, pSrc[1] + nOffsetUV, nRefPitches[1],
VXFullUVB, VXFullUVF, VYFullUVB, VYFullUVF, MaskFullUVB, MaskFullUVF, VPitchUV,
nWidthUV, nHeightUV, time256, nPel, LUTVB, LUTVF, bitsPerSample);
FlowInter(pDst[2], nDstPitches[2], pRef[2] + nOffsetUV, pSrc[2] + nOffsetUV, nRefPitches[2],
VXFullUVB, VXFullUVF, VYFullUVB, VYFullUVF, MaskFullUVB, MaskFullUVF, VPitchUV,
nWidthUV, nHeightUV, time256, nPel, LUTVB, LUTVF, bitsPerSample);
}
} else {// mode=0, faster simple method
FlowInterSimple(pDst[0], nDstPitches[0], pRef[0] + nOffsetY, pSrc[0] + nOffsetY, nRefPitches[0],
VXFullYB, VXFullYF, VYFullYB, VYFullYF, MaskFullYB, MaskFullYF, VPitchY,
nWidth, nHeight, time256, nPel, LUTVB, LUTVF, bitsPerSample);
if (d->vi.format->colorFamily != cmGray) {
FlowInterSimple(pDst[1], nDstPitches[1], pRef[1] + nOffsetUV, pSrc[1] + nOffsetUV, nRefPitches[1],
VXFullUVB, VXFullUVF, VYFullUVB, VYFullUVF, MaskFullUVB, MaskFullUVF, VPitchUV,
nWidthUV, nHeightUV, time256, nPel, LUTVB, LUTVF, bitsPerSample);
FlowInterSimple(pDst[2], nDstPitches[2], pRef[2] + nOffsetUV, pSrc[2] + nOffsetUV, nRefPitches[2],
VXFullUVB, VXFullUVF, VYFullUVB, VYFullUVF, MaskFullUVB, MaskFullUVF, VPitchUV,
nWidthUV, nHeightUV, time256, nPel, LUTVB, LUTVF, bitsPerSample);
}
}
vsapi->freeFrame(src);
vsapi->freeFrame(ref);
return dst;
} else { // poor estimation
const VSFrameRef *src = vsapi->getFrameFilter(d->vi.numFrames ? VSMIN(nleft, d->vi.numFrames - 1) : nleft, d->node, frameCtx);
if (blend) {//let's blend src with ref frames like ConvertFPS
uint8_t *pDst[3];
const uint8_t *pRef[3], *pSrc[3];
int nDstPitches[3], nRefPitches[3], nSrcPitches[3];
const VSFrameRef *ref = vsapi->getFrameFilter(d->vi.numFrames ? VSMIN(nright, d->vi.numFrames - 1) : nright, d->node, frameCtx);
VSFrameRef *dst = vsapi->newVideoFrame(d->vi.format, d->vi.width, d->vi.height, src, core);
for (int i = 0; i < d->vi.format->numPlanes; i++) {
pDst[i] = vsapi->getWritePtr(dst, i);
pRef[i] = vsapi->getReadPtr(ref, i);
pSrc[i] = vsapi->getReadPtr(src, i);
nDstPitches[i] = vsapi->getStride(dst, i);
nRefPitches[i] = vsapi->getStride(ref, i);
nSrcPitches[i] = vsapi->getStride(src, i);
}
// blend with time weight
Blend(pDst[0], pSrc[0], pRef[0], nHeight, nWidth, nDstPitches[0], nSrcPitches[0], nRefPitches[0], time256, isse, bitsPerSample);
if (d->vi.format->colorFamily != cmGray) {
Blend(pDst[1], pSrc[1], pRef[1], nHeightUV, nWidthUV, nDstPitches[1], nSrcPitches[1], nRefPitches[1], time256, isse, bitsPerSample);
Blend(pDst[2], pSrc[2], pRef[2], nHeightUV, nWidthUV, nDstPitches[2], nSrcPitches[2], nRefPitches[2], time256, isse, bitsPerSample);
}
vsapi->freeFrame(src);
vsapi->freeFrame(ref);
return dst;
} else {
return src; // like ChangeFPS
}
}
}
return 0;
}
static const VSFrameRef *VS_CC mvmaskGetFrame(int n, int activationReason, void **instanceData, void **frameData, VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi) {
(void)frameData;
MVMaskData *d = (MVMaskData *)*instanceData;
if (activationReason == arInitial) {
vsapi->requestFrameFilter(n, d->vectors, frameCtx);
vsapi->requestFrameFilter(n, d->node, frameCtx);
} else if (activationReason == arAllFramesReady) {
const VSFrameRef *src = vsapi->getFrameFilter(n, d->node, frameCtx);
VSFrameRef *dst = vsapi->newVideoFrame(d->vi.format, d->vi.width, d->vi.height, src, core);
const uint8_t *pSrc[3];
uint8_t *pDst[3];
int nDstPitches[3];
int nSrcPitches[3];
pSrc[0] = vsapi->getReadPtr(src, 0);
nSrcPitches[0] = vsapi->getStride(src, 0);
for (int i = 0; i < 3; i++) {
pDst[i] = vsapi->getWritePtr(dst, i);
nDstPitches[i] = vsapi->getStride(dst, i);
}
FakeGroupOfPlanes fgop;
const VSFrameRef *mvn = vsapi->getFrameFilter(n, d->vectors, frameCtx);
fgopInit(&fgop, &d->vectors_data);
const VSMap *mvprops = vsapi->getFramePropsRO(mvn);
fgopUpdate(&fgop, (const uint8_t *)vsapi->propGetData(mvprops, prop_MVTools_vectors, 0, NULL));
vsapi->freeFrame(mvn);
const int kind = d->kind;
const int nWidth = d->vectors_data.nWidth;
const int nHeight = d->vectors_data.nHeight;
const int nWidthUV = d->nWidthUV;
const int nHeightUV = d->nHeightUV;
const int nSceneChangeValue = d->nSceneChangeValue;
if (fgopIsUsable(&fgop, d->thscd1, d->thscd2)) {
const int nBlkX = d->vectors_data.nBlkX;
const int nBlkY = d->vectors_data.nBlkY;
const int nBlkCount = nBlkX * nBlkY;
const float fMaskNormFactor = d->fMaskNormFactor;
const float fMaskNormFactor2 = d->fMaskNormFactor2;
const float fGamma = d->fGamma;
const float fHalfGamma = d->fHalfGamma;
const int nPel = d->vectors_data.nPel;
const int nBlkSizeX = d->vectors_data.nBlkSizeX;
const int nBlkSizeY = d->vectors_data.nBlkSizeY;
const int nOverlapX = d->vectors_data.nOverlapX;
const int nOverlapY = d->vectors_data.nOverlapY;
const int nWidthB = d->nWidthB;
const int nHeightB = d->nHeightB;
const int nWidthBUV = d->nWidthBUV;
const int nHeightBUV = d->nHeightBUV;
SimpleResize *upsizer = &d->upsizer;
SimpleResize *upsizerUV = &d->upsizerUV;
const int time256 = d->time256;
const int bitsPerSample = vsapi->getFrameFormat(src)->bitsPerSample;
uint8_t *smallMask = (uint8_t *)malloc(nBlkX * nBlkY);
uint8_t *smallMaskV = (uint8_t *)malloc(nBlkX * nBlkY);
if (kind == 0) { // vector length mask
for (int j = 0; j < nBlkCount; j++)
smallMask[j] = mvmaskLength(fgopGetBlock(&fgop, 0, j)->vector, nPel, fMaskNormFactor2, fHalfGamma);
} else if (kind == 1) { // SAD mask
MakeSADMaskTime(&fgop, nBlkX, nBlkY, 4.0 * fMaskNormFactor / (nBlkSizeX * nBlkSizeY), fGamma, nPel, smallMask, nBlkX, time256, nBlkSizeX - nOverlapX, nBlkSizeY - nOverlapY, bitsPerSample);
} else if (kind == 2) { // occlusion mask
MakeVectorOcclusionMaskTime(&fgop, d->vectors_data.isBackward, nBlkX, nBlkY, 1.0 / fMaskNormFactor, fGamma, nPel, smallMask, nBlkX, time256, nBlkSizeX - nOverlapX, nBlkSizeY - nOverlapY);
} else if (kind == 3) { // vector x mask
for (int j = 0; j < nBlkCount; j++)
smallMask[j] = VSMAX(0, VSMIN(255, (int)(fgopGetBlock(&fgop, 0, j)->vector.x * fMaskNormFactor * 100 + 128))); // shited by 128 for signed support
} else if (kind == 4) { // vector y mask
for (int j = 0; j < nBlkCount; j++)
smallMask[j] = VSMAX(0, VSMIN(255, (int)(fgopGetBlock(&fgop, 0, j)->vector.y * fMaskNormFactor * 100 + 128))); // shited by 128 for signed support
} else if (kind == 5) { // vector x mask in U, y mask in V
for (int j = 0; j < nBlkCount; j++) {
VECTOR v = fgopGetBlock(&fgop, 0, j)->vector;
smallMask[j] = VSMAX(0, VSMIN(255, (int)(v.x * fMaskNormFactor * 100 + 128))); // shited by 128 for signed support
smallMaskV[j] = VSMAX(0, VSMIN(255, (int)(v.y * fMaskNormFactor * 100 + 128))); // shited by 128 for signed support
}
}
if (kind == 5) { // do not change luma for kind=5
memcpy(pDst[0], pSrc[0], nSrcPitches[0] * nHeight);
} else {
upsizer->simpleResize_uint8_t(upsizer, pDst[0], nDstPitches[0], smallMask, nBlkX);
if (nWidth > nWidthB)
for (int h = 0; h < nHeight; h++)
for (int w = nWidthB; w < nWidth; w++)
*(pDst[0] + h * nDstPitches[0] + w) = *(pDst[0] + h * nDstPitches[0] + nWidthB - 1);
if (nHeight > nHeightB)
vs_bitblt(pDst[0] + nHeightB * nDstPitches[0], nDstPitches[0], pDst[0] + (nHeightB - 1) * nDstPitches[0], nDstPitches[0], nWidth, nHeight - nHeightB);
}
// chroma
upsizerUV->simpleResize_uint8_t(upsizerUV, pDst[1], nDstPitches[1], smallMask, nBlkX);
if (kind == 5)
upsizerUV->simpleResize_uint8_t(upsizerUV, pDst[2], nDstPitches[2], smallMaskV, nBlkX);
else
memcpy(pDst[2], pDst[1], nHeightUV * nDstPitches[1]);
if (nWidthUV > nWidthBUV)
for (int h = 0; h < nHeightUV; h++)
for (int w = nWidthBUV; w < nWidthUV; w++) {
*(pDst[1] + h * nDstPitches[1] + w) = *(pDst[1] + h * nDstPitches[1] + nWidthBUV - 1);
*(pDst[2] + h * nDstPitches[2] + w) = *(pDst[2] + h * nDstPitches[2] + nWidthBUV - 1);
}
if (nHeightUV > nHeightBUV) {
vs_bitblt(pDst[1] + nHeightBUV * nDstPitches[1], nDstPitches[1], pDst[1] + (nHeightBUV - 1) * nDstPitches[1], nDstPitches[1], nWidthUV, nHeightUV - nHeightBUV);
vs_bitblt(pDst[2] + nHeightBUV * nDstPitches[2], nDstPitches[2], pDst[2] + (nHeightBUV - 1) * nDstPitches[2], nDstPitches[2], nWidthUV, nHeightUV - nHeightBUV);
}
free(smallMask);
free(smallMaskV);
} else { // not usable
if (kind == 5)
memcpy(pDst[0], pSrc[0], nSrcPitches[0] * nHeight);
else
memset(pDst[0], nSceneChangeValue, nHeight * nDstPitches[0]);
memset(pDst[1], nSceneChangeValue, nHeightUV * nDstPitches[1]);
memset(pDst[2], nSceneChangeValue, nHeightUV * nDstPitches[2]);
}
fgopDeinit(&fgop);
vsapi->freeFrame(src);
return dst;
}
return 0;
}
