block.c

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

        {
            t->pia[MB_16x8](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3] + 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2], 
                t->ref[list_index][vec.refno]->Y[index[y][x][1]] + ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5] + 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4],
                t->edged_stride, t->edged_stride, ref + 16 * 8, 16);
        }
        break;
    case MB_8x16:
        vec = t->mb.vec[0][0];
        x = (vec.x & 3);
        y = (vec.y & 3);

        if (index[y][x][0] == index[y][x][1])
        {
            tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + ((t->mb.mb_y << 4) + (vec.y >> 2)) * t->edged_stride + 
                ((t->mb.mb_x << 4) + (vec.x >> 2));
            t->memcpy_stride_u(tmp, 8, 16, t->edged_stride, ref, 16);
        }
        else
        {
            t->pia[MB_8x16](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3]) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2], 
                t->ref[list_index][vec.refno]->Y[index[y][x][1]] + ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5]) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4],
                t->edged_stride, t->edged_stride, ref, 16);
        }

        vec = t->mb.vec[0][2];
        x = (vec.x & 3);
        y = (vec.y & 3);

        if (index[y][x][0] == index[y][x][1])
        {
            tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + ((t->mb.mb_y << 4) + (vec.y >> 2)) * t->edged_stride + 
                ((t->mb.mb_x << 4) + (vec.x >> 2)) + 8;
            t->memcpy_stride_u(tmp, 8, 16, t->edged_stride, ref + 8, 16);
        }
        else
        {
            t->pia[MB_8x16](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3]) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2] + 8, 
                t->ref[list_index][vec.refno]->Y[index[y][x][1]] + ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5]) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4] + 8,
                t->edged_stride, t->edged_stride, ref + 8, 16);
        }
        break;
    case MB_8x8:
    case MB_8x8ref0:
        for(i = 0 ; i < 4 ; i ++)
        {
            int32_t offset1, offset2;
            switch(t->mb.submb_part[luma_index[4 * i]]) 
            {
            case MB_8x8:
                vec = t->mb.vec[0][luma_index[4 * i]];
                x = (vec.x & 3);
                y = (vec.y & 3);

                if (index[y][x][0] == index[y][x][1])
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + i / 2 * 8) * t->edged_stride + ((t->mb.mb_x << 4) + (vec.x >> 2)) + i % 2 * 8;
                    tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1;
                    t->memcpy_stride_u(tmp, 8, 8, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8, 16);
                }
                else
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2] + i % 2 * 8;
                    offset2 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4] + i % 2 * 8;
                    t->pia[MB_8x8](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1, 
                        t->ref[list_index][vec.refno]->Y[index[y][x][1]] + offset2,
                        t->edged_stride, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8, 
                        16);
                }
                break;
            case MB_8x4:
                vec = t->mb.vec[0][luma_index[4 * i]];
                x = (vec.x & 3);
                y = (vec.y & 3);

                if (index[y][x][0] == index[y][x][1])
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + i / 2 * 8) * t->edged_stride + ((t->mb.mb_x << 4) + (vec.x >> 2)) + i % 2 * 8;
                    tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1;
                    t->memcpy_stride_u(tmp, 8, 4, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8, 16);
                }
                else
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2] + i % 2 * 8;
                    offset2 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4] + i % 2 * 8;
                    t->pia[MB_8x4](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1, 
                        t->ref[list_index][vec.refno]->Y[index[y][x][1]] + offset2,
                        t->edged_stride, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8, 
                        16);
                }

                vec = t->mb.vec[0][luma_index[4 * i + 2]];
                x = (vec.x & 3);
                y = (vec.y & 3);

                if (index[y][x][0] == index[y][x][1])
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + i / 2 * 8 + 4) * t->edged_stride + ((t->mb.mb_x << 4) + (vec.x >> 2)) + i % 2 * 8;
                    tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1;
                    t->memcpy_stride_u(tmp, 8, 4, t->edged_stride, ref + i / 2  * 16 * 8 + 64 + i % 2 * 8, 16);
                }
                else
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3] + i / 2 * 8 + 4) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2] + i % 2 * 8;
                    offset2 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5] + i / 2 * 8 + 4) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4] + i % 2 * 8;
                    t->pia[MB_8x4](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1, 
                        t->ref[list_index][vec.refno]->Y[index[y][x][1]] + offset2,
                        t->edged_stride, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8 + 64, 
                        16);
                }
                break;
            case MB_4x8:
                vec = t->mb.vec[0][luma_index[4 * i]];
                x = (vec.x & 3);
                y = (vec.y & 3);

                if (index[y][x][0] == index[y][x][1])
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + i / 2 * 8) * t->edged_stride + ((t->mb.mb_x << 4) + (vec.x >> 2)) + i % 2 * 8;
                    tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1;
                    t->memcpy_stride_u(tmp, 4, 8, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8, 16);
                }
                else
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2] + i % 2 * 8;
                    offset2 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4] + i % 2 * 8;
                    t->pia[MB_4x8](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1, 
                        t->ref[list_index][vec.refno]->Y[index[y][x][1]] + offset2,
                        t->edged_stride, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8, 
                        16);
                }

                vec = t->mb.vec[0][luma_index[4 * i + 1]];
                x = (vec.x & 3);
                y = (vec.y & 3);

                if (index[y][x][0] == index[y][x][1])
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + i / 2 * 8) * t->edged_stride + ((t->mb.mb_x << 4) + (vec.x >> 2)) + i % 2 * 8 + 4;
                    tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1;
                    t->memcpy_stride_u(tmp, 4, 8, t->edged_stride, ref + i / 2  * 16 * 8 + i % 2 * 8 + 4, 16);
                }
                else
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2] + i % 2 * 8 + 4;
                    offset2 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4] + i % 2 * 8 + 4;
                    t->pia[MB_4x8](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1, 
                        t->ref[list_index][vec.refno]->Y[index[y][x][1]] + offset2,
                        t->edged_stride, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8 + 4, 
                        16);
                }
                break;
            case MB_4x4:
                vec = t->mb.vec[0][luma_index[4 * i]];
                x = (vec.x & 3);
                y = (vec.y & 3);

                if (index[y][x][0] == index[y][x][1])
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + i / 2 * 8) * t->edged_stride + ((t->mb.mb_x << 4) + (vec.x >> 2)) + i % 2 * 8;
                    tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1;
                    t->memcpy_stride_u(tmp, 4, 4, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8, 16);
                }
                else
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2] + i % 2 * 8;
                    offset2 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4] + i % 2 * 8;
                    t->pia[MB_4x4](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1, 
                        t->ref[list_index][vec.refno]->Y[index[y][x][1]] + offset2,
                        t->edged_stride, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8, 
                        16);
                }

                vec = t->mb.vec[0][luma_index[4 * i + 1]];
                x = (vec.x & 3);
                y = (vec.y & 3);

                if (index[y][x][0] == index[y][x][1])
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + i / 2 * 8) * t->edged_stride + ((t->mb.mb_x << 4) + (vec.x >> 2)) + i % 2 * 8 + 4;
                    tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1;
                    t->memcpy_stride_u(tmp, 4, 4, t->edged_stride, ref + i / 2  * 16 * 8 + i % 2 * 8 + 4, 16);
                }
                else
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2] + i % 2 * 8 + 4;
                    offset2 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5] + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4] + i % 2 * 8 + 4;
                    t->pia[MB_4x4](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1, 
                        t->ref[list_index][vec.refno]->Y[index[y][x][1]] + offset2,
                        t->edged_stride, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8 + 4, 
                        16);
                }

                vec = t->mb.vec[0][luma_index[4 * i + 2]];
                x = (vec.x & 3);
                y = (vec.y & 3);

                if (index[y][x][0] == index[y][x][1])
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + i / 2 * 8 + 4) * t->edged_stride + ((t->mb.mb_x << 4) + (vec.x >> 2)) + i % 2 * 8;
                    tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1;
                    t->memcpy_stride_u(tmp, 4, 4, t->edged_stride, ref + i / 2  * 16 * 8 + 64 + i % 2 * 8, 16);
                }
                else
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3] + i / 2 * 8 + 4) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2] + i % 2 * 8;
                    offset2 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5] + i / 2 * 8 + 4) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4] + i % 2 * 8;
                    t->pia[MB_4x4](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1, 
                        t->ref[list_index][vec.refno]->Y[index[y][x][1]] + offset2,
                        t->edged_stride, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8 + 64, 
                        16);
                }

                vec = t->mb.vec[0][luma_index[4 * i + 3]];
                x = (vec.x & 3);
                y = (vec.y & 3);

                if (index[y][x][0] == index[y][x][1])
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + i / 2 * 8 + 4) * t->edged_stride + ((t->mb.mb_x << 4) + (vec.x >> 2)) + i % 2 * 8 + 4;
                    tmp = t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1;
                    t->memcpy_stride_u(tmp, 4, 4, t->edged_stride, ref + i / 2  * 16 * 8 + 64 + i % 2 * 8 + 4, 16);
                }
                else
                {
                    offset1 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][3] + i / 2 * 8 + 4) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][2] + i % 2 * 8 + 4;
                    offset2 = ((t->mb.mb_y << 4) + (vec.y >> 2) + index[y][x][5] + i / 2 * 8 + 4) * t->edged_stride + (t->mb.mb_x << 4) + (vec.x >> 2) + index[y][x][4] + i % 2 * 8 + 4;
                    t->pia[MB_4x4](t->ref[list_index][vec.refno]->Y[index[y][x][0]] + offset1, 
                        t->ref[list_index][vec.refno]->Y[index[y][x][1]] + offset2,
                        t->edged_stride, t->edged_stride, ref + i / 2 * 16 * 8 + i % 2 * 8 + 64 + 4, 
                        16);
                }
                break;
            }
        }
        break;
    default:
        assert(0);
        break;
    }
}

