Function MIDOUT_BEGIN

dnn/src/common/warp_common.h:434–627

        const Mat<T>& _src, Mat<T>& _dst, const Mat<short>& _xy,
        const Mat<ushort>& _fxy, const void* _wtab, const T* bvalue) {
    MIDOUT_BEGIN(remapBilinear_bmode, midout_iv(bmode)) {
        typedef typename CastOp::type1 WT;
        const AT* wtab = (const AT*)_wtab;
        const T* S0 = _src.ptr();
        size_t sstep = _src.step();
        int dx, dy;
        CastOp castOp;
        VecOp vecOp;
        int swidth = _src.width(), sheight = _src.height();
        int dwidth = _dst.width(), dheight = _dst.height();
        unsigned width1 = std::max(swidth - 1, 0), height1 = std::max(sheight - 1, 0);
        for (dy = 0; dy < dheight; dy++) {
            T* D = _dst.ptr(dy);
            const short* XY = _xy.ptr(dy);
            const ushort* FXY = _fxy.ptr(dy);
            int X0 = 0;
            bool prevInlier = false;

            for (dx = 0; dx <= dwidth; dx++) {
                bool curInlier = dx < dwidth
                                       ? (unsigned)XY[dx * 2] < width1 &&
                                                 (unsigned)XY[dx * 2 + 1] < height1
                                       : !prevInlier;
                if (curInlier == prevInlier)
                    continue;

                int X1 = dx;
                dx = X0;
                X0 = X1;
                prevInlier = curInlier;

                if (!curInlier) {
                    int len = vecOp(_src, D, XY + dx * 2, FXY + dx, wtab, X1 - dx);
                    D += len * CH;
                    dx += len;

                    if (CH == 1) {
                        MIDOUT_BEGIN(remapBilinear_bmode, 0, 1) {
                            for (; dx < X1; dx++, D++) {
                                int sx = XY[dx * 2], sy = XY[dx * 2 + 1];
                                const AT* w = wtab + FXY[dx] * 4;
                                const T* S = S0 + sy * sstep + sx;
                                *D = castOp(
                                        WT(S[0] * w[0] + S[1] * w[1] + S[sstep] * w[2] +
                                           S[sstep + 1] * w[3]));
                            }
                        }
                        MIDOUT_END();
                    } else if (CH == 2) {
                        MIDOUT_BEGIN(remapBilinear_bmode, 0, 2) {
                            for (; dx < X1; dx++, D += 2) {
                                int sx = XY[dx * 2], sy = XY[dx * 2 + 1];
                                const AT* w = wtab + FXY[dx] * 4;
                                const T* S = S0 + sy * sstep + sx * 2;
                                WT t0 = S[0] * w[0] + S[2] * w[1] + S[sstep] * w[2] +
                                        S[sstep + 2] * w[3];
                                WT t1 = S[1] * w[0] + S[3] * w[1] +
                                        S[sstep + 1] * w[2] + S[sstep + 3] * w[3];