format.c

uclinux 下的vlc播放器源代码

#endif

        p_in++; p_out++;
    }

    p_block_out->i_samples = p_block->i_samples;
    p_block_out->i_dts = p_block->i_dts;
    p_block_out->i_pts = p_block->i_pts;
    p_block_out->i_length = p_block->i_length;
    p_block_out->i_rate = p_block->i_rate;

    p_block->pf_release( p_block );
    return p_block_out;
}

static block_t *U16toFloat32( filter_t *p_filter, block_t *p_block )
{
    block_t *p_block_out;
    uint16_t *p_in;
    float *p_out;
    int i;

    p_block_out =
        p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
    if( !p_block_out )
    {
        msg_Warn( p_filter, "can't get output buffer" );
        return NULL;
    }

    p_in = (uint16_t *)p_block->p_buffer;
    p_out = (float *)p_block_out->p_buffer;

    for( i = p_block->i_buffer / 2; i--; )
    {
        *p_out++ = (float)(*p_in++ - 32768) / 32768.0;
    }

    p_block_out->i_samples = p_block->i_samples;
    p_block_out->i_dts = p_block->i_dts;
    p_block_out->i_pts = p_block->i_pts;
    p_block_out->i_length = p_block->i_length;
    p_block_out->i_rate = p_block->i_rate;

    p_block->pf_release( p_block );
    return p_block_out;
}

static block_t *S16toS24( filter_t *p_filter, block_t *p_block )
{
    block_t *p_block_out;
    uint8_t *p_in, *p_out;
    int i;

    p_block_out =
        p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*3/2 );
    if( !p_block_out )
    {
        msg_Warn( p_filter, "can't get output buffer" );
        return NULL;
    }

    p_in = (uint8_t *)p_block->p_buffer;
    p_out = (uint8_t *)p_block_out->p_buffer;

    for( i = p_block->i_buffer / 2; i--; )
    {
#ifdef WORDS_BIGENDIAN
        *p_out++ = *p_in++;
        *p_out++ = *p_in++;
        *p_out++ = 0;
#else
        *p_out++ = 0;
        *p_out++ = *p_in++;
        *p_out++ = *p_in++;
#endif
    }

    p_block_out->i_samples = p_block->i_samples;
    p_block_out->i_dts = p_block->i_dts;
    p_block_out->i_pts = p_block->i_pts;
    p_block_out->i_length = p_block->i_length;
    p_block_out->i_rate = p_block->i_rate;

    p_block->pf_release( p_block );
    return p_block_out;
}

static block_t *S16toS8( filter_t *p_filter, block_t *p_block )
{
    int i;
    int16_t *p_in = (int16_t *)p_block->p_buffer;
    int8_t *p_out = (int8_t *)p_in;

    for( i = p_block->i_buffer / 2; i--; )
        *p_out++ = (*p_in++) >> 8;

    p_block->i_buffer /= 2;
    return p_block;
}
static block_t *S16toU8( filter_t *p_filter, block_t *p_block )
{
    int i;
    int16_t *p_in = (int16_t *)p_block->p_buffer;
    uint8_t *p_out = (uint8_t *)p_in;

    for( i = p_block->i_buffer / 2; i--; )
        *p_out++ = ((*p_in++) + 32768) >> 8;

    p_block->i_buffer /= 2;
    return p_block;
}
static block_t *S16toU16( filter_t *p_filter, block_t *p_block )
{
    int i;
    int16_t *p_in = (int16_t *)p_block->p_buffer;
    uint16_t *p_out = (uint16_t *)p_in;

    for( i = p_block->i_buffer / 2; i--; )
        *p_out++ = (*p_in++) + 32768;

    return p_block;
}

static block_t *U16toS8( filter_t *p_filter, block_t *p_block )
{
    int i;
    uint16_t *p_in = (uint16_t *)p_block->p_buffer;
    int8_t *p_out = (int8_t *)p_in;

    for( i = p_block->i_buffer / 2; i--; )
        *p_out++ = ((int)(*p_in++) - 32768) >> 8;

    p_block->i_buffer /= 2;
    return p_block;
}
static block_t *U16toU8( filter_t *p_filter, block_t *p_block )
{
    int i;
    uint16_t *p_in = (uint16_t *)p_block->p_buffer;
    uint8_t *p_out = (uint8_t *)p_in;

    for( i = p_block->i_buffer / 2; i--; )
        *p_out++ = (*p_in++) >> 8;

    p_block->i_buffer /= 2;
    return p_block;
}
static block_t *U16toS16( filter_t *p_filter, block_t *p_block )
{
    int i;
    uint16_t *p_in = (uint16_t *)p_block->p_buffer;
    int16_t *p_out = (int16_t *)p_in;

    for( i = p_block->i_buffer / 2; i--; )
        *p_out++ = (int)(*p_in++) - 32768;

    return p_block;
}

