deblock.c

T264是中国的视频编码自由组织合力开发的264编解码程序

                        else
                        {
                            dst[-1 * stride] = (2 * p[1] + p[0] + q[1] + 2 ) >> 2;
                            dst[0] = (2 * q[1] + q[0] + p[1] + 2 ) >> 2;
                        }
                    }
                    else
                    {
                        dst[-1 * stride] = (2 * p[1] + p[0] + q[1] + 2 ) >> 2;
                        dst[0] = (2 * q[1] + q[0] + p[1] + 2 ) >> 2;
                    }
                }
            }
        }
    }
}

void __inline
deblock_mb_chroma(T264_t*t, int32_t x, int32_t y, uint8_t* dst_uv, uint8_t bSV[4][4], uint8_t bSH[4][4],
                  uint8_t indexAc, int32_t alphac, int32_t betac)
{
    uint8_t* dst;
    int32_t i;

    if (x != 0)
    {
        dst = dst_uv;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSV[0][i] > 0)
            {
                EdgeLoopH(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
                dst += t->edged_stride_uv;
                EdgeLoopH(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
                dst += t->edged_stride_uv;
            }
            else
            {
                dst += 2 * t->edged_stride_uv;
            }
        }
    }
    {
        dst = dst_uv + 4;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSV[2][i] > 0)
            {
                EdgeLoopH(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
                dst += t->edged_stride_uv;
                EdgeLoopH(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
                dst += t->edged_stride_uv;
            }
            else
            {
                dst += 2 * t->edged_stride_uv;
            }
        }
    }

    // u
    if (y != 0)
    {
        dst = dst_uv;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSH[0][i] > 0)
            {
                EdgeLoopV(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
                dst ++;
                EdgeLoopV(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
                dst ++;
            }
            else
            {
                dst += 2;
            }
        }
    }
    {
        dst = dst_uv + 4 * t->edged_stride_uv;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSH[2][i] > 0)
            {
                EdgeLoopV(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
                dst ++;
                EdgeLoopV(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
                dst ++;
            }
            else
            {
                dst += 2;
            }
        }
    }
}
void __inline
deblock_mb_chroma_(T264_t*t, int32_t x, int32_t y, uint8_t* org_dst_u, uint8_t* org_dst_v, uint8_t bSV[4][4], uint8_t bSH[4][4],
                  uint8_t indexAc, int32_t alphac, int32_t betac)
{
    uint8_t* dst_u, *dst_v;
    int32_t i;

    if (x != 0)
    {
        dst_u = org_dst_u;
        dst_v = org_dst_v;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSV[0][i] > 0)
            {
                EdgeLoopH(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
                dst_u += t->edged_stride_uv;
                EdgeLoopH(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
                dst_u += t->edged_stride_uv;

                EdgeLoopH(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
                dst_v += t->edged_stride_uv;
                EdgeLoopH(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
                dst_v += t->edged_stride_uv;
            }
            else
            {
                dst_u += 2 * t->edged_stride_uv;
                dst_v += 2 * t->edged_stride_uv;
            }
        }
    }
    {
        dst_u = org_dst_u + 4;
        dst_v = org_dst_v + 4;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSV[2][i] > 0)
            {
                EdgeLoopH(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
                dst_u += t->edged_stride_uv;
                EdgeLoopH(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
                dst_u += t->edged_stride_uv;

                EdgeLoopH(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
                dst_v += t->edged_stride_uv;
                EdgeLoopH(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
                dst_v += t->edged_stride_uv;
            }
            else
            {
                dst_u += 2 * t->edged_stride_uv;
                dst_v += 2 * t->edged_stride_uv;
            }
        }
    }

    // u
    if (y != 0)
    {
        dst_u = org_dst_u;
        dst_v = org_dst_v;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSH[0][i] > 0)
            {
                EdgeLoopV(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
                dst_u ++;
                EdgeLoopV(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
                dst_u ++;

                EdgeLoopV(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
                dst_v ++;
                EdgeLoopV(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
                dst_v ++;
            }
            else
            {
                dst_u += 2;
                dst_v += 2;
            }
        }
    }
    {
        dst_u = org_dst_u + 4 * t->edged_stride_uv;
        dst_v = org_dst_v + 4 * t->edged_stride_uv;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSH[2][i] > 0)
            {
                EdgeLoopV(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
                dst_u ++;
                EdgeLoopV(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
                dst_u ++;

                EdgeLoopV(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
                dst_v ++;
                EdgeLoopV(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
                dst_v ++;
            }
            else
            {
                dst_u += 2;
                dst_v += 2;
            }
        }
    }
}

void
deblock_mb(T264_t* t, int32_t y, int32_t x, T264_frame_t* f)
{
    int32_t i, j;
    T264_mb_context_t* cur, *prev;
    uint8_t qpav, qpavc;
    uint8_t indexA, indexB, indexAc, indexBc;
    int32_t alpha, beta, alphac, betac;
    uint8_t bSV[4][4];
    uint8_t bSH[4][4];
    uint8_t* dst_y, *dst_u, *dst_v;
    int32_t mb_xy = t->mb_stride * y + x;
    uint8_t* dst;
    
    cur = &f->mb[mb_xy];
    dst_y = f->Y[0] + (y << 4) * t->edged_stride + (x << 4);
    dst_u = f->U + (y << 3) * t->edged_stride_uv + (x << 3);
    dst_v = f->V + (y << 3) * t->edged_stride_uv + (x << 3);
    // xxx current mb_qp_delta == 0 !!
    qpav = (cur->mb_qp_delta + cur->mb_qp_delta + t->qp_y + t->qp_y + 1) >> 1;
    indexA = clip3(qpav + 0, 0, 51);
    indexB = clip3(qpav + 0, 0, 51);
    alpha = deblock_threshold_a[indexA];
    beta  = deblock_threshold_b[indexB];

    qpavc = (cur->mb_qp_delta + cur->mb_qp_delta + t->qp_uv + t->qp_uv + 1) >> 1;
    indexAc = clip3(qpavc + 0, 0, 51);
    indexBc = clip3(qpavc + 0, 0, 51);
    alphac = deblock_threshold_a[indexAc];
    betac  = deblock_threshold_b[indexBc];

    // vertical first
    // mb edge
    if (x != 0)
    {
        prev = &f->mb[mb_xy - 1];
        get_strength(t, bSV[0], 0, 0, cur, prev);
        
        dst = dst_y;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSV[0][i] > 0)
            {
                EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[0][i], 0);
                dst += t->edged_stride;
                EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[0][i], 0);
                dst += t->edged_stride;
                EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[0][i], 0);
                dst += t->edged_stride;
                EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[0][i], 0);
                dst += t->edged_stride;
            }
            else
            {
                dst += 4 * t->edged_stride;
            }
        }
    }
    for(j = 1 ; j < 4 ; j ++)
    {
        prev = cur;
        get_strength(t, bSV[j], 0, j, cur, prev);

        dst = dst_y + 4 * j;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSV[j][i] > 0)
            {
                EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[j][i], 0);
                dst += t->edged_stride;
                EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[j][i], 0);
                dst += t->edged_stride;
                EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[j][i], 0);
                dst += t->edged_stride;
                EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[j][i], 0);
                dst += t->edged_stride;
            }
            else
            {
                dst += 4 * t->edged_stride;
            }
        }
    }

    // mb edge
    if (y != 0)
    {
        prev = &f->mb[mb_xy - t->mb_stride];
        get_strength(t, bSH[0], 1, 0, cur, prev);

        dst = dst_y;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSH[0][i] > 0)
            {
                EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[0][i], 0);
                dst ++;
                EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[0][i], 0);
                dst ++;
                EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[0][i], 0);
                dst ++;
                EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[0][i], 0);
                dst ++;
            }
            else
            {
                dst += 4;
            }
        }
    }
    for(j = 1 ; j < 4 ; j ++)
    {
        prev = cur;
        get_strength(t, bSH[j], 1, j, cur, prev);

        dst = dst_y + 4 * j * t->edged_stride;
        for(i = 0 ; i < 4 ; i ++)
        {
            if (bSH[j][i] > 0)
            {
                EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[j][i], 0);
                dst ++;
                EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[j][i], 0);
                dst ++;
                EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[j][i], 0);
                dst ++;
                EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[j][i], 0);
                dst ++;
            }
            else
            {
                dst += 4;
            }
        }
    }

    deblock_mb_chroma(t, x, y, dst_u, bSV, bSH, indexAc, alphac, betac);
    deblock_mb_chroma(t, x, y, dst_v, bSV, bSH, indexAc, alphac, betac);
}

void
T264_deblock_frame(T264_t* t, T264_frame_t* f)
{
    int32_t i, j;
    
    for (i = 0 ; i < t->mb_height ; i ++)
    {
        for (j = 0 ; j < t->mb_width ; j ++)
        {			
            deblock_mb(t, i, j, f);
        }
    }
}