araw: filter out non-finite floating point samples
[vlc.git] / modules / codec / araw.c
1 /*****************************************************************************
2  * araw.c: Pseudo audio decoder; for raw pcm data
3  *****************************************************************************
4  * Copyright (C) 2001, 2003 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <math.h>
32 #include <assert.h>
33
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36 #include <vlc_codec.h>
37 #include <vlc_aout.h>
38
39 /*****************************************************************************
40  * Module descriptor
41  *****************************************************************************/
42 static int  DecoderOpen ( vlc_object_t * );
43 static void DecoderClose( vlc_object_t * );
44
45 #ifdef ENABLE_SOUT
46 static int  EncoderOpen ( vlc_object_t * );
47 #endif
48
49 vlc_module_begin ()
50     /* audio decoder module */
51     set_description( N_("Raw/Log Audio decoder") )
52     set_capability( "decoder", 100 )
53     set_category( CAT_INPUT )
54     set_subcategory( SUBCAT_INPUT_ACODEC )
55     set_callbacks( DecoderOpen, DecoderClose )
56
57 #ifdef ENABLE_SOUT
58     /* audio encoder submodule */
59     add_submodule ()
60     set_description( N_("Raw audio encoder") )
61     set_capability( "encoder", 150 )
62     set_callbacks( EncoderOpen, NULL )
63 #endif
64 vlc_module_end ()
65
66 /*****************************************************************************
67  * Local prototypes
68  *****************************************************************************/
69 static block_t *DecodeBlock( decoder_t *, block_t ** );
70
71 struct decoder_sys_t
72 {
73     void (*decode) (void *, const uint8_t *, unsigned);
74     size_t framebits;
75     date_t end_date;
76 };
77
78 static const uint16_t pi_channels_maps[] =
79 {
80     0,
81     AOUT_CHAN_CENTER, AOUT_CHANS_2_0, AOUT_CHANS_3_0,
82     AOUT_CHANS_4_0,   AOUT_CHANS_5_0, AOUT_CHANS_5_1,
83     AOUT_CHANS_7_0,   AOUT_CHANS_7_1, AOUT_CHANS_8_1,
84 };
85
86 static void S8Decode( void *, const uint8_t *, unsigned );
87 static void U16BDecode( void *, const uint8_t *, unsigned );
88 static void U16LDecode( void *, const uint8_t *, unsigned );
89 static void S16IDecode( void *, const uint8_t *, unsigned );
90 static void S20BDecode( void *, const uint8_t *, unsigned );
91 static void U24BDecode( void *, const uint8_t *, unsigned );
92 static void U24LDecode( void *, const uint8_t *, unsigned );
93 static void S24BDecode( void *, const uint8_t *, unsigned );
94 static void S24LDecode( void *, const uint8_t *, unsigned );
95 static void S24B32Decode( void *, const uint8_t *, unsigned );
96 static void S24L32Decode( void *, const uint8_t *, unsigned );
97 static void U32BDecode( void *, const uint8_t *, unsigned );
98 static void U32LDecode( void *, const uint8_t *, unsigned );
99 static void S32IDecode( void *, const uint8_t *, unsigned );
100 static void F32NDecode( void *, const uint8_t *, unsigned );
101 static void F32IDecode( void *, const uint8_t *, unsigned );
102 static void F64NDecode( void *, const uint8_t *, unsigned );
103 static void F64IDecode( void *, const uint8_t *, unsigned );
104 static void DAT12Decode( void *, const uint8_t *, unsigned );
105
106 /*****************************************************************************
107  * DecoderOpen: probe the decoder and return score
108  *****************************************************************************/
109 static int DecoderOpen( vlc_object_t *p_this )
110 {
111     decoder_t *p_dec = (decoder_t*)p_this;
112     vlc_fourcc_t format = p_dec->fmt_in.i_codec;
113
114     switch( p_dec->fmt_in.i_codec )
115     {
116     case VLC_FOURCC('a','r','a','w'):
117     case VLC_FOURCC('a','f','l','t'):
118     /* _signed_ big endian samples (mov) */
119     case VLC_FOURCC('t','w','o','s'):
120     /* _signed_ little endian samples (mov) */
121     case VLC_FOURCC('s','o','w','t'):
122         format =
123             vlc_fourcc_GetCodecAudio( p_dec->fmt_in.i_codec,
124                                       p_dec->fmt_in.audio.i_bitspersample );
125         if( !format )
126         {
127             msg_Err( p_dec, "bad parameters(bits/sample)" );
128             return VLC_EGENERIC;
129         }
130         break;
131     }
132
133     void (*decode) (void *, const uint8_t *, unsigned) = NULL;
134     uint_fast8_t bits;
135
136     switch( format )
137     {
138 #ifdef WORDS_BIGENDIAN
139     case VLC_CODEC_F64L:
140 #else
141     case VLC_CODEC_F64B:
142 #endif
143         format = VLC_CODEC_FL64;
144         decode = F64IDecode;
145         bits = 64;
146         break;
147     case VLC_CODEC_FL64:
148         decode = F64NDecode;
149         bits = 64;
150         break;
151 #ifdef WORDS_BIGENDIAN
152     case VLC_CODEC_F32L:
153 #else
154     case VLC_CODEC_F32B:
155 #endif
156         format = VLC_CODEC_FL32;
157         decode = F32IDecode;
158         bits = 32;
159         break;
160     case VLC_CODEC_FL32:
161         decode = F32NDecode;
162         bits = 32;
163         break;
164     case VLC_CODEC_U32B:
165         format = VLC_CODEC_S32N;
166         decode = U32BDecode;
167         bits = 32;
168         break;
169     case VLC_CODEC_U32L:
170         format = VLC_CODEC_S32N;
171         decode = U32LDecode;
172         bits = 32;
173         break;
174     case VLC_CODEC_S32I:
175         format = VLC_CODEC_S32N;
176         decode = S32IDecode;
177     case VLC_CODEC_S32N:
178         bits = 32;
179         break;
180     case VLC_CODEC_S24B32:
181         format = VLC_CODEC_S32N;
182         decode = S24B32Decode;
183         bits = 32;
184         break;
185     case VLC_CODEC_S24L32:
186         format = VLC_CODEC_S32N;
187         decode = S24L32Decode;
188         bits = 32;
189         break;
190     case VLC_CODEC_U24B:
191         format = VLC_CODEC_S32N;
192         decode = U24BDecode;
193         bits = 24;
194         break;
195     case VLC_CODEC_U24L:
196         format = VLC_CODEC_S32N;
197         decode = U24LDecode;
198         bits = 24;
199         break;
200     case VLC_CODEC_S24B:
201         format = VLC_CODEC_S32N;
202         decode = S24BDecode;
203         bits = 24;
204         break;
205     case VLC_CODEC_S24L:
206         format = VLC_CODEC_S32N;
207         decode = S24LDecode;
208         bits = 24;
209         break;
210     case VLC_CODEC_S20B:
211         format = VLC_CODEC_S32N;
212         decode = S20BDecode;
213         bits = 20;
214         break;
215     case VLC_CODEC_U16B:
216         format = VLC_CODEC_S16N;
217         decode = U16BDecode;
218         bits = 16;
219         break;
220     case VLC_CODEC_U16L:
221         format = VLC_CODEC_S16N;
222         decode = U16LDecode;
223         bits = 16;
224         break;
225     case VLC_CODEC_S16I:
226         format = VLC_CODEC_S16N;
227         decode = S16IDecode;
228     case VLC_CODEC_S16N:
229         bits = 16;
230         break;
231     case VLC_CODEC_DAT12:
232         format = VLC_CODEC_S16N;
233         decode = DAT12Decode;
234         bits = 12;
235         break;
236     case VLC_CODEC_S8:
237         decode = S8Decode;
238         format = VLC_CODEC_U8;
239     case VLC_CODEC_U8:
240         bits = 8;
241         break;
242     default:
243         return VLC_EGENERIC;
244     }
245
246     if( p_dec->fmt_in.audio.i_channels <= 0 ||
247         p_dec->fmt_in.audio.i_channels > AOUT_CHAN_MAX )
248     {
249         msg_Err( p_dec, "bad channels count (1-9): %i",
250                  p_dec->fmt_in.audio.i_channels );
251         return VLC_EGENERIC;
252     }
253
254     if( p_dec->fmt_in.audio.i_rate <= 0 )
255     {
256         msg_Err( p_dec, "bad samplerate: %d Hz", p_dec->fmt_in.audio.i_rate );
257         return VLC_EGENERIC;
258     }
259
260     msg_Dbg( p_dec, "samplerate:%dHz channels:%d bits/sample:%d",
261              p_dec->fmt_in.audio.i_rate, p_dec->fmt_in.audio.i_channels,
262              p_dec->fmt_in.audio.i_bitspersample );
263
264     /* Allocate the memory needed to store the decoder's structure */
265     decoder_sys_t *p_sys = malloc(sizeof(*p_sys));
266     if( unlikely(p_sys == NULL) )
267         return VLC_ENOMEM;
268
269     /* Set output properties */
270     p_dec->fmt_out.i_cat = AUDIO_ES;
271     p_dec->fmt_out.i_codec = format;
272     p_dec->fmt_out.audio.i_format = format;
273     p_dec->fmt_out.audio.i_rate = p_dec->fmt_in.audio.i_rate;
274     if( p_dec->fmt_in.audio.i_physical_channels )
275         p_dec->fmt_out.audio.i_physical_channels =
276                                        p_dec->fmt_in.audio.i_physical_channels;
277     else
278         p_dec->fmt_out.audio.i_physical_channels =
279                               pi_channels_maps[p_dec->fmt_in.audio.i_channels];
280     if( p_dec->fmt_in.audio.i_original_channels )
281         p_dec->fmt_out.audio.i_original_channels =
282                                        p_dec->fmt_in.audio.i_original_channels;
283     else
284         p_dec->fmt_out.audio.i_original_channels =
285                                       p_dec->fmt_out.audio.i_physical_channels;
286     aout_FormatPrepare( &p_dec->fmt_out.audio );
287
288     p_sys->decode = decode;
289     p_sys->framebits = bits * p_dec->fmt_out.audio.i_channels;
290     assert( p_sys->framebits );
291
292     date_Init( &p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1 );
293     date_Set( &p_sys->end_date, 0 );
294
295     p_dec->pf_decode_audio = DecodeBlock;
296     p_dec->p_sys = p_sys;
297
298     return VLC_SUCCESS;
299 }
300
301 /****************************************************************************
302  * DecodeBlock: the whole thing
303  ****************************************************************************
304  * This function must be fed with whole samples (see nBlockAlign).
305  ****************************************************************************/
306 static block_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
307 {
308     decoder_sys_t *p_sys = p_dec->p_sys;
309     if( pp_block == NULL )
310         return NULL;
311
312     block_t *p_block = *pp_block;
313     if( p_block == NULL )
314         return NULL;
315     *pp_block = NULL;
316
317     if( p_block->i_pts > VLC_TS_INVALID &&
318         p_block->i_pts != date_Get( &p_sys->end_date ) )
319     {
320         date_Set( &p_sys->end_date, p_block->i_pts );
321     }
322     else if( !date_Get( &p_sys->end_date ) )
323         /* We've just started the stream, wait for the first PTS. */
324         goto skip;
325
326     unsigned samples = (8 * p_block->i_buffer) / p_sys->framebits;
327     if( samples == 0 )
328         goto skip;
329
330     if( p_sys->decode != NULL )
331     {
332         block_t *p_out = decoder_NewAudioBuffer( p_dec, samples );
333         if( p_out == NULL )
334             goto skip;
335
336         p_sys->decode( p_out->p_buffer, p_block->p_buffer,
337                        samples * p_dec->fmt_in.audio.i_channels );
338         block_Release( p_block );
339         p_block = p_out;
340     }
341     else
342     {
343         decoder_UpdateAudioFormat( p_dec );
344         p_block->i_nb_samples = samples;
345         p_block->i_buffer = samples * (p_sys->framebits / 8);
346     }
347
348     p_block->i_pts = date_Get( &p_sys->end_date );
349     p_block->i_length = date_Increment( &p_sys->end_date, samples )
350                       - p_block->i_pts;
351     return p_block;
352 skip:
353     block_Release( p_block );
354     return NULL;
355 }
356
357 static void S8Decode( void *outp, const uint8_t *in, unsigned samples )
358 {
359     uint8_t *out = outp;
360
361     for( size_t i = 0; i < samples; i++ )
362         out[i] = in[i] ^ 0x80;
363 }
364
365 static void U16BDecode( void *outp, const uint8_t *in, unsigned samples )
366 {
367     uint16_t *out = outp;
368
369     for( size_t i = 0; i < samples; i++ )
370     {
371         *(out++) = GetWBE( in ) - 0x8000;
372         in += 2;
373     }
374 }
375
376 static void U16LDecode( void *outp, const uint8_t *in, unsigned samples )
377 {
378     uint16_t *out = outp;
379
380     for( size_t i = 0; i < samples; i++ )
381     {
382         *(out++) = GetWLE( in ) - 0x8000;
383         in += 2;
384     }
385 }
386
387 static void S16IDecode( void *out, const uint8_t *in, unsigned samples )
388 {
389     swab( in, out, samples * 2 );
390 }
391
392 static void S20BDecode( void *outp, const uint8_t *in, unsigned samples )
393 {
394     int32_t *out = outp;
395
396     while( samples >= 2 )
397     {
398         uint32_t dw = U32_AT(in);
399         in += 4;
400         *(out++) = dw & ~0xFFF;
401         *(out++) = (dw << 20) | (*in << 12);
402         in++;
403         samples -= 2;
404     }
405
406     /* No U32_AT() for the last odd sample: avoid off-by-one overflow! */
407     if( samples )
408         *(out++) = (U16_AT(in) << 16) | ((in[2] & 0xF0) << 8);
409 }
410
411 static void U24BDecode( void *outp, const uint8_t *in, unsigned samples )
412 {
413     uint32_t *out = outp;
414
415     for( size_t i = 0; i < samples; i++ )
416     {
417         uint32_t s = ((in[0] << 24) | (in[1] << 16) | (in[2] << 8)) - 0x80000000;
418         *(out++) = s;
419         in += 3;
420     }
421 }
422
423 static void U24LDecode( void *outp, const uint8_t *in, unsigned samples )
424 {
425     uint32_t *out = outp;
426
427     for( size_t i = 0; i < samples; i++ )
428     {
429         uint32_t s = ((in[2] << 24) | (in[1] << 16) | (in[0] << 8)) - 0x80000000;
430         *(out++) = s;
431         in += 3;
432     }
433 }
434
435 static void S24BDecode( void *outp, const uint8_t *in, unsigned samples )
436 {
437     uint32_t *out = outp;
438
439     for( size_t i = 0; i < samples; i++ )
440     {
441         uint32_t s = ((in[0] << 24) | (in[1] << 16) | (in[2] << 8));
442         *(out++) = s;
443         in += 3;
444     }
445 }
446
447 static void S24LDecode( void *outp, const uint8_t *in, unsigned samples )
448 {
449     uint32_t *out = outp;
450
451     for( size_t i = 0; i < samples; i++ )
452     {
453         uint32_t s = ((in[2] << 24) | (in[1] << 16) | (in[0] << 8));
454         *(out++) = s;
455         in += 3;
456     }
457 }
458
459 static void S24B32Decode( void *outp, const uint8_t *in, unsigned samples )
460 {
461     uint32_t *out = outp;
462
463     for( size_t i = 0; i < samples; i++ )
464     {
465         *(out++) = GetDWBE( in ) << 8;
466         in += 4;
467     }
468 }
469
470 static void S24L32Decode( void *outp, const uint8_t *in, unsigned samples )
471 {
472     uint32_t *out = outp;
473
474     for( size_t i = 0; i < samples; i++ )
475     {
476         *(out++) = GetDWLE( in ) << 8;
477         in += 4;
478     }
479 }
480
481 static void U32BDecode( void *outp, const uint8_t *in, unsigned samples )
482 {
483     uint32_t *out = outp;
484
485     for( size_t i = 0; i < samples; i++ )
486     {
487         *(out++) = GetDWBE( in ) - 0x80000000;
488         in += 4;
489     }
490 }
491
492 static void U32LDecode( void *outp, const uint8_t *in, unsigned samples )
493 {
494     uint32_t *out = outp;
495
496     for( size_t i = 0; i < samples; i++ )
497     {
498         *(out++) = GetDWLE( in ) - 0x80000000;
499         in += 4;
500     }
501 }
502
503 static void S32IDecode( void *outp, const uint8_t *in, unsigned samples )
504 {
505     int32_t *out = outp;
506
507     for( size_t i = 0; i < samples; i++ )
508     {
509 #ifdef WORDS_BIGENDIAN
510         *(out++) = GetDWLE( in );
511 #else
512         *(out++) = GetDWBE( in );
513 #endif
514         in += 4;
515     }
516 }
517
518 static void F32NDecode( void *outp, const uint8_t *in, unsigned samples )
519 {
520     float *out = outp;
521
522     for( size_t i = 0; i < samples; i++ )
523     {
524         memcpy( out, in, sizeof(float) );
525         if( unlikely(!isfinite(*out)) )
526             *out = 0.f;
527         out++;
528         in += sizeof(float);
529     }
530 }
531
532 static void F32IDecode( void *outp, const uint8_t *in, unsigned samples )
533 {
534     float *out = outp;
535
536     for( size_t i = 0; i < samples; i++ )
537     {
538         union { float f; uint32_t u; } s;
539
540 #ifdef WORDS_BIGENDIAN
541         s.u = GetDWLE( in );
542 #else
543         s.u = GetDWBE( in );
544 #endif
545         if( unlikely(!isfinite(s.f)) )
546             s.f = 0.f;
547         *(out++) = s.f;
548         in += 4;
549     }
550 }
551
552 static void F64NDecode( void *outp, const uint8_t *in, unsigned samples )
553 {
554     double *out = outp;
555
556     for( size_t i = 0; i < samples; i++ )
557     {
558         memcpy( out, in, sizeof(double) );
559         if( unlikely(!isfinite( *out )) )
560             *out = 0.;
561         out++;
562         in += sizeof(double);
563     }
564 }
565
566 static void F64IDecode( void *outp, const uint8_t *in, unsigned samples )
567 {
568     double *out = outp;
569
570     for( size_t i = 0; i < samples; i++ )
571     {
572         union { double d; uint64_t u; } s;
573
574 #ifdef WORDS_BIGENDIAN
575         s.u = GetQWLE( in );
576 #else
577         s.u = GetQWBE( in );
578 #endif
579         if( unlikely(!isfinite( s.d )) )
580             s.d = 0.;
581         *(out++) = s.d;
582         in += 8;
583     }
584 }
585
586 static int16_t dat12tos16( uint16_t y )
587 {
588     static const uint16_t diff[16] = {
589        0x0000, 0x0000, 0x0100, 0x0200, 0x0300, 0x0400, 0x0500, 0x0600,
590        0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00, 0x1000, 0x1000 };
591     static const uint8_t shift[16] = {
592         0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1, 0, 0 };
593
594     int d = y >> 8;
595     return (y - diff[d]) << shift[d];
596 }
597
598 static void DAT12Decode( void *outp, const uint8_t *in, unsigned samples )
599 {
600     int32_t *out = outp;
601
602     while( samples >= 2 )
603     {
604         *(out++) = dat12tos16(U16_AT(in) >> 4);
605         *(out++) = dat12tos16(U16_AT(in + 1) & ~0xF000);
606         in += 3;
607         samples -= 2;
608     }
609
610     if( samples )
611         *(out++) = dat12tos16(U16_AT(in) >> 4);
612 }
613
614 /*****************************************************************************
615  * DecoderClose: decoder destruction
616  *****************************************************************************/
617 static void DecoderClose( vlc_object_t *p_this )
618 {
619     decoder_t *p_dec = (decoder_t *)p_this;
620
621     free( p_dec->p_sys );
622 }
623
624 #ifdef ENABLE_SOUT
625 /* NOTE: Output buffers are always aligned since they are allocated by the araw plugin.
626  * Contrary to the decoder, the encoder can also assume that input buffers are aligned,
627  * since decoded audio blocks must always be aligned. */
628
629 static void U16IEncode( void *outp, const uint8_t *inp, unsigned samples )
630 {
631     const uint16_t *in = (const uint16_t *)inp;
632     uint16_t *out = outp;
633
634     for( size_t i = 0; i < samples; i++ )
635         *(out++) =  bswap16( *(in++) + 0x8000 );
636 }
637
638 static void U16NEncode( void *outp, const uint8_t *inp, unsigned samples )
639 {
640     const uint16_t *in = (const uint16_t *)inp;
641     uint16_t *out = outp;
642
643     for( size_t i = 0; i < samples; i++ )
644         *(out++) =  *(in++) + 0x8000;
645 }
646
647 static void U24BEncode( void *outp, const uint8_t *inp, unsigned samples )
648 {
649     const uint32_t *in = (const uint32_t *)inp;
650     uint8_t *out = outp;
651
652     for( size_t i = 0; i < samples; i++ )
653     {
654         uint32_t s = *(in++);
655         *(out++) = (s >> 24) + 0x80;
656         *(out++) = (s >> 16);
657         *(out++) = (s >>  8);
658     }
659 }
660
661 static void U24LEncode( void *outp, const uint8_t *inp, unsigned samples )
662 {
663     const uint32_t *in = (const uint32_t *)inp;
664     uint8_t *out = outp;
665
666     for( size_t i = 0; i < samples; i++ )
667     {
668         uint32_t s = *(in++);
669         *(out++) = (s >>  8);
670         *(out++) = (s >> 16);
671         *(out++) = (s >> 24) + 0x80;
672     }
673 }
674
675 static void S24BEncode( void *outp, const uint8_t *inp, unsigned samples )
676 {
677     const uint32_t *in = (const uint32_t *)inp;
678     uint8_t *out = outp;
679
680     for( size_t i = 0; i < samples; i++ )
681     {
682         uint32_t s = *(in++);
683         *(out++) = (s >> 24);
684         *(out++) = (s >> 16);
685         *(out++) = (s >>  8);
686     }
687 }
688
689 static void S24LEncode( void *outp, const uint8_t *inp, unsigned samples )
690 {
691     const uint32_t *in = (const uint32_t *)inp;
692     uint8_t *out = outp;
693
694     for( size_t i = 0; i < samples; i++ )
695     {
696         uint32_t s = *(in++);
697         *(out++) = (s >>  8);
698         *(out++) = (s >> 16);
699         *(out++) = (s >> 24);
700     }
701 }
702
703 static void U32IEncode( void *outp, const uint8_t *inp, unsigned samples )
704 {
705     const uint32_t *in = (const uint32_t *)inp;
706     uint32_t *out = outp;
707
708     for( size_t i = 0; i < samples; i++ )
709         *(out++) =  bswap32( *(in++) + 0x80000000 );
710 }
711
712 static void U32NEncode( void *outp, const uint8_t *inp, unsigned samples )
713 {
714     const uint32_t *in = (const uint32_t *)inp;
715     uint32_t *out = outp;
716
717     for( size_t i = 0; i < samples; i++ )
718         *(out++) =  *(in++) + 0x80000000;
719 }
720
721 static void S32IEncode( void *outp, const uint8_t *inp, unsigned samples )
722 {
723     const int32_t *in = (const int32_t *)inp;
724     int32_t *out = outp;
725
726     for( size_t i = 0; i < samples; i++ )
727         *(out++) = bswap32( *(in++) );
728 }
729
730 static void F32IEncode( void *outp, const uint8_t *inp, unsigned samples )
731 {
732     const float *in = (const float *)inp;
733     uint8_t *out = outp;
734
735     for( size_t i = 0; i < samples; i++ )
736     {
737         union { float f; uint32_t u; char b[4]; } s;
738
739         s.f = *(in++);
740         s.u = bswap32( s.u );
741         memcpy( out, s.b, 4 );
742         out += 4;
743     }
744 }
745
746 static void F64IEncode( void *outp, const uint8_t *inp, unsigned samples )
747 {
748     const double *in = (const double *)inp;
749     uint8_t *out = outp;
750
751     for( size_t i = 0; i < samples; i++ )
752     {
753         union { double d; uint64_t u; char b[8]; } s;
754
755         s.d = *(in++);
756         s.u = bswap64( s.u );
757         memcpy( out, s.b, 8 );
758         out += 8;
759     }
760 }
761
762 static block_t *Encode( encoder_t *enc, block_t *in )
763 {
764     if( in == NULL )
765         return NULL;
766
767     block_t *out = block_Alloc( in->i_nb_samples
768                                 * enc->fmt_out.audio.i_bytes_per_frame );
769     if( unlikely(out == NULL) )
770         return NULL;
771
772     out->i_flags      = in->i_flags;
773     out->i_nb_samples = in->i_nb_samples;
774     out->i_dts        = in->i_dts;
775     out->i_pts        = in->i_pts;
776     out->i_length     = in->i_length;
777
778     void (*encode)(void *, const uint8_t *, unsigned) = (void *)enc->p_sys;
779     if( encode != NULL )
780         encode( out->p_buffer, in->p_buffer, in->i_nb_samples
781                                              * enc->fmt_out.audio.i_channels );
782     else {
783         assert( out->i_buffer >= in->i_buffer );
784         memcpy( out->p_buffer, in->p_buffer, in->i_buffer );
785     }
786     return out;
787 }
788
789 /**
790  * Probes the PCM audio encoder.
791  */
792 static int EncoderOpen( vlc_object_t *p_this )
793 {
794     encoder_t *p_enc = (encoder_t *)p_this;
795     void (*encode)(void *, const uint8_t *, unsigned) = NULL;
796
797     switch( p_enc->fmt_out.i_codec )
798     {
799     case VLC_CODEC_S8:
800         encode = S8Decode;
801     case VLC_CODEC_U8:
802         p_enc->fmt_in.i_codec = VLC_CODEC_U8;
803         p_enc->fmt_out.audio.i_bitspersample = 8;
804         break;
805     case VLC_CODEC_U16I:
806         encode = U16IEncode;
807         p_enc->fmt_in.i_codec = VLC_CODEC_S16N;
808         p_enc->fmt_out.audio.i_bitspersample = 16;
809         break;
810     case VLC_CODEC_U16N:
811         encode = U16NEncode;
812         p_enc->fmt_in.i_codec = VLC_CODEC_S16N;
813         p_enc->fmt_out.audio.i_bitspersample = 16;
814         break;
815     case VLC_CODEC_S16I:
816         encode = S16IDecode;
817     case VLC_CODEC_S16N:
818         p_enc->fmt_in.i_codec = VLC_CODEC_S16N;
819         p_enc->fmt_out.audio.i_bitspersample = 16;
820         break;
821     case VLC_CODEC_U24B:
822         encode = U24BEncode;
823         p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
824         p_enc->fmt_out.audio.i_bitspersample = 24;
825         break;
826     case VLC_CODEC_U24L:
827         encode = U24LEncode;
828         p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
829         p_enc->fmt_out.audio.i_bitspersample = 24;
830         break;
831     case VLC_CODEC_S24B:
832         encode = S24BEncode;
833         p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
834         p_enc->fmt_out.audio.i_bitspersample = 24;
835         break;
836     case VLC_CODEC_S24L:
837         encode = S24LEncode;
838         p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
839         p_enc->fmt_out.audio.i_bitspersample = 24;
840         break;
841     case VLC_CODEC_U32I:
842         encode = U32IEncode;
843         p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
844         p_enc->fmt_out.audio.i_bitspersample = 32;
845         break;
846     case VLC_CODEC_U32N:
847         encode = U32NEncode;
848         p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
849         p_enc->fmt_out.audio.i_bitspersample = 32;
850         break;
851     case VLC_CODEC_S32I:
852         encode = S32IEncode;
853     case VLC_CODEC_S32N:
854         p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
855         p_enc->fmt_out.audio.i_bitspersample = 32;
856         break;
857 #ifdef WORDS_BIGENDIAN
858     case VLC_CODEC_F32L:
859 #else
860     case VLC_CODEC_F32B:
861 #endif
862         encode = F32IEncode;
863     case VLC_CODEC_FL32:
864         p_enc->fmt_in.i_codec = VLC_CODEC_FL32;
865         p_enc->fmt_out.audio.i_bitspersample = 32;
866         break;
867 #ifdef WORDS_BIGENDIAN
868     case VLC_CODEC_F64L:
869 #else
870     case VLC_CODEC_F64B:
871 #endif
872         encode = F64IEncode;
873     case VLC_CODEC_FL64:
874         p_enc->fmt_in.i_codec = VLC_CODEC_FL64;
875         p_enc->fmt_out.audio.i_bitspersample = 64;
876         break;
877     default:
878         return VLC_EGENERIC;
879     }
880
881     p_enc->p_sys = (void *)encode;
882     p_enc->pf_encode_audio = Encode;
883     p_enc->fmt_out.audio.i_bytes_per_frame =
884         (p_enc->fmt_out.audio.i_bitspersample / 8) *
885         p_enc->fmt_in.audio.i_channels;
886     p_enc->fmt_out.i_bitrate =
887         p_enc->fmt_in.audio.i_channels *
888         p_enc->fmt_in.audio.i_rate *
889         p_enc->fmt_out.audio.i_bitspersample;
890
891     msg_Dbg( p_enc, "samplerate:%dHz channels:%d bits/sample:%d",
892              p_enc->fmt_out.audio.i_rate, p_enc->fmt_out.audio.i_channels,
893              p_enc->fmt_out.audio.i_bitspersample );
894
895     return VLC_SUCCESS;
896 }
897 #endif /* ENABLE_SOUT */