.#video_yuv.c.1.33

vlc stand 0.1.99 ist sehr einfach

    {
        intf_ErrMsg("error: %s\n", strerror(ENOMEM));
        free( p_vout->yuv.p_base );
        free( p_vout->yuv.p_buffer );
        return( 1 );
    }

    /* Initialize tables */
    SetYUV( p_vout );
    return( 0 );
}

/*****************************************************************************
 * vout_ResetTables: re-initialize translations tables
 *****************************************************************************
 * This function will initialize the tables allocated by vout_CreateTables and
 * set functions pointers.
 *****************************************************************************/
int vout_ResetYUV( vout_thread_t *p_vout )
{
    vout_EndYUV( p_vout );
    return( vout_InitYUV( p_vout ) );
}

/*****************************************************************************
 * vout_EndYUV: destroy translations tables
 *****************************************************************************
 * Free memory allocated by vout_CreateTables.
 *****************************************************************************/
void vout_EndYUV( vout_thread_t *p_vout )
{
    free( p_vout->yuv.p_base );
    free( p_vout->yuv.p_buffer );
    free( p_vout->yuv.p_offset );
}

/* following functions are local */

/*****************************************************************************
 * SetGammaTable: return intensity table transformed by gamma curve.
 *****************************************************************************
 * pi_table is a table of 256 entries from 0 to 255.
 *****************************************************************************/
static void SetGammaTable( int *pi_table, double f_gamma )
{
    int         i_y;                                       /* base intensity */

    /* Use exp(gamma) instead of gamma */
    f_gamma = exp( f_gamma );

    /* Build gamma table */
    for( i_y = 0; i_y < 256; i_y++ )
    {
        pi_table[ i_y ] = pow( (double)i_y / 256, f_gamma ) * 256;
    }
 }

