edge-detec.c

H.264 source codes

            if( i_qbits >= 1 )
            {
                dct[y][x] = ( dct[y][x] * dequant_mf[i_mf][0][0] ) << (i_qbits - 1);
            }
            else
            {
                dct[y][x] = ( dct[y][x] * dequant_mf[i_mf][0][0] ) >> 1;
            }
        }
    }
}
static void dequant_4x4( int16_t dct[4][4], int i_qscale )
{
    int i_mf = i_qscale%6;
    int i_qbits = i_qscale/6;
    int x,y;

    for( y = 0; y < 4; y++ )
    {
        for( x = 0; x < 4; x++ )
        {
            dct[y][x] = ( dct[y][x] * dequant_mf[i_mf][x][y] ) << i_qbits;
        }
    }
}

static inline int array_non_zero_count( int *v, int i_count )
{
    int i;
    int i_nz;

    for( i = 0, i_nz = 0; i < i_count; i++ )
    {
        if( v[i] )
        {
            i_nz++;
        }
    }
    return i_nz;
}

/* TODO : use a table instead */
static int mb_partition_count( int i_partition )
{
    switch( i_partition )
    {
        case D_8x8:
            return 4;
        case D_16x8:
        case D_8x16:
            return 2;
        case D_16x16:
            return 1;
        default:
            /* should never occur */
            return 0;
    }
}

static int mb_sub_partition_count( int i_partition )
{
    switch( i_partition )
    {
        case D_L0_4x4:
        case D_L1_4x4:
        case D_BI_4x4:
            return 4;
        case D_L0_4x8:
        case D_L1_4x8:
        case D_BI_4x8:
        case D_L0_8x4:
        case D_L1_8x4:
        case D_BI_8x4:
            return 2;
        case D_L0_8x8:
        case D_L1_8x8:
        case D_BI_8x8:
        case D_DIRECT_8x8:
            return 1;
        default:
            /* should never occur */
            return 0;
    }
}

static inline void x264_macroblock_partition_getxy( x264_macroblock_t *mb, int i_part, int i_sub, int *x, int *y )
{
    if( mb->i_partition == D_16x16 )
    {
        *x  = 0;
        *y  = 0;
    }
    else if( mb->i_partition == D_16x8 )
    {
        *x = 0;
        *y = 2*i_part;
    }
    else if( mb->i_partition == D_8x16 )
    {
        *x = 2*i_part;
        *y = 0;
    }
    else if( mb->i_partition == D_8x8 )
    {
        *x = 2 * (i_part%2);
        *y = 2 * (i_part/2);

        if( IS_SUB4x4( mb->i_sub_partition[i_part] ) )
        {
            (*x) += i_sub%2;
            (*y) += i_sub/2;
        }
        else if( IS_SUB4x8( mb->i_sub_partition[i_part] ) )
        {
            (*x) += i_sub;
        }
        else if( IS_SUB8x4( mb->i_sub_partition[i_part] ) )
        {
            (*y) += i_sub;
        }
    }
}
static inline void x264_macroblock_partition_size( x264_macroblock_t *mb, int i_part, int i_sub, int *w, int *h )
{
    if( mb->i_partition == D_16x16 )
    {
        *w  = 4;
        *h  = 4;
    }
    else if( mb->i_partition == D_16x8 )
    {
        *w = 4;
        *h = 2;
    }
    else if( mb->i_partition == D_8x16 )
    {
        *w = 2;
        *h = 4;
    }
    else if( mb->i_partition == D_8x8 )
    {
        if( IS_SUB4x4( mb->i_sub_partition[i_part] ) )
        {
            *w = 1;
            *h = 1;
        }
        else if( IS_SUB4x8( mb->i_sub_partition[i_part] ) )
        {
            *w = 1;
            *h = 2;
        }
        else if( IS_SUB8x4( mb->i_sub_partition[i_part] ) )
        {
            *w = 2;
            *h = 1;
        }
        else
        {
            *w = 2;
            *h = 2;
        }
    }
}

