git.sesse.net Git - vlc/blob - modules/audio_filter/format.c

   1 /*****************************************************************************
   2  * format.c : PCM format converter
   3  *****************************************************************************
   4  * Copyright (C) 2002-2005 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   8  *          Gildas Bazin <gbazin@videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <string.h>
  29
  30 #include <vlc/vlc.h>
  31 #include <vlc_aout.h>
  32 #include <vlc_block.h>
  33 #include "vlc_filter.h"
  34
  35 #ifdef WORDS_BIGENDIAN
  36 #   define AOUT_FMT_S24_IE VLC_FOURCC('s','2','4','l')
  37 #   define AOUT_FMT_S16_IE VLC_FOURCC('s','1','6','l')
  38 #   define AOUT_FMT_U16_IE VLC_FOURCC('u','1','6','l')
  39 #else
  40 #   define AOUT_FMT_S24_IE VLC_FOURCC('s','2','4','b')
  41 #   define AOUT_FMT_S16_IE VLC_FOURCC('s','1','6','b')
  42 #   define AOUT_FMT_U16_IE VLC_FOURCC('u','1','6','b')
  43 #endif
  44
  45
  46 /*****************************************************************************
  47  * Local prototypes
  48  *****************************************************************************/
  49 static int  Open ( vlc_object_t * );
  50
  51 static block_t *Float32toS24( filter_t *, block_t * );
  52 static block_t *Float32toS16( filter_t *, block_t * );
  53 static block_t *Float32toU16( filter_t *, block_t * );
  54 static block_t *Float32toS8 ( filter_t *, block_t * );
  55 static block_t *Float32toU8 ( filter_t *, block_t * );
  56
  57 static block_t *S24toFloat32  ( filter_t *, block_t * );
  58 static block_t *S24toS16      ( filter_t *, block_t * );
  59 static block_t *S24toS16Invert( filter_t *, block_t * );
  60
  61 static block_t *S16toFloat32  ( filter_t *, block_t * );
  62 static block_t *S16toS24      ( filter_t *, block_t * );
  63 static block_t *S16toS24Invert( filter_t *, block_t * );
  64 static block_t *S16toS8       ( filter_t *, block_t * );
  65 static block_t *S16toU8       ( filter_t *, block_t * );
  66 static block_t *S16toU16      ( filter_t *, block_t * );
  67
  68 static block_t *U16toFloat32( filter_t *, block_t * );
  69 static block_t *U16toS8     ( filter_t *, block_t * );
  70 static block_t *U16toU8     ( filter_t *, block_t * );
  71 static block_t *U16toS16    ( filter_t *, block_t * );
  72
  73 static block_t *Float32toS24Invert( filter_t *, block_t * );
  74 static block_t *Float32toS16Invert( filter_t *, block_t * );
  75 static block_t *Float32toU16Invert( filter_t *, block_t * );
  76
  77 static block_t *S24InverttoFloat32  ( filter_t *, block_t * );
  78 static block_t *S24InverttoS16      ( filter_t *, block_t * );
  79 static block_t *S24InverttoS16Invert( filter_t *, block_t * );
  80
  81 static block_t *S16InverttoFloat32  ( filter_t *, block_t * );
  82 static block_t *S16InverttoS24      ( filter_t *, block_t * );
  83 static block_t *S16InverttoS24Invert( filter_t *, block_t * );
  84 static block_t *S16InverttoS8       ( filter_t *, block_t * );
  85 static block_t *S16InverttoU8       ( filter_t *, block_t * );
  86 static block_t *S16InverttoU16      ( filter_t *, block_t * );
  87
  88 static block_t *U16InverttoFloat32( filter_t *, block_t * );
  89 static block_t *U16InverttoS8     ( filter_t *, block_t * );
  90 static block_t *U16InverttoU8     ( filter_t *, block_t * );
  91 static block_t *U16InverttoS16    ( filter_t *, block_t * );
  92
  93 static block_t *S8toFloat32  ( filter_t *, block_t * );
  94 static block_t *S8toS16      ( filter_t *, block_t * );
  95 static block_t *S8toU16      ( filter_t *, block_t * );
  96 static block_t *S8toU8       ( filter_t *, block_t * );
  97 static block_t *S8toS16Invert( filter_t *, block_t * );
  98 static block_t *S8toU16Invert( filter_t *, block_t * );
  99
 100 static block_t *U8toFloat32  ( filter_t *, block_t * );
 101 static block_t *U8toFloat32  ( filter_t *, block_t * );
 102 static block_t *U8toS16      ( filter_t *, block_t * );
 103 static block_t *U8toU16      ( filter_t *, block_t * );
 104 static block_t *U8toS8       ( filter_t *, block_t * );
 105 static block_t *U8toS16Invert( filter_t *, block_t * );
 106 static block_t *U8toU16Invert( filter_t *, block_t * );
 107
 108
 109 static block_t *U8toS8( filter_t *, block_t * );
 110 static block_t *S8toU8( filter_t *, block_t * );
 111
 112
 113 static block_t *Swap16( filter_t *, block_t * );
 114 static block_t *Swap24( filter_t *, block_t * );
 115
 116 static struct
 117 {
 118     vlc_fourcc_t i_src;
 119     vlc_fourcc_t i_dst;
 120     block_t *(*pf_convert)( filter_t *, block_t *);
 121 } ConvertTable[] =
 122 {
 123     /* From fl32 */
 124     { VLC_FOURCC('f','l','3','2'), AOUT_FMT_S24_NE, Float32toS24 },
 125     { VLC_FOURCC('f','l','3','2'), AOUT_FMT_S16_NE, Float32toS16 },
 126     { VLC_FOURCC('f','l','3','2'), AOUT_FMT_U16_NE, Float32toU16 },
 127     { VLC_FOURCC('f','l','3','2'), AOUT_FMT_S24_IE, Float32toS24Invert },
 128     { VLC_FOURCC('f','l','3','2'), AOUT_FMT_S16_IE, Float32toS16Invert },
 129     { VLC_FOURCC('f','l','3','2'), AOUT_FMT_U16_IE, Float32toU16Invert },
 130     { VLC_FOURCC('f','l','3','2'), VLC_FOURCC('s','8',' ',' '), Float32toS8 },
 131     { VLC_FOURCC('f','l','3','2'), VLC_FOURCC('u','8',' ',' '), Float32toU8 },
 132
 133     /* From s24 invert */
 134     { AOUT_FMT_S24_NE, VLC_FOURCC('f','l','3','2'), S24toFloat32 },
 135     { AOUT_FMT_S24_NE, AOUT_FMT_S24_IE,             Swap24 },
 136     { AOUT_FMT_S24_NE, AOUT_FMT_S16_NE,             S24toS16 },
 137     { AOUT_FMT_S24_NE, AOUT_FMT_S16_IE,             S24toS16Invert },
 138
 139     /* From s16 */
 140     { AOUT_FMT_S16_NE, VLC_FOURCC('f','l','3','2'), S16toFloat32 },
 141     { AOUT_FMT_S16_NE, AOUT_FMT_S24_NE,             S16toS24 },
 142     { AOUT_FMT_S16_NE, AOUT_FMT_S24_IE,             S16toS24Invert },
 143     { AOUT_FMT_S16_NE, AOUT_FMT_S16_IE,             Swap16 },
 144     { AOUT_FMT_S16_NE, AOUT_FMT_U16_IE,             S16toU16 },
 145     { AOUT_FMT_S16_NE, VLC_FOURCC('s','8',' ',' '), S16toS8 },
 146     { AOUT_FMT_S16_NE, VLC_FOURCC('u','8',' ',' '), S16toU8 },
 147
 148     /* From u16 */
 149     { AOUT_FMT_U16_NE, VLC_FOURCC('f','l','3','2'), U16toFloat32 },
 150     { AOUT_FMT_U16_NE, AOUT_FMT_U16_IE,             Swap16 },
 151     { AOUT_FMT_U16_NE, AOUT_FMT_S16_IE,             U16toS16 },
 152     { AOUT_FMT_U16_NE, VLC_FOURCC('s','8',' ',' '), U16toS8 },
 153     { AOUT_FMT_U16_NE, VLC_FOURCC('u','8',' ',' '), U16toU8 },
 154
 155     /* From s8 */
 156     { VLC_FOURCC('s','8',' ',' '), VLC_FOURCC('f','l','3','2'), S8toFloat32 },
 157     { VLC_FOURCC('s','8',' ',' '), AOUT_FMT_S16_NE,             S8toS16 },
 158     { VLC_FOURCC('s','8',' ',' '), AOUT_FMT_S16_IE,             S8toS16Invert },
 159     { VLC_FOURCC('s','8',' ',' '), AOUT_FMT_U16_NE,             S8toU16 },
 160     { VLC_FOURCC('s','8',' ',' '), AOUT_FMT_U16_IE,             S8toU16Invert },
 161     { VLC_FOURCC('s','8',' ',' '), VLC_FOURCC('u','8',' ',' '), S8toU8 },
 162
 163     /* From u8 */
 164     { VLC_FOURCC('u','8',' ',' '), VLC_FOURCC('f','l','3','2'), U8toFloat32 },
 165     { VLC_FOURCC('u','8',' ',' '), AOUT_FMT_S16_NE,             U8toS16 },
 166     { VLC_FOURCC('u','8',' ',' '), AOUT_FMT_S16_IE,             U8toS16Invert },
 167     { VLC_FOURCC('u','8',' ',' '), AOUT_FMT_U16_NE,             U8toU16 },
 168     { VLC_FOURCC('u','8',' ',' '), AOUT_FMT_U16_IE,             U8toU16Invert },
 169     { VLC_FOURCC('u','8',' ',' '), VLC_FOURCC('s','8',' ',' '), U8toS8 },
 170
 171     /* From s24 invert */
 172     { AOUT_FMT_S24_IE, VLC_FOURCC('f','l','3','2'), S24InverttoFloat32 },
 173     { AOUT_FMT_S24_IE, AOUT_FMT_S24_NE,             Swap24 },
 174     { AOUT_FMT_S24_IE, AOUT_FMT_S16_NE,             S24InverttoS16 },
 175     { AOUT_FMT_S24_IE, AOUT_FMT_S16_IE,             S24InverttoS16Invert },
 176
 177     /* From s16 invert */
 178     { AOUT_FMT_S16_IE, VLC_FOURCC('f','l','3','2'), S16InverttoFloat32 },
 179     { AOUT_FMT_S16_IE, AOUT_FMT_S24_NE,             S16InverttoS24 },
 180     { AOUT_FMT_S16_IE, AOUT_FMT_S24_IE,             S16InverttoS24Invert },
 181     { AOUT_FMT_S16_IE, AOUT_FMT_S16_NE,             Swap16 },
 182     { AOUT_FMT_S16_IE, AOUT_FMT_U16_NE,             S16InverttoU16 },
 183     { AOUT_FMT_S16_IE, VLC_FOURCC('s','8',' ',' '), S16InverttoS8 },
 184     { AOUT_FMT_S16_IE, VLC_FOURCC('u','8',' ',' '), S16InverttoU8 },
 185
 186     /* From u16 invert */
 187     { AOUT_FMT_U16_IE, VLC_FOURCC('f','l','3','2'), U16InverttoFloat32 },
 188     { AOUT_FMT_U16_IE, AOUT_FMT_U16_NE,             Swap16 },
 189     { AOUT_FMT_U16_IE, AOUT_FMT_S16_NE,             U16InverttoS16 },
 190     { AOUT_FMT_U16_IE, VLC_FOURCC('s','8',' ',' '), U16InverttoS8 },
 191     { AOUT_FMT_U16_IE, VLC_FOURCC('u','8',' ',' '), U16InverttoU8 },
 192
 193     { 0, 0, NULL },
 194 };
 195
 196
 197 /*****************************************************************************
 198  * Module descriptor
 199  *****************************************************************************/
 200 vlc_module_begin();
 201     set_description( _("Audio filter for PCM format conversion") );
 202     set_category( CAT_AUDIO );
 203     set_subcategory( SUBCAT_AUDIO_MISC );
 204     set_capability( "audio filter2", 1 );
 205     set_callbacks( Open, NULL );
 206 vlc_module_end();
 207
 208 /*****************************************************************************
 209  * Open:
 210  *****************************************************************************/
 211 static int Open( vlc_object_t *p_this )
 212 {
 213     filter_t *p_filter = (filter_t *)p_this;
 214     int i;
 215
 216     for( i = 0; ConvertTable[i].pf_convert != NULL; i++ )
 217     {
 218         if( ConvertTable[i].i_src == p_filter->fmt_in.i_codec &&
 219             ConvertTable[i].i_dst == p_filter->fmt_out.i_codec )
 220             break;
 221     }
 222     if( ConvertTable[i].pf_convert == NULL )
 223         return VLC_EGENERIC;
 224
 225     p_filter->pf_audio_filter = ConvertTable[i].pf_convert;
 226     p_filter->fmt_out.audio = p_filter->fmt_in.audio;
 227     p_filter->fmt_out.audio.i_format = p_filter->fmt_out.i_codec;
 228
 229     msg_Dbg( p_this, "%4.4s->%4.4s, bits per sample: %i",
 230              (char *)&p_filter->fmt_in.i_codec,
 231              (char *)&p_filter->fmt_out.i_codec,
 232              p_filter->fmt_in.audio.i_bitspersample );
 233
 234     return VLC_SUCCESS;
 235 }
 236
 237 /*****************************************************************************
 238  * Convert a buffer
 239  *****************************************************************************/
 240 static block_t *Float32toS24( filter_t *p_filter, block_t *p_block )
 241 {
 242     int i;
 243     float *p_in = (float *)p_block->p_buffer;
 244     uint8_t *p_out = (uint8_t *)p_in;
 245     int32_t out;
 246
 247     for( i = p_block->i_buffer / 4; i--; )
 248     {
 249         if ( *p_in >= 1.0 ) out = 8388607;
 250         else if ( *p_in < -1.0 ) out = -8388608;
 251         else out = *p_in * 8388608.0;
 252
 253 #ifdef WORDS_BIGENDIAN
 254         *((int16_t *)p_out) = out >> 8;
 255         p_out[2] = out & 0xFF;
 256 #else
 257         *((int16_t *)(p_out+1)) = out >> 8;
 258         p_out[0] = out & 0xFF;
 259 #endif
 260
 261         p_in++; p_out += 3;
 262     }
 263
 264     p_block->i_buffer = p_block->i_buffer * 3 / 4;
 265     return p_block;
 266 }
 267
 268 static block_t *Float32toS16( filter_t *p_filter, block_t *p_block )
 269 {
 270     int i;
 271     float *p_in = (float *)p_block->p_buffer;
 272     int16_t *p_out = (int16_t *)p_in;
 273
 274     for( i = p_block->i_buffer / 4; i--; )
 275     {
 276 #if 0
 277         /* Slow version. */
 278         if ( *p_in >= 1.0 ) *p_out = 32767;
 279         else if ( *p_in < -1.0 ) *p_out = -32768;
 280         else *p_out = *p_in * 32768.0;
 281 #else
 282         /* This is walken's trick based on IEEE float format. */
 283         union { float f; int32_t i; } u;
 284         u.f = *p_in + 384.0;
 285         if ( u.i > 0x43c07fff ) *p_out = 32767;
 286         else if ( u.i < 0x43bf8000 ) *p_out = -32768;
 287         else *p_out = u.i - 0x43c00000;
 288 #endif
 289         p_in++; p_out++;
 290     }
 291
 292     p_block->i_buffer /= 2;
 293     return p_block;
 294 }
 295
 296 static block_t *Float32toU16( filter_t *p_filter, block_t *p_block )
 297 {
 298     int i;
 299     float *p_in = (float *)p_block->p_buffer;
 300     uint16_t *p_out = (uint16_t *)p_in;
 301
 302     for( i = p_block->i_buffer / 4; i--; )
 303     {
 304         if ( *p_in >= 1.0 ) *p_out = 65535;
 305         else if ( *p_in < -1.0 ) *p_out = 0;
 306         else *p_out = (uint16_t)(32768 + *p_in * 32768);
 307         p_in++; p_out++;
 308     }
 309
 310     p_block->i_buffer /= 2;
 311     return p_block;
 312 }
 313
 314 static block_t *S24toFloat32( filter_t *p_filter, block_t *p_block )
 315 {
 316     block_t *p_block_out;
 317     uint8_t *p_in;
 318     float *p_out;
 319     int i;
 320
 321     p_block_out =
 322         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer * 4 / 3 );
 323     if( !p_block_out )
 324     {
 325         msg_Warn( p_filter, "can't get output buffer" );
 326         return NULL;
 327     }
 328
 329     p_in = p_block->p_buffer;
 330     p_out = (float *)p_block_out->p_buffer;
 331
 332     for( i = p_block->i_buffer / 3; i--; )
 333     {
 334         /* FIXME: unaligned reads */
 335 #ifdef WORDS_BIGENDIAN
 336         *p_out = ((float)( (((int32_t)*(int16_t *)(p_in)) << 8) + p_in[2]))
 337 #else
 338         *p_out = ((float)( (((int32_t)*(int16_t *)(p_in+1)) << 8) + p_in[0]))
 339 #endif
 340             / 8388608.0;
 341
 342         p_in += 3; p_out++;
 343     }
 344
 345     p_block_out->i_samples = p_block->i_samples;
 346     p_block_out->i_dts = p_block->i_dts;
 347     p_block_out->i_pts = p_block->i_pts;
 348     p_block_out->i_length = p_block->i_length;
 349     p_block_out->i_rate = p_block->i_rate;
 350
 351     p_block->pf_release( p_block );
 352     return p_block_out;
 353 }
 354
 355 static block_t *S24toS16( filter_t *p_filter, block_t *p_block )
 356 {
 357     int i;
 358     uint8_t *p_in = (uint8_t *)p_block->p_buffer;
 359     uint8_t *p_out = (uint8_t *)p_in;
 360
 361     for( i = p_block->i_buffer / 3; i--; )
 362     {
 363 #ifdef WORDS_BIGENDIAN
 364         *p_out++ = *p_in++;
 365         *p_out++ = *p_in++;
 366         p_in++;
 367 #else
 368         p_in++;
 369         *p_out++ = *p_in++;
 370         *p_out++ = *p_in++;
 371 #endif
 372     }
 373
 374     p_block->i_buffer = p_block->i_buffer * 2 / 3;
 375     return p_block;
 376 }
 377
 378 static block_t *S16toFloat32( filter_t *p_filter, block_t *p_block )
 379 {
 380     block_t *p_block_out;
 381     int16_t *p_in;
 382     float *p_out;
 383     int i;
 384
 385     p_block_out =
 386         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
 387     if( !p_block_out )
 388     {
 389         msg_Warn( p_filter, "can't get output buffer" );
 390         return NULL;
 391     }
 392
 393     p_in = (int16_t *)p_block->p_buffer;
 394     p_out = (float *)p_block_out->p_buffer;
 395
 396     for( i = p_block->i_buffer / 2; i--; )
 397     {
 398 #if 0
 399         /* Slow version */
 400         *p_out = (float)*p_in / 32768.0;
 401 #else
 402         /* This is walken's trick based on IEEE float format. On my PIII
 403          * this takes 16 seconds to perform one billion conversions, instead
 404          * of 19 seconds for the above division. */
 405         union { float f; int32_t i; } u;
 406         u.i = *p_in + 0x43c00000;
 407         *p_out = u.f - 384.0;
 408 #endif
 409
 410         p_in++; p_out++;
 411     }
 412
 413     p_block_out->i_samples = p_block->i_samples;
 414     p_block_out->i_dts = p_block->i_dts;
 415     p_block_out->i_pts = p_block->i_pts;
 416     p_block_out->i_length = p_block->i_length;
 417     p_block_out->i_rate = p_block->i_rate;
 418
 419     p_block->pf_release( p_block );
 420     return p_block_out;
 421 }
 422
 423 static block_t *U16toFloat32( filter_t *p_filter, block_t *p_block )
 424 {
 425     block_t *p_block_out;
 426     uint16_t *p_in;
 427     float *p_out;
 428     int i;
 429
 430     p_block_out =
 431         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
 432     if( !p_block_out )
 433     {
 434         msg_Warn( p_filter, "can't get output buffer" );
 435         return NULL;
 436     }
 437
 438     p_in = (uint16_t *)p_block->p_buffer;
 439     p_out = (float *)p_block_out->p_buffer;
 440
 441     for( i = p_block->i_buffer / 2; i--; )
 442     {
 443         *p_out++ = (float)(*p_in++ - 32768) / 32768.0;
 444     }
 445
 446     p_block_out->i_samples = p_block->i_samples;
 447     p_block_out->i_dts = p_block->i_dts;
 448     p_block_out->i_pts = p_block->i_pts;
 449     p_block_out->i_length = p_block->i_length;
 450     p_block_out->i_rate = p_block->i_rate;
 451
 452     p_block->pf_release( p_block );
 453     return p_block_out;
 454 }
 455
 456 static block_t *S16toS24( filter_t *p_filter, block_t *p_block )
 457 {
 458     block_t *p_block_out;
 459     uint8_t *p_in, *p_out;
 460     int i;
 461
 462     p_block_out =
 463         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*3/2 );
 464     if( !p_block_out )
 465     {
 466         msg_Warn( p_filter, "can't get output buffer" );
 467         return NULL;
 468     }
 469
 470     p_in = (uint8_t *)p_block->p_buffer;
 471     p_out = (uint8_t *)p_block_out->p_buffer;
 472
 473     for( i = p_block->i_buffer / 2; i--; )
 474     {
 475 #ifdef WORDS_BIGENDIAN
 476         *p_out++ = *p_in++;
 477         *p_out++ = *p_in++;
 478         *p_out++ = 0;
 479 #else
 480         *p_out++ = 0;
 481         *p_out++ = *p_in++;
 482         *p_out++ = *p_in++;
 483 #endif
 484     }
 485
 486     p_block_out->i_samples = p_block->i_samples;
 487     p_block_out->i_dts = p_block->i_dts;
 488     p_block_out->i_pts = p_block->i_pts;
 489     p_block_out->i_length = p_block->i_length;
 490     p_block_out->i_rate = p_block->i_rate;
 491
 492     p_block->pf_release( p_block );
 493     return p_block_out;
 494 }
 495
 496 static block_t *S16toS8( filter_t *p_filter, block_t *p_block )
 497 {
 498     int i;
 499     int16_t *p_in = (int16_t *)p_block->p_buffer;
 500     int8_t *p_out = (int8_t *)p_in;
 501
 502     for( i = p_block->i_buffer / 2; i--; )
 503         *p_out++ = (*p_in++) >> 8;
 504
 505     p_block->i_buffer /= 2;
 506     return p_block;
 507 }
 508 static block_t *S16toU8( filter_t *p_filter, block_t *p_block )
 509 {
 510     int i;
 511     int16_t *p_in = (int16_t *)p_block->p_buffer;
 512     uint8_t *p_out = (uint8_t *)p_in;
 513
 514     for( i = p_block->i_buffer / 2; i--; )
 515         *p_out++ = ((*p_in++) + 32768) >> 8;
 516
 517     p_block->i_buffer /= 2;
 518     return p_block;
 519 }
 520 static block_t *S16toU16( filter_t *p_filter, block_t *p_block )
 521 {
 522     int i;
 523     int16_t *p_in = (int16_t *)p_block->p_buffer;
 524     uint16_t *p_out = (uint16_t *)p_in;
 525
 526     for( i = p_block->i_buffer / 2; i--; )
 527         *p_out++ = (*p_in++) + 32768;
 528
 529     return p_block;
 530 }
 531
 532 static block_t *U16toS8( filter_t *p_filter, block_t *p_block )
 533 {
 534     int i;
 535     uint16_t *p_in = (uint16_t *)p_block->p_buffer;
 536     int8_t *p_out = (int8_t *)p_in;
 537
 538     for( i = p_block->i_buffer / 2; i--; )
 539         *p_out++ = ((int)(*p_in++) - 32768) >> 8;
 540
 541     p_block->i_buffer /= 2;
 542     return p_block;
 543 }
 544 static block_t *U16toU8( filter_t *p_filter, block_t *p_block )
 545 {
 546     int i;
 547     uint16_t *p_in = (uint16_t *)p_block->p_buffer;
 548     uint8_t *p_out = (uint8_t *)p_in;
 549
 550     for( i = p_block->i_buffer / 2; i--; )
 551         *p_out++ = (*p_in++) >> 8;
 552
 553     p_block->i_buffer /= 2;
 554     return p_block;
 555 }
 556 static block_t *U16toS16( filter_t *p_filter, block_t *p_block )
 557 {
 558     int i;
 559     uint16_t *p_in = (uint16_t *)p_block->p_buffer;
 560     int16_t *p_out = (int16_t *)p_in;
 561
 562     for( i = p_block->i_buffer / 2; i--; )
 563         *p_out++ = (int)(*p_in++) - 32768;
 564
 565     return p_block;
 566 }
 567
 568 static block_t *S8toU8( filter_t *p_filter, block_t *p_block )
 569 {
 570     int i;
 571     int8_t *p_in = (int8_t *)p_block->p_buffer;
 572     uint8_t *p_out = (uint8_t *)p_in;
 573
 574     for( i = p_block->i_buffer; i--; )
 575         *p_out++ = ((*p_in++) + 128);
 576
 577     return p_block;
 578 }
 579 static block_t *U8toS8( filter_t *p_filter, block_t *p_block )
 580 {
 581     int i;
 582     uint8_t *p_in = (uint8_t *)p_block->p_buffer;
 583     int8_t *p_out = (int8_t *)p_in;
 584
 585     for( i = p_block->i_buffer; i--; )
 586         *p_out++ = ((*p_in++) - 128);
 587
 588     return p_block;
 589 }
 590
 591 /* */
 592 static block_t *S8toU16( filter_t *p_filter, block_t *p_block )
 593 {
 594     block_t *p_block_out;
 595     int8_t *p_in;
 596     uint16_t *p_out;
 597     int i;
 598
 599     p_block_out =
 600         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
 601     if( !p_block_out )
 602     {
 603         msg_Warn( p_filter, "can't get output buffer" );
 604         return NULL;
 605     }
 606
 607     p_in = (int8_t *)p_block->p_buffer;
 608     p_out = (uint16_t *)p_block_out->p_buffer;
 609
 610     for( i = p_block->i_buffer; i--; )
 611         *p_out++ = ((*p_in++) + 128) << 8;
 612
 613     p_block_out->i_samples = p_block->i_samples;
 614     p_block_out->i_dts = p_block->i_dts;
 615     p_block_out->i_pts = p_block->i_pts;
 616     p_block_out->i_length = p_block->i_length;
 617     p_block_out->i_rate = p_block->i_rate;
 618
 619     p_block->pf_release( p_block );
 620     return p_block_out;
 621 }
 622
 623 static block_t *U8toS16( filter_t *p_filter, block_t *p_block )
 624 {
 625     block_t *p_block_out;
 626     uint8_t *p_in;
 627     int16_t *p_out;
 628     int i;
 629
 630     p_block_out =
 631         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
 632     if( !p_block_out )
 633     {
 634         msg_Warn( p_filter, "can't get output buffer" );
 635         return NULL;
 636     }
 637
 638     p_in = (uint8_t *)p_block->p_buffer;
 639     p_out = (int16_t *)p_block_out->p_buffer;
 640
 641     for( i = p_block->i_buffer; i--; )
 642         *p_out++ = ((*p_in++) - 128) << 8;
 643
 644     p_block_out->i_samples = p_block->i_samples;
 645     p_block_out->i_dts = p_block->i_dts;
 646     p_block_out->i_pts = p_block->i_pts;
 647     p_block_out->i_length = p_block->i_length;
 648     p_block_out->i_rate = p_block->i_rate;
 649
 650     p_block->pf_release( p_block );
 651     return p_block_out;
 652 }
 653
 654
 655 static block_t *S8toS16( filter_t *p_filter, block_t *p_block )
 656 {
 657     block_t *p_block_out;
 658     int8_t *p_in;
 659     int16_t *p_out;
 660     int i;
 661
 662     p_block_out =
 663         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
 664     if( !p_block_out )
 665     {
 666         msg_Warn( p_filter, "can't get output buffer" );
 667         return NULL;
 668     }
 669
 670     p_in = (int8_t *)p_block->p_buffer;
 671     p_out = (int16_t *)p_block_out->p_buffer;
 672
 673     for( i = p_block->i_buffer; i--; )
 674         *p_out++ = (*p_in++) << 8;
 675
 676     p_block_out->i_samples = p_block->i_samples;
 677     p_block_out->i_dts = p_block->i_dts;
 678     p_block_out->i_pts = p_block->i_pts;
 679     p_block_out->i_length = p_block->i_length;
 680     p_block_out->i_rate = p_block->i_rate;
 681
 682     p_block->pf_release( p_block );
 683     return p_block_out;
 684 }
 685
 686 static block_t *U8toU16( filter_t *p_filter, block_t *p_block )
 687 {
 688     block_t *p_block_out;
 689     uint8_t *p_in;
 690     uint16_t *p_out;
 691     int i;
 692
 693     p_block_out =
 694         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
 695     if( !p_block_out )
 696     {
 697         msg_Warn( p_filter, "can't get output buffer" );
 698         return NULL;
 699     }
 700
 701     p_in = (uint8_t *)p_block->p_buffer;
 702     p_out = (uint16_t *)p_block_out->p_buffer;
 703
 704     for( i = p_block->i_buffer; i--; )
 705         *p_out++ = (*p_in++) << 8;
 706
 707     p_block_out->i_samples = p_block->i_samples;
 708     p_block_out->i_dts = p_block->i_dts;
 709     p_block_out->i_pts = p_block->i_pts;
 710     p_block_out->i_length = p_block->i_length;
 711     p_block_out->i_rate = p_block->i_rate;
 712
 713     p_block->pf_release( p_block );
 714     return p_block_out;
 715 }
 716
 717 /*****************************************************************************
 718  * Swap a buffer of words
 719  *****************************************************************************/
 720 static block_t *Swap16( filter_t *p_filter, block_t *p_block )
 721 {
 722     int i;
 723     uint8_t *p_in = (uint8_t *)p_block->p_buffer;
 724     uint8_t tmp;
 725
 726     for( i = 0; i < p_block->i_buffer / 2; i++ )
 727     {
 728         tmp = p_in[0];
 729         p_in[0] = p_in[1];
 730         p_in[1] = tmp;
 731         p_in += 2;
 732     }
 733
 734     return p_block;
 735 }
 736
 737 static block_t *Swap24( filter_t *p_filter, block_t *p_block )
 738 {
 739     int i;
 740     uint8_t *p_in = (uint8_t *)p_block->p_buffer;
 741     uint8_t tmp;
 742
 743     for( i = 0; i < p_block->i_buffer / 3; i++ )
 744     {
 745         tmp = p_in[0];
 746         p_in[0] = p_in[2];
 747         p_in[2] = tmp;
 748         p_in += 3;
 749     }
 750
 751     return p_block;
 752 }
 753
 754 #define CONVERT_NN( func, f_in, f_out, b_pre_invert, b_post_invert, swapa, swapb ) \
 755 static block_t *func( filter_t *p_filter, block_t *p_block ) \
 756 {                                                   \
 757     if( b_pre_invert )                              \
 758         swapa( p_filter, p_block );                  \
 759                                                     \
 760     p_block = f_in##to##f_out( p_filter, p_block ); \
 761                                                     \
 762     if( b_post_invert )                             \
 763         swapb( p_filter, p_block );                  \
 764                                                     \
 765     return p_block;                                 \
 766 }
 767
 768 CONVERT_NN( Float32toS24Invert, Float32, S24, 0, 1, Swap24, Swap24 )
 769 CONVERT_NN( Float32toS16Invert, Float32, S16, 0, 1, Swap16, Swap16 )
 770 CONVERT_NN( Float32toU16Invert, Float32, U16, 0, 1, Swap16, Swap16 )
 771
 772 CONVERT_NN( S24InverttoFloat32, S24, Float32, 1, 0, Swap24, Swap24 )
 773 CONVERT_NN( S24InverttoS16,     S24, S16,     1, 0, Swap24, Swap16 )
 774 CONVERT_NN( S24InverttoS16Invert, S24, S16,   1, 1, Swap24, Swap16 )
 775 CONVERT_NN( S24toS16Invert,     S24, S16,     0, 1, Swap24, Swap16 )
 776
 777 CONVERT_NN( S16InverttoFloat32, S16, Float32, 1, 0, Swap16, Swap16 )
 778 CONVERT_NN( S16InverttoS24,     S16, S24,     1, 0, Swap16, Swap24 )
 779 CONVERT_NN( S16toS24Invert,     S16, S24,     0, 1, Swap16, Swap24 )
 780 CONVERT_NN( S16InverttoS24Invert, S16, S24,   1, 1, Swap16, Swap24 )
 781 CONVERT_NN( S16InverttoS8,      S16, S8,      1, 0, Swap16, Swap16 )
 782 CONVERT_NN( S16InverttoU8,      S16, U8,      1, 0, Swap16, Swap16 )
 783 CONVERT_NN( S16InverttoU16,     S16, U16,     1, 0, Swap16, Swap16 )
 784
 785 CONVERT_NN( U16InverttoFloat32, U16, Float32, 1, 0, Swap16, Swap16 )
 786 CONVERT_NN( U16InverttoS8,      U16, S8,      1, 0, Swap16, Swap16 )
 787 CONVERT_NN( U16InverttoU8,      U16, U8,      1, 0, Swap16, Swap16 )
 788 CONVERT_NN( U16InverttoS16,     U16, S16,     1, 0, Swap16, Swap16 )
 789
 790 #undef CONVERT_NN
 791
 792 #define CONVERT_INDIRECT( func, f_in, f_mid, f_out )                    \
 793 static block_t *func( filter_t *p_filter, block_t *p_block )            \
 794 {                                                                       \
 795     return f_mid##to##f_out( p_filter,                                  \
 796                              f_in##to##f_mid( p_filter, p_block ) );    \
 797 }
 798
 799 CONVERT_INDIRECT( Float32toS8,   Float32, S16, U8 )
 800 CONVERT_INDIRECT( Float32toU8,   Float32, U16, U8 )
 801 CONVERT_INDIRECT( S8toFloat32,   S8,      S16, Float32 )
 802 CONVERT_INDIRECT( U8toFloat32,   U8,      U16, Float32 )
 803
 804 #define S16toS16Invert Swap16
 805 #define U16toU16Invert Swap16
 806
 807 CONVERT_INDIRECT( U8toS16Invert, U8,      S16, S16Invert )
 808 CONVERT_INDIRECT( S8toU16Invert, S8,      U16, U16Invert )
 809
 810 CONVERT_INDIRECT( U8toU16Invert, U8,      U16, U16Invert )
 811 CONVERT_INDIRECT( S8toS16Invert, S8,      S16, S16Invert )
 812
 813 #undef CONVERT_INDIRECT