static block_t *S8toU8( filter_t *p_filter, block_t *p_block )
{
    int i;
    int8_t *p_in = (int8_t *)p_block->p_buffer;
    uint8_t *p_out = (uint8_t *)p_in;

    for( i = p_block->i_buffer; i--; )
        *p_out++ = ((*p_in++) + 128);

    return p_block;
}
static block_t *U8toS8( filter_t *p_filter, block_t *p_block )
{
    int i;
    uint8_t *p_in = (uint8_t *)p_block->p_buffer;
    int8_t *p_out = (int8_t *)p_in;

    for( i = p_block->i_buffer; i--; )
        *p_out++ = ((*p_in++) - 128);

    return p_block;
}

/* */
static block_t *S8toU16( filter_t *p_filter, block_t *p_block )
{
    block_t *p_block_out;
    int8_t *p_in;
    uint16_t *p_out;
    int i;

    p_block_out =
        p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
    if( !p_block_out )
    {
        msg_Warn( p_filter, "can't get output buffer" );
        return NULL;
    }

    p_in = (int8_t *)p_block->p_buffer;
    p_out = (uint16_t *)p_block_out->p_buffer;

    for( i = p_block->i_buffer; i--; )
        *p_out++ = ((*p_in++) + 128) << 8;

    p_block_out->i_samples = p_block->i_samples;
    p_block_out->i_dts = p_block->i_dts;
    p_block_out->i_pts = p_block->i_pts;
    p_block_out->i_length = p_block->i_length;
    p_block_out->i_rate = p_block->i_rate;

    p_block->pf_release( p_block );
    return p_block_out;
}

static block_t *U8toS16( filter_t *p_filter, block_t *p_block )
{
    block_t *p_block_out;
    uint8_t *p_in;
    int16_t *p_out;
    int i;

    p_block_out =
        p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
    if( !p_block_out )
    {
        msg_Warn( p_filter, "can't get output buffer" );
        return NULL;
    }

    p_in = (uint8_t *)p_block->p_buffer;
    p_out = (int16_t *)p_block_out->p_buffer;

    for( i = p_block->i_buffer; i--; )
        *p_out++ = ((*p_in++) - 128) << 8;

    p_block_out->i_samples = p_block->i_samples;
    p_block_out->i_dts = p_block->i_dts;
    p_block_out->i_pts = p_block->i_pts;
    p_block_out->i_length = p_block->i_length;
    p_block_out->i_rate = p_block->i_rate;

    p_block->pf_release( p_block );
    return p_block_out;
}


static block_t *S8toS16( filter_t *p_filter, block_t *p_block )
{
    block_t *p_block_out;
    int8_t *p_in;
    int16_t *p_out;
    int i;

    p_block_out =
        p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
    if( !p_block_out )
    {
        msg_Warn( p_filter, "can't get output buffer" );
        return NULL;
    }

    p_in = (int8_t *)p_block->p_buffer;
    p_out = (int16_t *)p_block_out->p_buffer;

    for( i = p_block->i_buffer; i--; )
        *p_out++ = (*p_in++) << 8;

    p_block_out->i_samples = p_block->i_samples;
    p_block_out->i_dts = p_block->i_dts;
    p_block_out->i_pts = p_block->i_pts;
    p_block_out->i_length = p_block->i_length;
    p_block_out->i_rate = p_block->i_rate;

    p_block->pf_release( p_block );
    return p_block_out;
}

static block_t *U8toU16( filter_t *p_filter, block_t *p_block )
{
    block_t *p_block_out;
    uint8_t *p_in;
    uint16_t *p_out;
    int i;

    p_block_out =
        p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
    if( !p_block_out )
    {
        msg_Warn( p_filter, "can't get output buffer" );
        return NULL;
    }

    p_in = (uint8_t *)p_block->p_buffer;
    p_out = (uint16_t *)p_block_out->p_buffer;

    for( i = p_block->i_buffer; i--; )
        *p_out++ = (*p_in++) << 8;

    p_block_out->i_samples = p_block->i_samples;
    p_block_out->i_dts = p_block->i_dts;
    p_block_out->i_pts = p_block->i_pts;
    p_block_out->i_length = p_block->i_length;
    p_block_out->i_rate = p_block->i_rate;

    p_block->pf_release( p_block );
    return p_block_out;
}