void x264_macroblock_partition_set( x264_macroblock_t *mb, int i_list, int i_part, int i_sub, int i_ref, int mx, int my )
{
    int x,  y;
    int w,  h;
    int dx, dy;

    x264_macroblock_partition_getxy( mb, i_part, i_sub, &x, &y );
    x264_macroblock_partition_size ( mb, i_part, i_sub, &w, &h );

    for( dx = 0; dx < w; dx++ )
    {
        for( dy = 0; dy < h; dy++ )
        {
            mb->partition[x+dx][y+dy].i_ref[i_list] = i_ref;
            mb->partition[x+dx][y+dy].mv[i_list][0] = mx;
            mb->partition[x+dx][y+dy].mv[i_list][1] = my;
        }
    }
}

void x264_macroblock_partition_get( x264_macroblock_t *mb, int i_list, int i_part, int i_sub, int *pi_ref, int *pi_mx, int *pi_my )
{
    int x,y;

    x264_macroblock_partition_getxy( mb, i_part, i_sub, &x, &y );

    if( pi_ref )
    {
        *pi_ref = mb->partition[x][y].i_ref[i_list];
    }
    if( pi_mx && pi_my )
    {
        *pi_mx  = mb->partition[x][y].mv[i_list][0];
        *pi_my  = mb->partition[x][y].mv[i_list][1];
    }
}