/*****************************************************************************
 * SetYUV: compute tables and set function pointers
+ *****************************************************************************/
static void SetYUV( vout_thread_t *p_vout )
{
    int         pi_gamma[256];                                /* gamma table */
    int         i_index;                                  /* index in tables */

    /* Build gamma table */
    SetGammaTable( pi_gamma, p_vout->f_gamma );

    /*
     * Set pointers and build YUV tables
     */
    if( p_vout->b_grayscale )
    {
        /* Grayscale: build gray table */
        switch( p_vout->i_bytes_per_pixel )
        {
        case 1:
            {
                u16 bright[256], transp[256];

                p_vout->yuv.yuv.p_gray8 =  (u8 *)p_vout->yuv.p_base + GRAY_MARGIN;
                for( i_index = 0; i_index < GRAY_MARGIN; i_index++ )
                {
                    p_vout->yuv.yuv.p_gray8[ -i_index ] =      RGB2PIXEL( p_vout, pi_gamma[0], pi_gamma[0], pi_gamma[0] );
                    p_vout->yuv.yuv.p_gray8[ 256 + i_index ] = RGB2PIXEL( p_vout, pi_gamma[255], pi_gamma[255], pi_gamma[255] );
                }
                for( i_index = 0; i_index < 256; i_index++)
                {
                    p_vout->yuv.yuv.p_gray8[ i_index ] = pi_gamma[ i_index ];
                    bright[ i_index ] = i_index << 8;
                    transp[ i_index ] = 0;
                }
                /* the colors have been allocated, we can set the palette */
                p_vout->p_set_palette( p_vout, bright, bright, bright, transp );
                p_vout->i_white_pixel = 0xff;
                p_vout->i_black_pixel = 0x00;
                p_vout->i_gray_pixel = 0x44;
                p_vout->i_blue_pixel = 0x3b;

                break;
            }
        case 2:
            p_vout->yuv.yuv.p_gray16 =  (u16 *)p_vout->yuv.p_base + GRAY_MARGIN;
            for( i_index = 0; i_index < GRAY_MARGIN; i_index++ )
            {
                p_vout->yuv.yuv.p_gray16[ -i_index ] =      RGB2PIXEL( p_vout, pi_gamma[0], pi_gamma[0], pi_gamma[0] );
                p_vout->yuv.yuv.p_gray16[ 256 + i_index ] = RGB2PIXEL( p_vout, pi_gamma[255], pi_gamma[255], pi_gamma[255] );
            }
            for( i_index = 0; i_index < 256; i_index++)
            {
                p_vout->yuv.yuv.p_gray16[ i_index ] = RGB2PIXEL( p_vout, pi_gamma[i_index], pi_gamma[i_index], pi_gamma[i_index] );
            }
            break;
        case 3:
        case 4:
            p_vout->yuv.yuv.p_gray32 =  (u32 *)p_vout->yuv.p_base + GRAY_MARGIN;
            for( i_index = 0; i_index < GRAY_MARGIN; i_index++ )
            {
                p_vout->yuv.yuv.p_gray32[ -i_index ] =      RGB2PIXEL( p_vout, pi_gamma[0], pi_gamma[0], pi_gamma[0] );
                p_vout->yuv.yuv.p_gray32[ 256 + i_index ] = RGB2PIXEL( p_vout, pi_gamma[255], pi_gamma[255], pi_gamma[255] );
            }
            for( i_index = 0; i_index < 256; i_index++)
            {
                p_vout->yuv.yuv.p_gray32[ i_index ] = RGB2PIXEL( p_vout, pi_gamma[i_index], pi_gamma[i_index], pi_gamma[i_index] );
            }
            break;
         }
    }
    else
    {
        /* Color: build red, green and blue tables */
        switch( p_vout->i_bytes_per_pixel )
        {
        case 1:
            {
                #define RGB_MIN 0
                #define RGB_MAX 255
                #define CLIP( x ) ( ((x < 0) ? 0 : (x > 255) ? 255 : x) << 8 )

                int y,u,v;
                int r,g,b;
                int uvr, uvg, uvb;
                int i = 0, j = 0;
                u16 red[256], green[256], blue[256], transp[256];
                unsigned char lookup[PALETTE_TABLE_SIZE];

                p_vout->yuv.yuv.p_rgb8 = (u8 *)p_vout->yuv.p_base;

                /* this loop calculates the intersection of an YUV box
                 * and the RGB cube. */
                for ( y = 0; y <= 256; y += 16 )
                {
                    for ( u = 0; u <= 256; u += 32 )
                    for ( v = 0; v <= 256; v += 32 )
                    {
                        uvr = (V_RED_COEF*(v-128)) >> SHIFT;
                        uvg = (U_GREEN_COEF*(u-128) + V_GREEN_COEF*(v-128)) >> SHIFT;
                        uvb = (U_BLUE_COEF*(u-128)) >> SHIFT;
                        r = y + uvr;
                        g = y + uvg;
                        b = y + uvb;

                        if( r >= RGB_MIN && g >= RGB_MIN && b >= RGB_MIN
                                && r <= RGB_MAX && g <= RGB_MAX && b <= RGB_MAX )
                        {
                            /* this one should never happen unless someone fscked up my code */
                            if(j == 256) { intf_ErrMsg( "vout error: no colors left to build palette\n" ); break; }

                            /* clip the colors */
                            red[j] = CLIP( r );
                            green[j] = CLIP( g );
                            blue[j] = CLIP( b );
                            transp[j] = 0;

                            /* allocate color */
                            lookup[i] = 1;
                            p_vout->yuv.yuv.p_rgb8[i++] = j;
                            j++;
                        }
                        else
                        {
                            lookup[i] = 0;
                            p_vout->yuv.yuv.p_rgb8[i++] = 0;
                        }
                    }
                    i += 128-81;
                }

                /* the colors have been allocated, we can set the palette */
                /* there will eventually be a way to know which colors
                 * couldn't be allocated and try to find a replacement */
                p_vout->p_set_palette( p_vout, red, green, blue, transp );

                p_vout->i_white_pixel = 0xff;
                p_vout->i_black_pixel = 0x00;
                p_vout->i_gray_pixel = 0x44;
                p_vout->i_blue_pixel = 0x3b;

                i = 0;
                /* this loop allocates colors that got outside
                 * the RGB cube */
                for ( y = 0; y <= 256; y += 16 )
                {
                    for ( u = 0; u <= 256; u += 32 )
                    for ( v = 0; v <= 256; v += 32 )
                    {
                        int u2, v2;
                        int dist, mindist = 100000000;

                        if( lookup[i] || y==0)
                        {
                            i++;
                            continue;
                        }

                        /* heavy. yeah. */
                        for( u2 = 0; u2 <= 256; u2 += 32 )
                        for( v2 = 0; v2 <= 256; v2 += 32 )
                        {
                            j = ((y>>4)<<7) + (u2>>5)*9 + (v2>>5);
                            dist = (u-u2)*(u-u2) + (v-v2)*(v-v2);
                            if( lookup[j] )
                            /* find the nearest color */
                            if( dist < mindist )
                            {
                                p_vout->yuv.yuv.p_rgb8[i] = p_vout->yuv.yuv.p_rgb8[j];
                                mindist = dist;
                            }
                            j -= 128;
                            if( lookup[j] )
                            /* find the nearest color */
                            if( dist + 128 < mindist )
                            {
                                p_vout->yuv.yuv.p_rgb8[i] = p_vout->yuv.yuv.p_rgb8[j];
                                mindist = dist + 128;
                            }
                        }
                        i++;
                    }
                    i += 128-81;
                }