/*****************************************************************************
 * Swap a buffer of words
 *****************************************************************************/
static block_t *Swap16( filter_t *p_filter, block_t *p_block )
{
    int i;
    uint8_t *p_in = (uint8_t *)p_block->p_buffer;
    uint8_t tmp;

    for( i = 0; i < p_block->i_buffer / 2; i++ )
    {
        tmp = p_in[0];
        p_in[0] = p_in[1];
        p_in[1] = tmp;
        p_in += 2;
    }

    return p_block;
}

static block_t *Swap24( filter_t *p_filter, block_t *p_block )
{
    int i;
    uint8_t *p_in = (uint8_t *)p_block->p_buffer;
    uint8_t tmp;

    for( i = 0; i < p_block->i_buffer / 3; i++ )
    {
        tmp = p_in[0];
        p_in[0] = p_in[2];
        p_in[2] = tmp;
        p_in += 3;
    }

    return p_block;
}

#define CONVERT_NN( func, f_in, f_out, b_pre_invert, b_post_invert, swapa, swapb ) \
static block_t *func( filter_t *p_filter, block_t *p_block ) \
{                                                   \
    if( b_pre_invert )                              \
        swapa( p_filter, p_block );                  \
                                                    \
    p_block = f_in##to##f_out( p_filter, p_block ); \
                                                    \
    if( b_post_invert )                             \
        swapb( p_filter, p_block );                  \
                                                    \
    return p_block;                                 \
}

CONVERT_NN( Float32toS24Invert, Float32, S24, 0, 1, Swap24, Swap24 )
CONVERT_NN( Float32toS16Invert, Float32, S16, 0, 1, Swap16, Swap16 )
CONVERT_NN( Float32toU16Invert, Float32, U16, 0, 1, Swap16, Swap16 )

CONVERT_NN( S24InverttoFloat32, S24, Float32, 1, 0, Swap24, Swap24 )
CONVERT_NN( S24InverttoS16,     S24, S16,     1, 0, Swap24, Swap16 )
CONVERT_NN( S24InverttoS16Invert, S24, S16,   1, 1, Swap24, Swap16 )
CONVERT_NN( S24toS16Invert,     S24, S16,     0, 1, Swap24, Swap16 )

CONVERT_NN( S16InverttoFloat32, S16, Float32, 1, 0, Swap16, Swap16 )
CONVERT_NN( S16InverttoS24,     S16, S24,     1, 0, Swap16, Swap24 )
CONVERT_NN( S16toS24Invert,     S16, S24,     0, 1, Swap16, Swap24 )
CONVERT_NN( S16InverttoS24Invert, S16, S24,   1, 1, Swap16, Swap24 )
CONVERT_NN( S16InverttoS8,      S16, S8,      1, 0, Swap16, Swap16 )
CONVERT_NN( S16InverttoU8,      S16, U8,      1, 0, Swap16, Swap16 )
CONVERT_NN( S16InverttoU16,     S16, U16,     1, 0, Swap16, Swap16 )

CONVERT_NN( U16InverttoFloat32, U16, Float32, 1, 0, Swap16, Swap16 )
CONVERT_NN( U16InverttoS8,      U16, S8,      1, 0, Swap16, Swap16 )
CONVERT_NN( U16InverttoU8,      U16, U8,      1, 0, Swap16, Swap16 )
CONVERT_NN( U16InverttoS16,     U16, S16,     1, 0, Swap16, Swap16 )

#undef CONVERT_NN

#define CONVERT_INDIRECT( func, f_in, f_mid, f_out )                    \
static block_t *func( filter_t *p_filter, block_t *p_block )            \
{                                                                       \
    return f_mid##to##f_out( p_filter,                                  \
                             f_in##to##f_mid( p_filter, p_block ) );    \
}

CONVERT_INDIRECT( Float32toS8,   Float32, S16, U8 )
CONVERT_INDIRECT( Float32toU8,   Float32, U16, U8 )
CONVERT_INDIRECT( S8toFloat32,   S8,      S16, Float32 )
CONVERT_INDIRECT( U8toFloat32,   U8,      U16, Float32 )

#define S16toS16Invert Swap16
#define U16toU16Invert Swap16

CONVERT_INDIRECT( U8toS16Invert, U8,      S16, S16Invert )
CONVERT_INDIRECT( S8toU16Invert, S8,      U16, U16Invert )

CONVERT_INDIRECT( U8toU16Invert, U8,      U16, U16Invert )
CONVERT_INDIRECT( S8toS16Invert, S8,      S16, S16Invert )

#undef CONVERT_INDIRECT