/* ARrrrg so unbeautifull, and unoptimised for common case */
void x264_macroblock_predict_mv( x264_macroblock_t *mb, int i_list, int i_part, int i_subpart, int *mvxp, int *mvyp )
{
    int x, y, xn, yn;
    int w, h;
    int i_ref;

    int i_refa = -1;
    int i_refb = -1;
    int i_refc = -1;

    int mvxa = 0, mvxb = 0, mvxc = 0;
    int mvya = 0, mvyb = 0, mvyc = 0;

    x264_macroblock_t *mbn;


    x264_macroblock_partition_getxy( mb, i_part, i_subpart, &x, &y );
    x264_macroblock_partition_size( mb, i_part, i_subpart, &w, &h );
    i_ref = mb->partition[x][y].i_ref[i_list];

    /* Left  pixel (-1,0)*/
    xn = x - 1;
    mbn = mb;
    if( xn < 0 )
    {
        xn += 4;
        mbn = mb->mba;
    }
    if( mbn )
    {
        i_refa = -2;
        if( !IS_INTRA( mbn->i_type ) )
        {
            i_refa = mbn->partition[xn][y].i_ref[i_list];
            mvxa   = mbn->partition[xn][y].mv[i_list][0];
            mvya   = mbn->partition[xn][y].mv[i_list][1];
        }
    }

    /* Up ( pixel(0,-1)*/
    yn = y - 1;
    mbn = mb;
    if( yn < 0 )
    {
        yn += 4;
        mbn = mb->mbb;
    }
    if( mbn )
    {
        i_refb = -2;
        if( !IS_INTRA( mbn->i_type ) )
        {
            i_refb = mbn->partition[x][yn].i_ref[i_list];
            mvxb   = mbn->partition[x][yn].mv[i_list][0];
            mvyb   = mbn->partition[x][yn].mv[i_list][1];
        }
    }

    /* Up right pixel(width,-1)*/
    xn = x + w;
    yn = y - 1;

    mbn = mb;
    if( yn < 0 && xn >= 4 )
    {
        if( mb->mbc )
        {
            xn -= 4;
            yn += 4;
            mbn = mb->mbc;
        }
        else
        {
            mbn = NULL;
        }
    }
    else if( yn < 0 )
    {
        yn += 4;
        mbn = mb->mbb;
    }
    else if( xn >= 4 || ( xn == 2 && ( yn == 0 || yn == 2 ) ) )
    {
        mbn = NULL; /* not yet decoded */
    }

    if( mbn == NULL )
    {
        /* load top left pixel(-1,-1) */
        xn = x - 1;
        yn = y - 1;

        mbn = mb;
        if( yn < 0 && xn < 0 )
        {
            if( mb->mba && mb->mbb )
            {
                xn += 4;
                yn += 4;
                mbn = mb->mbb - 1;
            }
            else
            {
                mbn = NULL;
            }
        }
        else if( yn < 0 )
        {
            yn += 4;
            mbn = mb->mbb;
        }
        else if( xn < 0 )
        {
            xn += 4;
            mbn = mb->mba;
        }
    }

    if( mbn )
    {
        i_refc = -2;
        if( !IS_INTRA( mbn->i_type ) )
        {
            i_refc = mbn->partition[xn][yn].i_ref[i_list];
            mvxc   = mbn->partition[xn][yn].mv[i_list][0];
            mvyc   = mbn->partition[xn][yn].mv[i_list][1];
        }
    }

    if( mb->i_partition == D_16x8 && i_part == 0 && i_refb == i_ref )
    {
        *mvxp = mvxb;
        *mvyp = mvyb;
    }
    else if( mb->i_partition == D_16x8 && i_part == 1 && i_refa == i_ref )
    {
        *mvxp = mvxa;
        *mvyp = mvya;
    }
    else if( mb->i_partition == D_8x16 && i_part == 0 && i_refa == i_ref )
    {
        *mvxp = mvxa;
        *mvyp = mvya;
    }
    else if( mb->i_partition == D_8x16 && i_part == 1 && i_refc == i_ref )
    {
        *mvxp = mvxc;
        *mvyp = mvyc;
    }
    else
    {
        int i_count;

        i_count = 0;
        if( i_refa == i_ref ) i_count++;
        if( i_refb == i_ref ) i_count++;
        if( i_refc == i_ref ) i_count++;

        if( i_count > 1 )
        {
            *mvxp = x264_median( mvxa, mvxb, mvxc );
            *mvyp = x264_median( mvya, mvyb, mvyc );
        }
        else if( i_count == 1 )
        {
            if( i_refa == i_ref )
            {
                *mvxp = mvxa;
                *mvyp = mvya;
            }
            else if( i_refb == i_ref )
            {
                *mvxp = mvxb;
                *mvyp = mvyb;
            }
            else
            {
                *mvxp = mvxc;
                *mvyp = mvyc;
            }
        }
        else if( i_refb == -1 && i_refc == -1 && i_refa != -1 )
        {
            *mvxp = mvxa;
            *mvyp = mvya;
        }
        else
        {
            *mvxp = x264_median( mvxa, mvxb, mvxc );
            *mvyp = x264_median( mvya, mvyb, mvyc );
        }
    }
}

void x264_macroblock_predict_mv_pskip( x264_macroblock_t *mb, int *mvxp, int *mvyp )
{
    int x, y, xn, yn;

    int i_refa = -1;
    int i_refb = -1;

    int mvxa = 0, mvxb = 0;
    int mvya = 0, mvyb = 0;

    x264_macroblock_t *mbn;


    x264_macroblock_partition_getxy( mb, 0, 0, &x, &y );

    /* Left  pixel (-1,0)*/
    xn = x - 1;
    mbn = mb;
    if( xn < 0 )
    {
        xn += 4;
        mbn = mb->mba;
    }
    if( mbn )
    {
        i_refa = -2;
        if( !IS_INTRA( mbn->i_type ) )
        {
            i_refa = mbn->partition[xn][y].i_ref[0];
            mvxa   = mbn->partition[xn][y].mv[0][0];
            mvya   = mbn->partition[xn][y].mv[0][1];
        }
    }

    /* Up ( pixel(0,-1)*/
    yn = y - 1;
    mbn = mb;
    if( yn < 0 )
    {
        yn += 4;
        mbn = mb->mbb;
    }
    if( mbn )
    {