Fix a segfault (buffer overflow for win32 only).
[vlc.git] / 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
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_aout.h>
36 #include <vlc_block.h>
37 #include "vlc_filter.h"
38
39 /*****************************************************************************
40  * Local prototypes
41  *****************************************************************************/
42 static int  Open ( vlc_object_t * );
43
44 static block_t *Float32toS24( filter_t *, block_t * );
45 static block_t *Float32toS16( filter_t *, block_t * );
46 static block_t *Float32toU16( filter_t *, block_t * );
47 static block_t *Float32toS8 ( filter_t *, block_t * );
48 static block_t *Float32toU8 ( filter_t *, block_t * );
49
50 static block_t *S24toFloat32  ( filter_t *, block_t * );
51 static block_t *S24toS16      ( filter_t *, block_t * );
52 static block_t *S24toS16Invert( filter_t *, block_t * );
53
54 static block_t *S16toFloat32  ( filter_t *, block_t * );
55 static block_t *S16toS24      ( filter_t *, block_t * );
56 static block_t *S16toS24Invert( filter_t *, block_t * );
57 static block_t *S16toS8       ( filter_t *, block_t * );
58 static block_t *S16toU8       ( filter_t *, block_t * );
59 static block_t *S16toU16      ( filter_t *, block_t * );
60
61 static block_t *U16toFloat32( filter_t *, block_t * );
62 static block_t *U16toS8     ( filter_t *, block_t * );
63 static block_t *U16toU8     ( filter_t *, block_t * );
64 static block_t *U16toS16    ( filter_t *, block_t * );
65
66 static block_t *Float32toS24Invert( filter_t *, block_t * );
67 static block_t *Float32toS16Invert( filter_t *, block_t * );
68 static block_t *Float32toU16Invert( filter_t *, block_t * );
69
70 static block_t *S24InverttoFloat32  ( filter_t *, block_t * );
71 static block_t *S24InverttoS16      ( filter_t *, block_t * );
72 static block_t *S24InverttoS16Invert( filter_t *, block_t * );
73
74 static block_t *S16InverttoFloat32  ( filter_t *, block_t * );
75 static block_t *S16InverttoS24      ( filter_t *, block_t * );
76 static block_t *S16InverttoS24Invert( filter_t *, block_t * );
77 static block_t *S16InverttoS8       ( filter_t *, block_t * );
78 static block_t *S16InverttoU8       ( filter_t *, block_t * );
79 static block_t *S16InverttoU16      ( filter_t *, block_t * );
80
81 static block_t *U16InverttoFloat32( filter_t *, block_t * );
82 static block_t *U16InverttoS8     ( filter_t *, block_t * );
83 static block_t *U16InverttoU8     ( filter_t *, block_t * );
84 static block_t *U16InverttoS16    ( filter_t *, block_t * );
85
86 static block_t *S8toFloat32  ( filter_t *, block_t * );
87 static block_t *S8toS16      ( filter_t *, block_t * );
88 static block_t *S8toU16      ( filter_t *, block_t * );
89 static block_t *S8toU8       ( filter_t *, block_t * );
90 static block_t *S8toS16Invert( filter_t *, block_t * );
91 static block_t *S8toU16Invert( filter_t *, block_t * );
92
93 static block_t *U8toFloat32  ( filter_t *, block_t * );
94 static block_t *U8toFloat32  ( filter_t *, block_t * );
95 static block_t *U8toS16      ( filter_t *, block_t * );
96 static block_t *U8toU16      ( filter_t *, block_t * );
97 static block_t *U8toS8       ( filter_t *, block_t * );
98 static block_t *U8toS16Invert( filter_t *, block_t * );
99 static block_t *U8toU16Invert( filter_t *, block_t * );
100
101
102 static block_t *U8toS8( filter_t *, block_t * );
103 static block_t *S8toU8( filter_t *, block_t * );
104
105
106 static block_t *Swap16( filter_t *, block_t * );
107 static block_t *Swap24( filter_t *, block_t * );
108
109 static const struct
110 {
111     vlc_fourcc_t i_src;
112     vlc_fourcc_t i_dst;
113     block_t *(*pf_convert)( filter_t *, block_t *);
114 } ConvertTable[] =
115 {
116     /* From fl32 */
117     { VLC_CODEC_FL32, VLC_CODEC_S24N, Float32toS24 },
118     { VLC_CODEC_FL32, VLC_CODEC_S16N, Float32toS16 },
119     { VLC_CODEC_FL32, VLC_CODEC_U16N, Float32toU16 },
120     { VLC_CODEC_FL32, VLC_CODEC_S24I, Float32toS24Invert },
121     { VLC_CODEC_FL32, VLC_CODEC_S16I, Float32toS16Invert },
122     { VLC_CODEC_FL32, VLC_CODEC_U16I, Float32toU16Invert },
123     { VLC_CODEC_FL32, VLC_CODEC_S8, Float32toS8 },
124     { VLC_CODEC_FL32, VLC_CODEC_U8, Float32toU8 },
125
126     /* From s24 invert */
127     { VLC_CODEC_S24N, VLC_CODEC_FL32, S24toFloat32 },
128     { VLC_CODEC_S24N, VLC_CODEC_S24I,             Swap24 },
129     { VLC_CODEC_S24N, VLC_CODEC_S16N,             S24toS16 },
130     { VLC_CODEC_S24N, VLC_CODEC_S16I,             S24toS16Invert },
131
132     /* From s16 */
133     { VLC_CODEC_S16N, VLC_CODEC_FL32, S16toFloat32 },
134     { VLC_CODEC_S16N, VLC_CODEC_S24N,             S16toS24 },
135     { VLC_CODEC_S16N, VLC_CODEC_S24I,             S16toS24Invert },
136     { VLC_CODEC_S16N, VLC_CODEC_S16I,             Swap16 },
137     { VLC_CODEC_S16N, VLC_CODEC_U16I,             S16toU16 },
138     { VLC_CODEC_S16N, VLC_CODEC_S8, S16toS8 },
139     { VLC_CODEC_S16N, VLC_CODEC_U8, S16toU8 },
140
141     /* From u16 */
142     { VLC_CODEC_U16N, VLC_CODEC_FL32, U16toFloat32 },
143     { VLC_CODEC_U16N, VLC_CODEC_U16I,             Swap16 },
144     { VLC_CODEC_U16N, VLC_CODEC_S16I,             U16toS16 },
145     { VLC_CODEC_U16N, VLC_CODEC_S8, U16toS8 },
146     { VLC_CODEC_U16N, VLC_CODEC_U8, U16toU8 },
147
148     /* From s8 */
149     { VLC_CODEC_S8, VLC_CODEC_FL32, S8toFloat32 },
150     { VLC_CODEC_S8, VLC_CODEC_S16N,             S8toS16 },
151     { VLC_CODEC_S8, VLC_CODEC_S16I,             S8toS16Invert },
152     { VLC_CODEC_S8, VLC_CODEC_U16N,             S8toU16 },
153     { VLC_CODEC_S8, VLC_CODEC_U16I,             S8toU16Invert },
154     { VLC_CODEC_S8, VLC_CODEC_U8, S8toU8 },
155  
156     /* From u8 */
157     { VLC_CODEC_U8, VLC_CODEC_FL32, U8toFloat32 },
158     { VLC_CODEC_U8, VLC_CODEC_S16N,             U8toS16 },
159     { VLC_CODEC_U8, VLC_CODEC_S16I,             U8toS16Invert },
160     { VLC_CODEC_U8, VLC_CODEC_U16N,             U8toU16 },
161     { VLC_CODEC_U8, VLC_CODEC_U16I,             U8toU16Invert },
162     { VLC_CODEC_U8, VLC_CODEC_S8, U8toS8 },
163
164     /* From s24 invert */
165     { VLC_CODEC_S24I, VLC_CODEC_FL32, S24InverttoFloat32 },
166     { VLC_CODEC_S24I, VLC_CODEC_S24N,             Swap24 },
167     { VLC_CODEC_S24I, VLC_CODEC_S16N,             S24InverttoS16 },
168     { VLC_CODEC_S24I, VLC_CODEC_S16I,             S24InverttoS16Invert },
169
170     /* From s16 invert */
171     { VLC_CODEC_S16I, VLC_CODEC_FL32, S16InverttoFloat32 },
172     { VLC_CODEC_S16I, VLC_CODEC_S24N,             S16InverttoS24 },
173     { VLC_CODEC_S16I, VLC_CODEC_S24I,             S16InverttoS24Invert },
174     { VLC_CODEC_S16I, VLC_CODEC_S16N,             Swap16 },
175     { VLC_CODEC_S16I, VLC_CODEC_U16N,             S16InverttoU16 },
176     { VLC_CODEC_S16I, VLC_CODEC_S8, S16InverttoS8 },
177     { VLC_CODEC_S16I, VLC_CODEC_U8, S16InverttoU8 },
178
179     /* From u16 invert */
180     { VLC_CODEC_U16I, VLC_CODEC_FL32, U16InverttoFloat32 },
181     { VLC_CODEC_U16I, VLC_CODEC_U16N,             Swap16 },
182     { VLC_CODEC_U16I, VLC_CODEC_S16N,             U16InverttoS16 },
183     { VLC_CODEC_U16I, VLC_CODEC_S8, U16InverttoS8 },
184     { VLC_CODEC_U16I, VLC_CODEC_U8, U16InverttoU8 },
185
186     { 0, 0, NULL },
187 };
188
189
190 /*****************************************************************************
191  * Module descriptor
192  *****************************************************************************/
193 vlc_module_begin ()
194     set_description( N_("Audio filter for PCM format conversion") )
195     set_category( CAT_AUDIO )
196     set_subcategory( SUBCAT_AUDIO_MISC )
197     set_capability( "audio filter2", 1 )
198     set_callbacks( Open, NULL )
199 vlc_module_end ()
200
201 /*****************************************************************************
202  * Open:
203  *****************************************************************************/
204 static int Open( vlc_object_t *p_this )
205 {
206     filter_t *p_filter = (filter_t *)p_this;
207     int i;
208
209     for( i = 0; ConvertTable[i].pf_convert != NULL; i++ )
210     {
211         if( ConvertTable[i].i_src == p_filter->fmt_in.i_codec &&
212             ConvertTable[i].i_dst == p_filter->fmt_out.i_codec )
213             break;
214     }
215     if( ConvertTable[i].pf_convert == NULL )
216         return VLC_EGENERIC;
217
218     p_filter->pf_audio_filter = ConvertTable[i].pf_convert;
219     p_filter->fmt_out.audio = p_filter->fmt_in.audio;
220     p_filter->fmt_out.audio.i_format = p_filter->fmt_out.i_codec;
221     p_filter->fmt_out.audio.i_bitspersample =
222         aout_BitsPerSample( p_filter->fmt_out.i_codec );
223
224     msg_Dbg( p_this, "%4.4s->%4.4s, bits per sample: %i->%i",
225              (char *)&p_filter->fmt_in.i_codec,
226              (char *)&p_filter->fmt_out.i_codec,
227              p_filter->fmt_in.audio.i_bitspersample,
228              p_filter->fmt_out.audio.i_bitspersample );
229
230     return VLC_SUCCESS;
231 }
232
233 /*****************************************************************************
234  * Convert a buffer
235  *****************************************************************************/
236 static block_t *Float32toS24( filter_t *p_filter, block_t *p_block )
237 {
238     VLC_UNUSED(p_filter);
239     int i;
240     float *p_in = (float *)p_block->p_buffer;
241     uint8_t *p_out = (uint8_t *)p_in;
242     int32_t out;
243
244     for( i = p_block->i_buffer / 4; i--; )
245     {
246         if ( *p_in >= 1.0 ) out = 8388607;
247         else if ( *p_in < -1.0 ) out = -8388608;
248         else out = *p_in * 8388608.0;
249
250 #ifdef WORDS_BIGENDIAN
251     *((int16_t *)p_out) = out >> 8;
252     p_out[2] = out & 0xFF;
253 #else
254     *((int16_t *)(p_out+1)) = out >> 8;
255     p_out[0] = out & 0xFF;
256 #endif
257
258         p_in++; p_out += 3;
259     }
260
261     p_block->i_buffer = p_block->i_buffer * 3 / 4;
262     return p_block;
263 }
264
265 static block_t *Float32toS16( filter_t *p_filter, block_t *p_block )
266 {
267     VLC_UNUSED(p_filter);
268     int i;
269     float *p_in = (float *)p_block->p_buffer;
270     int16_t *p_out = (int16_t *)p_in;
271
272     for( i = p_block->i_buffer / 4; i--; )
273     {
274 #if 0
275         /* Slow version. */
276         if ( *p_in >= 1.0 ) *p_out = 32767;
277         else if ( *p_in < -1.0 ) *p_out = -32768;
278         else *p_out = *p_in * 32768.0;
279 #else
280         /* This is walken's trick based on IEEE float format. */
281         union { float f; int32_t i; } u;
282         u.f = *p_in + 384.0;
283         if ( u.i > 0x43c07fff ) *p_out = 32767;
284         else if ( u.i < 0x43bf8000 ) *p_out = -32768;
285         else *p_out = u.i - 0x43c00000;
286 #endif
287         p_in++; p_out++;
288     }
289
290     p_block->i_buffer /= 2;
291     return p_block;
292 }
293
294 static block_t *Float32toU16( filter_t *p_filter, block_t *p_block )
295 {
296     VLC_UNUSED(p_filter);
297     int i;
298     float *p_in = (float *)p_block->p_buffer;
299     uint16_t *p_out = (uint16_t *)p_in;
300
301     for( i = p_block->i_buffer / 4; i--; )
302     {
303         if ( *p_in >= 1.0 ) *p_out = 65535;
304         else if ( *p_in < -1.0 ) *p_out = 0;
305         else *p_out = (uint16_t)(32768 + *p_in * 32768);
306         p_in++; p_out++;
307     }
308
309     p_block->i_buffer /= 2;
310     return p_block;
311 }
312
313 static block_t *S24toFloat32( filter_t *p_filter, block_t *p_block )
314 {
315     block_t *p_block_out;
316     uint8_t *p_in;
317     float *p_out;
318     int i;
319
320     p_block_out =
321         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer * 4 / 3 );
322     if( !p_block_out )
323     {
324         msg_Warn( p_filter, "can't get output buffer" );
325         return NULL;
326     }
327
328     p_in = p_block->p_buffer;
329     p_out = (float *)p_block_out->p_buffer;
330
331     for( i = p_block->i_buffer / 3; i--; )
332     {
333         /* FIXME: unaligned reads */
334 #ifdef WORDS_BIGENDIAN
335         *p_out = ((float)( (((int32_t)*(int16_t *)(p_in)) << 8) + p_in[2]))
336 #else
337         *p_out = ((float)( (((int32_t)*(int16_t *)(p_in+1)) << 8) + p_in[0]))
338 #endif
339             / 8388608.0;
340
341         p_in += 3; p_out++;
342     }
343
344     p_block_out->i_samples = p_block->i_samples;
345     p_block_out->i_dts = p_block->i_dts;
346     p_block_out->i_pts = p_block->i_pts;
347     p_block_out->i_length = p_block->i_length;
348     p_block_out->i_rate = p_block->i_rate;
349
350     block_Release( p_block );
351     return p_block_out;
352 }
353
354 static block_t *S24toS16( filter_t *p_filter, block_t *p_block )
355 {
356     VLC_UNUSED(p_filter);
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     block_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     block_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     block_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     VLC_UNUSED(p_filter);
499     int i;
500     int16_t *p_in = (int16_t *)p_block->p_buffer;
501     int8_t *p_out = (int8_t *)p_in;
502
503     for( i = p_block->i_buffer / 2; i--; )
504         *p_out++ = (*p_in++) >> 8;
505
506     p_block->i_buffer /= 2;
507     return p_block;
508 }
509 static block_t *S16toU8( filter_t *p_filter, block_t *p_block )
510 {
511     VLC_UNUSED(p_filter);
512     int i;
513     int16_t *p_in = (int16_t *)p_block->p_buffer;
514     uint8_t *p_out = (uint8_t *)p_in;
515
516     for( i = p_block->i_buffer / 2; i--; )
517         *p_out++ = ((*p_in++) + 32768) >> 8;
518
519     p_block->i_buffer /= 2;
520     return p_block;
521 }
522 static block_t *S16toU16( filter_t *p_filter, block_t *p_block )
523 {
524     VLC_UNUSED(p_filter);
525     int i;
526     int16_t *p_in = (int16_t *)p_block->p_buffer;
527     uint16_t *p_out = (uint16_t *)p_in;
528
529     for( i = p_block->i_buffer / 2; i--; )
530         *p_out++ = (*p_in++) + 32768;
531
532     return p_block;
533 }
534
535 static block_t *U16toS8( filter_t *p_filter, block_t *p_block )
536 {
537     VLC_UNUSED(p_filter);
538     int i;
539     uint16_t *p_in = (uint16_t *)p_block->p_buffer;
540     int8_t *p_out = (int8_t *)p_in;
541
542     for( i = p_block->i_buffer / 2; i--; )
543         *p_out++ = ((int)(*p_in++) - 32768) >> 8;
544
545     p_block->i_buffer /= 2;
546     return p_block;
547 }
548 static block_t *U16toU8( filter_t *p_filter, block_t *p_block )
549 {
550     VLC_UNUSED(p_filter);
551     int i;
552     uint16_t *p_in = (uint16_t *)p_block->p_buffer;
553     uint8_t *p_out = (uint8_t *)p_in;
554
555     for( i = p_block->i_buffer / 2; i--; )
556         *p_out++ = (*p_in++) >> 8;
557
558     p_block->i_buffer /= 2;
559     return p_block;
560 }
561 static block_t *U16toS16( filter_t *p_filter, block_t *p_block )
562 {
563     VLC_UNUSED(p_filter);
564     int i;
565     uint16_t *p_in = (uint16_t *)p_block->p_buffer;
566     int16_t *p_out = (int16_t *)p_in;
567
568     for( i = p_block->i_buffer / 2; i--; )
569         *p_out++ = (int)(*p_in++) - 32768;
570
571     return p_block;
572 }
573
574 static block_t *S8toU8( filter_t *p_filter, block_t *p_block )
575 {
576     VLC_UNUSED(p_filter);
577     int i;
578     int8_t *p_in = (int8_t *)p_block->p_buffer;
579     uint8_t *p_out = (uint8_t *)p_in;
580
581     for( i = p_block->i_buffer; i--; )
582         *p_out++ = ((*p_in++) + 128);
583
584     return p_block;
585 }
586 static block_t *U8toS8( filter_t *p_filter, block_t *p_block )
587 {
588     VLC_UNUSED(p_filter);
589     int i;
590     uint8_t *p_in = (uint8_t *)p_block->p_buffer;
591     int8_t *p_out = (int8_t *)p_in;
592
593     for( i = p_block->i_buffer; i--; )
594         *p_out++ = ((*p_in++) - 128);
595
596     return p_block;
597 }
598
599 /* */
600 static block_t *S8toU16( filter_t *p_filter, block_t *p_block )
601 {
602     block_t *p_block_out;
603     int8_t *p_in;
604     uint16_t *p_out;
605     int i;
606
607     p_block_out =
608         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
609     if( !p_block_out )
610     {
611         msg_Warn( p_filter, "can't get output buffer" );
612         return NULL;
613     }
614
615     p_in = (int8_t *)p_block->p_buffer;
616     p_out = (uint16_t *)p_block_out->p_buffer;
617
618     for( i = p_block->i_buffer; i--; )
619         *p_out++ = ((*p_in++) + 128) << 8;
620
621     p_block_out->i_samples = p_block->i_samples;
622     p_block_out->i_dts = p_block->i_dts;
623     p_block_out->i_pts = p_block->i_pts;
624     p_block_out->i_length = p_block->i_length;
625     p_block_out->i_rate = p_block->i_rate;
626
627     block_Release( p_block );
628     return p_block_out;
629 }
630
631 static block_t *U8toS16( filter_t *p_filter, block_t *p_block )
632 {
633     block_t *p_block_out;
634     uint8_t *p_in;
635     int16_t *p_out;
636     int i;
637
638     p_block_out =
639         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
640     if( !p_block_out )
641     {
642         msg_Warn( p_filter, "can't get output buffer" );
643         return NULL;
644     }
645
646     p_in = (uint8_t *)p_block->p_buffer;
647     p_out = (int16_t *)p_block_out->p_buffer;
648
649     for( i = p_block->i_buffer; i--; )
650         *p_out++ = ((*p_in++) - 128) << 8;
651
652     p_block_out->i_samples = p_block->i_samples;
653     p_block_out->i_dts = p_block->i_dts;
654     p_block_out->i_pts = p_block->i_pts;
655     p_block_out->i_length = p_block->i_length;
656     p_block_out->i_rate = p_block->i_rate;
657
658     block_Release( p_block );
659     return p_block_out;
660 }
661
662
663 static block_t *S8toS16( filter_t *p_filter, block_t *p_block )
664 {
665     block_t *p_block_out;
666     int8_t *p_in;
667     int16_t *p_out;
668     int i;
669
670     p_block_out =
671         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
672     if( !p_block_out )
673     {
674         msg_Warn( p_filter, "can't get output buffer" );
675         return NULL;
676     }
677
678     p_in = (int8_t *)p_block->p_buffer;
679     p_out = (int16_t *)p_block_out->p_buffer;
680
681     for( i = p_block->i_buffer; i--; )
682         *p_out++ = (*p_in++) << 8;
683
684     p_block_out->i_samples = p_block->i_samples;
685     p_block_out->i_dts = p_block->i_dts;
686     p_block_out->i_pts = p_block->i_pts;
687     p_block_out->i_length = p_block->i_length;
688     p_block_out->i_rate = p_block->i_rate;
689
690     block_Release( p_block );
691     return p_block_out;
692 }
693
694 static block_t *U8toU16( filter_t *p_filter, block_t *p_block )
695 {
696     block_t *p_block_out;
697     uint8_t *p_in;
698     uint16_t *p_out;
699     int i;
700
701     p_block_out =
702         p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
703     if( !p_block_out )
704     {
705         msg_Warn( p_filter, "can't get output buffer" );
706         return NULL;
707     }
708
709     p_in = (uint8_t *)p_block->p_buffer;
710     p_out = (uint16_t *)p_block_out->p_buffer;
711
712     for( i = p_block->i_buffer; i--; )
713         *p_out++ = (*p_in++) << 8;
714
715     p_block_out->i_samples = p_block->i_samples;
716     p_block_out->i_dts = p_block->i_dts;
717     p_block_out->i_pts = p_block->i_pts;
718     p_block_out->i_length = p_block->i_length;
719     p_block_out->i_rate = p_block->i_rate;
720
721     block_Release( p_block );
722     return p_block_out;
723 }
724
725 /*****************************************************************************
726  * Swap a buffer of words
727  *****************************************************************************/
728 static block_t *Swap16( filter_t *p_filter, block_t *p_block )
729 {
730     VLC_UNUSED(p_filter);
731     size_t i;
732     uint8_t *p_in = (uint8_t *)p_block->p_buffer;
733     uint8_t tmp;
734
735     for( i = 0; i < p_block->i_buffer / 2; i++ )
736     {
737         tmp = p_in[0];
738         p_in[0] = p_in[1];
739         p_in[1] = tmp;
740         p_in += 2;
741     }
742
743     return p_block;
744 }
745
746 static block_t *Swap24( filter_t *p_filter, block_t *p_block )
747 {
748     VLC_UNUSED(p_filter);
749     size_t i;
750     uint8_t *p_in = (uint8_t *)p_block->p_buffer;
751     uint8_t tmp;
752
753     for( i = 0; i < p_block->i_buffer / 3; i++ )
754     {
755         tmp = p_in[0];
756         p_in[0] = p_in[2];
757         p_in[2] = tmp;
758         p_in += 3;
759     }
760
761     return p_block;
762 }
763
764 #define CONVERT_NN( func, f_in, f_out, b_pre_invert, b_post_invert, swapa, swapb ) \
765 static block_t *func( filter_t *p_filter, block_t *p_block ) \
766 {                                                   \
767     if( b_pre_invert )                              \
768         swapa( p_filter, p_block );                  \
769                                                     \
770     p_block = f_in##to##f_out( p_filter, p_block ); \
771                                                     \
772     if( b_post_invert )                             \
773         swapb( p_filter, p_block );                  \
774                                                     \
775     return p_block;                                 \
776 }
777
778 CONVERT_NN( Float32toS24Invert, Float32, S24, 0, 1, Swap24, Swap24 )
779 CONVERT_NN( Float32toS16Invert, Float32, S16, 0, 1, Swap16, Swap16 )
780 CONVERT_NN( Float32toU16Invert, Float32, U16, 0, 1, Swap16, Swap16 )
781
782 CONVERT_NN( S24InverttoFloat32, S24, Float32, 1, 0, Swap24, Swap24 )
783 CONVERT_NN( S24InverttoS16,     S24, S16,     1, 0, Swap24, Swap16 )
784 CONVERT_NN( S24InverttoS16Invert, S24, S16,   1, 1, Swap24, Swap16 )
785 CONVERT_NN( S24toS16Invert,     S24, S16,     0, 1, Swap24, Swap16 )
786
787 CONVERT_NN( S16InverttoFloat32, S16, Float32, 1, 0, Swap16, Swap16 )
788 CONVERT_NN( S16InverttoS24,     S16, S24,     1, 0, Swap16, Swap24 )
789 CONVERT_NN( S16toS24Invert,     S16, S24,     0, 1, Swap16, Swap24 )
790 CONVERT_NN( S16InverttoS24Invert, S16, S24,   1, 1, Swap16, Swap24 )
791 CONVERT_NN( S16InverttoS8,      S16, S8,      1, 0, Swap16, Swap16 )
792 CONVERT_NN( S16InverttoU8,      S16, U8,      1, 0, Swap16, Swap16 )
793 CONVERT_NN( S16InverttoU16,     S16, U16,     1, 0, Swap16, Swap16 )
794
795 CONVERT_NN( U16InverttoFloat32, U16, Float32, 1, 0, Swap16, Swap16 )
796 CONVERT_NN( U16InverttoS8,      U16, S8,      1, 0, Swap16, Swap16 )
797 CONVERT_NN( U16InverttoU8,      U16, U8,      1, 0, Swap16, Swap16 )
798 CONVERT_NN( U16InverttoS16,     U16, S16,     1, 0, Swap16, Swap16 )
799
800 #undef CONVERT_NN
801
802 #define CONVERT_INDIRECT( func, f_in, f_mid, f_out )                    \
803 static block_t *func( filter_t *p_filter, block_t *p_block )            \
804 {                                                                       \
805     return f_mid##to##f_out( p_filter,                                  \
806                              f_in##to##f_mid( p_filter, p_block ) );    \
807 }
808
809 CONVERT_INDIRECT( Float32toS8,   Float32, S16, U8 )
810 CONVERT_INDIRECT( Float32toU8,   Float32, U16, U8 )
811 CONVERT_INDIRECT( S8toFloat32,   S8,      S16, Float32 )
812 CONVERT_INDIRECT( U8toFloat32,   U8,      U16, Float32 )
813
814 #define S16toS16Invert Swap16
815 #define U16toU16Invert Swap16
816
817 CONVERT_INDIRECT( U8toS16Invert, U8,      S16, S16Invert )
818 CONVERT_INDIRECT( S8toU16Invert, S8,      U16, U16Invert )
819
820 CONVERT_INDIRECT( U8toU16Invert, U8,      U16, U16Invert )
821 CONVERT_INDIRECT( S8toS16Invert, S8,      S16, S16Invert )
822
823 #undef CONVERT_INDIRECT