void
T264dec_mb_decode_interp_transform(T264_t* t, uint8_t* ref)
{
    DECLARE_ALIGNED_MATRIX(dct, 16, 16, int16_t, 16);
 
    int16_t* curdct = dct;
    int32_t i;

    for(i = 0 ; i < 16 ; i ++)
    {
        unscan_zig_4x4(t->mb.dct_y_z[luma_index[i]], curdct);

        t->iquant4x4(curdct, t->qp_y);
        t->idct4x4(curdct);
        curdct += 16;
    }
    t->contract16to8add(dct, 16 / 4, 16 / 4, ref, t->mb.src_y, t->edged_stride);
}

void 
T264dec_mb_decode_interp_y(T264_t* t)
{
    T264dec_mb_decode_interp_mc(t, t->mb.pred_p16x16);
    T264dec_mb_decode_interp_transform(t, t->mb.pred_p16x16);
}

void 
T264dec_mb_decode_interp_uv(T264_t* t)
{
    DECLARE_ALIGNED_MATRIX(pred_u, 8, 8, uint8_t, CACHE_SIZE);
    DECLARE_ALIGNED_MATRIX(pred_v, 8, 8, uint8_t, CACHE_SIZE);

    T264_vector_t vec;
    uint8_t* src, *dst;
    uint8_t* src_u, *dst_u;
    int32_t i;
    int32_t list_index = 0;

    switch (t->mb.mb_part)
    {
    case MB_16x16:
        vec = t->mb.vec[0][0];
        src = t->ref[list_index][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
        dst = pred_u;
        t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
        src = t->ref[list_index][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
        dst = pred_v;
        t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
        break;
    case MB_16x8:
        vec = t->mb.vec[0][0];
        src_u = t->ref[list_index][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
        dst_u = pred_u;
        t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 8, 4);
        src = t->ref[list_index][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
        dst = pred_v;
        t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);