850ea002c9b7ed24d745a800f1b0d3a548977d26
[vlc.git] / modules / codec / flac.c
1 /*****************************************************************************
2  * flac.c: flac decoder/encoder module making use of libflac
3  *****************************************************************************
4  * Copyright (C) 1999-2001 VLC authors and VideoLAN
5  *
6  * Authors: Gildas Bazin <gbazin@videolan.org>
7  *          Sigmund Augdal Helberg <dnumgis@videolan.org>
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
28 /* workaround libflac overriding assert.h system header */
29 #define assert(x) do {} while(0)
30
31 #ifdef HAVE_CONFIG_H
32 # include "config.h"
33 #endif
34
35 #include <vlc_common.h>
36 #include <vlc_plugin.h>
37 #include <vlc_codec.h>
38 #include <vlc_codecs.h>
39 #include <vlc_aout.h>
40
41 #ifdef _WIN32
42 # define FLAC__NO_DLL
43 #endif
44
45 #include <FLAC/stream_decoder.h>
46 #include <FLAC/stream_encoder.h>
47
48 #include <vlc_block_helper.h>
49 #include <vlc_bits.h>
50
51 #if defined(FLAC_API_VERSION_CURRENT) && FLAC_API_VERSION_CURRENT >= 8
52 #   define USE_NEW_FLAC_API
53 #endif
54
55 /*****************************************************************************
56  * decoder_sys_t : FLAC decoder descriptor
57  *****************************************************************************/
58 typedef struct
59 {
60     /*
61      * Input/Output properties
62      */
63     block_t *p_block;
64     block_t *p_aout_buffer;
65     date_t   end_date;
66
67     /*
68      * FLAC properties
69      */
70     FLAC__StreamDecoder *p_flac;
71     FLAC__StreamMetadata_StreamInfo stream_info;
72
73     uint8_t rgi_channels_reorder[AOUT_CHAN_MAX];
74     bool b_stream_info;
75 } decoder_sys_t;
76
77 static const int pi_channels_maps[FLAC__MAX_CHANNELS + 1] =
78 {
79     0,
80     AOUT_CHAN_CENTER,
81     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
82     AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
83     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
84      | AOUT_CHAN_REARRIGHT,
85     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
86      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
87     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
88      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE,
89     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
90      | AOUT_CHAN_REARCENTER | AOUT_CHAN_MIDDLELEFT| AOUT_CHAN_MIDDLERIGHT
91      | AOUT_CHAN_LFE,
92     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER | AOUT_CHAN_REARLEFT
93      | AOUT_CHAN_REARRIGHT | AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT
94      | AOUT_CHAN_LFE
95 };
96
97 /* XXX it supposes our internal format is WG4 */
98 static const uint8_t ppi_reorder[1+FLAC__MAX_CHANNELS][FLAC__MAX_CHANNELS] =
99 {
100     { 0 },
101     { 0, },
102     { 0, 1 },
103     { 0, 1, 2 },
104     { 0, 1, 2, 3 },
105     { 0, 1, 3, 4, 2 },
106     { 0, 1, 4, 5, 2, 3 },
107     { 0, 1, 5, 6, 4, 2, 3 },
108     { 0, 1, 6, 7, 4, 5, 2, 3 },
109 };
110
111 /* Flac uses same order as waveformatex */
112 #define MAPPED_WFX_CHANNELS 9
113 static const uint32_t wfx_remapping[MAPPED_WFX_CHANNELS][2] =
114 {
115     { WAVE_SPEAKER_FRONT_LEFT,              AOUT_CHAN_LEFT },
116     { WAVE_SPEAKER_FRONT_RIGHT,             AOUT_CHAN_RIGHT },
117     { WAVE_SPEAKER_FRONT_CENTER,            AOUT_CHAN_CENTER },
118     { WAVE_SPEAKER_LOW_FREQUENCY,           AOUT_CHAN_LFE },
119     { WAVE_SPEAKER_BACK_LEFT,               AOUT_CHAN_REARLEFT },
120     { WAVE_SPEAKER_BACK_RIGHT,              AOUT_CHAN_REARRIGHT },
121     { WAVE_SPEAKER_BACK_CENTER,             AOUT_CHAN_REARCENTER },
122     { WAVE_SPEAKER_SIDE_LEFT,               AOUT_CHAN_MIDDLELEFT },
123     { WAVE_SPEAKER_SIDE_RIGHT,              AOUT_CHAN_MIDDLERIGHT },
124 };
125
126 static const uint32_t wfx_chans_order[MAPPED_WFX_CHANNELS + 1] =
127 {
128     AOUT_CHAN_LEFT,
129     AOUT_CHAN_RIGHT,
130     AOUT_CHAN_CENTER,
131     AOUT_CHAN_LFE,
132     AOUT_CHAN_REARLEFT,
133     AOUT_CHAN_REARRIGHT,
134     AOUT_CHAN_REARCENTER,
135     AOUT_CHAN_MIDDLELEFT,
136     AOUT_CHAN_MIDDLERIGHT,
137     0
138 };
139
140 /*****************************************************************************
141  * Local prototypes
142  *****************************************************************************/
143 static int  OpenDecoder   ( vlc_object_t * );
144 static void CloseDecoder  ( vlc_object_t * );
145
146 #ifdef ENABLE_SOUT
147 static int OpenEncoder   ( vlc_object_t * );
148 static void CloseEncoder ( vlc_object_t * );
149 #endif
150
151 static int DecodeBlock( decoder_t *, block_t * );
152 static void Flush( decoder_t * );
153
154 /*****************************************************************************
155  * Module descriptor
156  *****************************************************************************/
157 vlc_module_begin ()
158
159     set_category( CAT_INPUT )
160     set_subcategory( SUBCAT_INPUT_ACODEC )
161     add_shortcut( "flac" )
162
163     set_description( N_("Flac audio decoder") )
164     set_capability( "audio decoder", 100 )
165     set_callbacks( OpenDecoder, CloseDecoder )
166
167 #ifdef ENABLE_SOUT
168     add_submodule ()
169     add_shortcut( "flac" )
170     set_description( N_("Flac audio encoder") )
171     set_capability( "encoder", 100 )
172     set_callbacks( OpenEncoder, CloseEncoder )
173 #endif
174
175 vlc_module_end ()
176
177 /*****************************************************************************
178  * Interleave: helper function to interleave channels
179  *****************************************************************************/
180 static void Interleave( int32_t *p_out, const int32_t * const *pp_in,
181                         const uint8_t *restrict pi_index, unsigned i_nb_channels,
182                         unsigned i_samples, unsigned bits )
183 {
184     unsigned shift = 32 - bits;
185
186     for( unsigned j = 0; j < i_samples; j++ )
187         for( unsigned i = 0; i < i_nb_channels; i++ )
188         {
189             union { int32_t i; uint32_t u; } spl;
190
191             spl.u = ((uint32_t)pp_in[pi_index[i]][j]) << shift;
192             p_out[j * i_nb_channels + i] = spl.i;
193         }
194 }
195
196 /*****************************************************************************
197  * DecoderSetOutputFormat: helper function to convert and check frame format
198  *****************************************************************************/
199 static int DecoderSetOutputFormat( unsigned i_channels, unsigned i_rate,
200                                    unsigned i_streaminfo_rate,
201                                    unsigned i_bitspersample,
202                                    audio_format_t *fmt,
203                                    uint8_t *pi_channels_reorder )
204 {
205     if( i_channels == 0 || i_channels > FLAC__MAX_CHANNELS ||
206         i_bitspersample == 0 || (i_rate == 0 && i_streaminfo_rate == 0) )
207         return VLC_EGENERIC;
208
209     fmt->i_channels = i_channels;
210     fmt->i_rate = (i_rate > 0 ) ? i_rate : i_streaminfo_rate;
211     fmt->i_physical_channels = pi_channels_maps[i_channels];
212     memcpy( pi_channels_reorder, ppi_reorder[i_channels], i_channels );
213     fmt->i_bitspersample = i_bitspersample;
214
215     return VLC_SUCCESS;
216 }
217
218 /*****************************************************************************
219  * DecoderWriteCallback: called by libflac to output decoded samples
220  *****************************************************************************/
221 static FLAC__StreamDecoderWriteStatus
222 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
223                       const FLAC__Frame *frame,
224                       const FLAC__int32 *const buffer[], void *client_data )
225 {
226     VLC_UNUSED(decoder);
227     decoder_t *p_dec = (decoder_t *)client_data;
228     decoder_sys_t *p_sys = p_dec->p_sys;
229
230     if( DecoderSetOutputFormat( frame->header.channels,
231                                 frame->header.sample_rate,
232                                 p_sys->b_stream_info ? p_sys->stream_info.sample_rate : 0,
233                                 frame->header.bits_per_sample,
234                                 &p_dec->fmt_out.audio,
235                                 p_sys->rgi_channels_reorder ) )
236         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
237
238     if( p_sys->end_date.i_divider_num != p_dec->fmt_out.audio.i_rate )
239     {
240         if( p_sys->end_date.i_divider_num > 0 )
241             date_Change( &p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1 );
242         else
243             date_Init( &p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1 );
244     }
245
246     if( decoder_UpdateAudioFormat( p_dec ) )
247         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
248
249     if( date_Get( &p_sys->end_date ) == VLC_TICK_INVALID )
250         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
251
252     p_sys->p_aout_buffer =
253         decoder_NewAudioBuffer( p_dec, frame->header.blocksize );
254
255     if( p_sys->p_aout_buffer == NULL )
256         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
257
258     Interleave( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
259                  p_sys->rgi_channels_reorder,
260                  frame->header.channels, frame->header.blocksize,
261                  frame->header.bits_per_sample );
262
263     /* Date management (already done by packetizer) */
264     p_sys->p_aout_buffer->i_pts = date_Get( &p_sys->end_date );
265     p_sys->p_aout_buffer->i_length =
266         date_Increment( &p_sys->end_date, frame->header.blocksize ) -
267         p_sys->p_aout_buffer->i_pts;
268
269     return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
270 }
271
272 /*****************************************************************************
273  * DecoderReadCallback: called by libflac when it needs more data
274  *****************************************************************************/
275 static FLAC__StreamDecoderReadStatus
276 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
277                      size_t *bytes, void *client_data )
278 {
279     VLC_UNUSED(decoder);
280     decoder_t *p_dec = (decoder_t *)client_data;
281     decoder_sys_t *p_sys = p_dec->p_sys;
282
283     if( p_sys->p_block && p_sys->p_block->i_buffer )
284     {
285         *bytes = __MIN(*bytes, p_sys->p_block->i_buffer);
286         memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
287         p_sys->p_block->i_buffer -= *bytes;
288         p_sys->p_block->p_buffer += *bytes;
289     }
290     else
291     {
292         *bytes = 0;
293         return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
294     }
295
296     return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
297 }
298
299 /*****************************************************************************
300  * DecoderMetadataCallback: called by libflac to when it encounters metadata
301  *****************************************************************************/
302 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
303                                      const FLAC__StreamMetadata *metadata,
304                                      void *client_data )
305 {
306     VLC_UNUSED(decoder);
307     decoder_t *p_dec = (decoder_t *)client_data;
308     decoder_sys_t *p_sys = p_dec->p_sys;
309
310     switch(metadata->type)
311     {
312         case FLAC__METADATA_TYPE_STREAMINFO:
313             /* Setup the format */
314             DecoderSetOutputFormat( metadata->data.stream_info.channels,
315                                     metadata->data.stream_info.sample_rate,
316                                     metadata->data.stream_info.sample_rate,
317                                     metadata->data.stream_info.bits_per_sample,
318                                     &p_dec->fmt_out.audio, p_sys->rgi_channels_reorder );
319
320             msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
321                      p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
322                      p_dec->fmt_out.audio.i_bitspersample );
323
324             p_sys->b_stream_info = true;
325             p_sys->stream_info = metadata->data.stream_info;
326
327             date_Init( &p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1 );
328             break;
329
330         case FLAC__METADATA_TYPE_VORBIS_COMMENT:
331             for( FLAC__uint32 i=0; i<metadata->data.vorbis_comment.num_comments; i++ )
332             {
333                 const FLAC__StreamMetadata_VorbisComment_Entry *comment =
334                         &metadata->data.vorbis_comment.comments[i];
335                 /* Check for custom WAVEFORMATEX channel ordering */
336                 if( comment->length > 34 &&
337                     !strncmp( "WAVEFORMATEXTENSIBLE_CHANNEL_MASK=", (char *) comment->entry, 34 ) )
338                 {
339                     char *endptr = (char *) &comment->entry[34] + comment->length;
340                     const uint32_t i_wfxmask = strtoul( (char *) &comment->entry[34], &endptr, 16 );
341                     const unsigned i_wfxchannels = vlc_popcount( i_wfxmask );
342                     if( i_wfxchannels > 0 && i_wfxchannels <= AOUT_CHAN_MAX )
343                     {
344                         /* Create the vlc bitmap from wfx channels */
345                         uint32_t i_vlcmask = 0;
346                         for( uint32_t i_chan = 1; i_chan && i_chan <= i_wfxmask; i_chan <<= 1 )
347                         {
348                             if( (i_chan & i_wfxmask) == 0 )
349                                 continue;
350                             for( size_t j=0; j<MAPPED_WFX_CHANNELS; j++ )
351                             {
352                                 if( wfx_remapping[j][0] == i_chan )
353                                     i_vlcmask |= wfx_remapping[j][1];
354                             }
355                         }
356                         /* Check if we have the 1 to 1 mapping */
357                         if( (unsigned) vlc_popcount(i_vlcmask) != i_wfxchannels )
358                         {
359                             msg_Warn( p_dec, "Unsupported channel mask %x", i_wfxmask );
360                             return;
361                         }
362
363                         /* Compute the remapping */
364                         uint8_t neworder[AOUT_CHAN_MAX] = {0};
365                         aout_CheckChannelReorder( wfx_chans_order, NULL,
366                                                   i_vlcmask, neworder );
367
368                         /* /!\ Invert our source/dest reordering,
369                          * as Interleave() here works source indexes */
370                         for( unsigned j=0; j<i_wfxchannels; j++ )
371                             p_sys->rgi_channels_reorder[neworder[j]] = j;
372
373                         p_dec->fmt_out.audio.i_physical_channels = i_vlcmask;
374                         p_dec->fmt_out.audio.i_channels = i_wfxchannels;
375                     }
376
377                     break;
378                 }
379             }
380
381         default:
382             break;
383     }
384 }
385
386 /*****************************************************************************
387  * DecoderErrorCallback: called when the libflac decoder encounters an error
388  *****************************************************************************/
389 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
390                                   FLAC__StreamDecoderErrorStatus status,
391                                   void *client_data )
392 {
393     VLC_UNUSED(decoder);
394     decoder_t *p_dec = (decoder_t *)client_data;
395     decoder_sys_t *p_sys = p_dec->p_sys;
396
397     switch( status )
398     {
399     case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
400         msg_Warn( p_dec, "an error in the stream caused the decoder to "
401                  "lose synchronization." );
402         break;
403     case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
404         msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
405         break;
406     case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
407         msg_Err( p_dec, "frame's data did not match the CRC in the "
408                  "footer." );
409         break;
410     case FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM:
411         msg_Err( p_dec, "The decoder encountered reserved fields in use in "
412                  "the stream." );
413         break;
414     default:
415         msg_Err( p_dec, "got decoder error: %d", status );
416     }
417
418     FLAC__stream_decoder_flush( p_sys->p_flac );
419     return;
420 }
421 /*****************************************************************************
422  * OpenDecoder: probe the decoder and return score
423  *****************************************************************************/
424 static int OpenDecoder( vlc_object_t *p_this )
425 {
426     decoder_t *p_dec = (decoder_t*)p_this;
427     decoder_sys_t *p_sys;
428
429     if( p_dec->fmt_in.i_codec != VLC_CODEC_FLAC )
430     {
431         return VLC_EGENERIC;
432     }
433
434     /* Allocate the memory needed to store the decoder's structure */
435     if( ( p_dec->p_sys = p_sys = malloc(sizeof(*p_sys)) ) == NULL )
436         return VLC_ENOMEM;
437
438     /* Misc init */
439     p_sys->b_stream_info = false;
440     memset(p_sys->rgi_channels_reorder, 0, AOUT_CHAN_MAX);
441     p_sys->p_block = NULL;
442
443     /* Take care of flac init */
444     if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
445     {
446         msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
447         free( p_sys );
448         return VLC_EGENERIC;
449     }
450
451     /* Enable STREAMINFO + COMMENTS */
452     FLAC__stream_decoder_set_metadata_respond( p_sys->p_flac,
453                                                FLAC__METADATA_TYPE_VORBIS_COMMENT );
454
455 #ifdef USE_NEW_FLAC_API
456     if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
457                                           DecoderReadCallback,
458                                           NULL,
459                                           NULL,
460                                           NULL,
461                                           NULL,
462                                           DecoderWriteCallback,
463                                           DecoderMetadataCallback,
464                                           DecoderErrorCallback,
465                                           p_dec )
466         != FLAC__STREAM_DECODER_INIT_STATUS_OK )
467     {
468         msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
469         FLAC__stream_decoder_delete( p_sys->p_flac );
470         free( p_sys );
471         return VLC_EGENERIC;
472     }
473 #else
474     FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
475                                             DecoderReadCallback );
476     FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
477                                              DecoderWriteCallback );
478     FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
479                                                 DecoderMetadataCallback );
480     FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
481                                              DecoderErrorCallback );
482     FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
483
484     FLAC__stream_decoder_init( p_sys->p_flac );
485 #endif
486
487     /* Set output properties */
488     p_dec->fmt_out.i_codec = VLC_CODEC_S32N;
489
490     /* Set callbacks */
491     p_dec->pf_decode = DecodeBlock;
492     p_dec->pf_flush  = Flush;
493
494     return VLC_SUCCESS;
495 }
496
497 /*****************************************************************************
498  * CloseDecoder: flac decoder destruction
499  *****************************************************************************/
500 static void CloseDecoder( vlc_object_t *p_this )
501 {
502     decoder_t *p_dec = (decoder_t *)p_this;
503     decoder_sys_t *p_sys = p_dec->p_sys;
504
505     FLAC__stream_decoder_finish( p_sys->p_flac );
506     FLAC__stream_decoder_delete( p_sys->p_flac );
507
508     if( p_sys->p_block )
509         block_Release( p_sys->p_block );
510     free( p_sys );
511 }
512
513 /*****************************************************************************
514  * ProcessHeader: process Flac header.
515  *****************************************************************************/
516 static void ProcessHeader( decoder_t *p_dec )
517 {
518     decoder_sys_t *p_sys = p_dec->p_sys;
519
520     if( !p_dec->fmt_in.i_extra )
521         return;
522
523     /* Decode STREAMINFO */
524     msg_Dbg( p_dec, "decode STREAMINFO" );
525     int i_extra = p_dec->fmt_in.i_extra;
526
527     static const char header[4] = { 'f', 'L', 'a', 'C' };
528
529     if( memcmp( p_dec->fmt_in.p_extra, header, 4 ) )
530         i_extra += 8;
531
532     p_sys->p_block = block_Alloc( i_extra );
533     if( p_sys->p_block == NULL )
534         return;
535
536     uint8_t *p_data = p_sys->p_block->p_buffer;
537     if( i_extra != p_dec->fmt_in.i_extra )
538     {
539         memcpy( p_data, header, 4);
540         p_data[4] = 0x80 | 0; /* STREAMINFO faked as last block */
541         p_data[5] = 0;
542         p_data[6] = 0;
543         p_data[7] = 34; /* block size */
544         p_data += 8;
545     }
546     memcpy( p_data, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
547
548     FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
549     msg_Dbg( p_dec, "STREAMINFO decoded" );
550
551     block_Release( p_sys->p_block );
552     p_sys->p_block = NULL;
553 }
554
555 /*****************************************************************************
556  * decoder_state_error: print meaningful error messages
557  *****************************************************************************/
558 static void decoder_state_error( decoder_t *p_dec,
559                                  FLAC__StreamDecoderState state )
560 {
561     switch ( state )
562     {
563     case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
564         msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
565         break;
566     case FLAC__STREAM_DECODER_READ_METADATA:
567         msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
568                  "reading metadata." );
569         break;
570     case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
571         msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
572                  "searching for the frame sync code." );
573         break;
574     case FLAC__STREAM_DECODER_READ_FRAME:
575         msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
576                  "reading a frame." );
577         break;
578     case FLAC__STREAM_DECODER_END_OF_STREAM:
579         msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
580         break;
581 #ifdef USE_NEW_FLAC_API
582     case FLAC__STREAM_DECODER_OGG_ERROR:
583         msg_Err( p_dec, "error occurred in the Ogg layer." );
584         break;
585     case FLAC__STREAM_DECODER_SEEK_ERROR:
586         msg_Err( p_dec, "error occurred while seeking." );
587         break;
588 #endif
589     case FLAC__STREAM_DECODER_ABORTED:
590         msg_Warn( p_dec, "the decoder was aborted by the read callback." );
591         break;
592 #ifndef USE_NEW_FLAC_API
593     case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
594         msg_Warn( p_dec, "the decoder encountered reserved fields in use "
595                  "in the stream." );
596         break;
597 #endif
598     case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
599         msg_Err( p_dec, "error when allocating memory." );
600         break;
601 #ifndef USE_NEW_FLAC_API
602     case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
603         msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
604                  "decoder was already initialized, usually because "
605                  "FLAC__stream_decoder_finish() was not called." );
606         break;
607     case FLAC__STREAM_DECODER_INVALID_CALLBACK:
608         msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
609                  "all callbacks being set." );
610         break;
611 #endif
612     case FLAC__STREAM_DECODER_UNINITIALIZED:
613         msg_Err( p_dec, "decoder in uninitialized state." );
614         break;
615     default:
616         msg_Warn(p_dec, "unknown error" );
617     }
618 }
619
620 /*****************************************************************************
621  * Flush:
622  *****************************************************************************/
623 static void Flush( decoder_t *p_dec )
624 {
625     decoder_sys_t *p_sys = p_dec->p_sys;
626
627     if( p_sys->b_stream_info )
628         FLAC__stream_decoder_flush( p_sys->p_flac );
629     date_Set( &p_sys->end_date, VLC_TICK_INVALID );
630 }
631
632 /****************************************************************************
633  * DecodeBlock: the whole thing
634  ****************************************************************************/
635 static int DecodeBlock( decoder_t *p_dec, block_t *p_block )
636 {
637     decoder_sys_t *p_sys = p_dec->p_sys;
638
639     if( p_block == NULL ) /* No Drain */
640         return VLCDEC_SUCCESS;
641     if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY | BLOCK_FLAG_CORRUPTED) )
642     {
643         Flush( p_dec );
644         if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
645         {
646             block_Release( p_block );
647             return VLCDEC_SUCCESS;
648         }
649     }
650
651     if( !p_sys->b_stream_info )
652     {
653         ProcessHeader( p_dec );
654         if( !p_sys->b_stream_info )
655         {
656             block_Release( p_block );
657             return VLCDEC_ECRITICAL;
658         }
659     }
660
661     p_sys->p_block = p_block;
662
663     if( p_sys->p_block->i_pts != VLC_TICK_INVALID &&
664         p_sys->p_block->i_pts != date_Get( &p_sys->end_date ) )
665         date_Set( &p_sys->end_date, p_sys->p_block->i_pts );
666
667     p_sys->p_aout_buffer = 0;
668
669     if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
670     {
671         decoder_state_error( p_dec,
672                              FLAC__stream_decoder_get_state( p_sys->p_flac ) );
673         FLAC__stream_decoder_flush( p_sys->p_flac );
674     }
675
676     /* If the decoder is in the "aborted" state,
677      * FLAC__stream_decoder_process_single() won't return an error. */
678     switch ( FLAC__stream_decoder_get_state(p_sys->p_flac) )
679     {
680         case FLAC__STREAM_DECODER_ABORTED:
681             FLAC__stream_decoder_flush( p_sys->p_flac );
682             break;
683         case FLAC__STREAM_DECODER_END_OF_STREAM:
684             FLAC__stream_decoder_reset( p_sys->p_flac );
685             break;
686         default:
687             break;
688     }
689
690     block_Release( p_sys->p_block );
691     p_sys->p_block = NULL;
692
693     if( p_sys->p_aout_buffer != NULL )
694         decoder_QueueAudio( p_dec, p_sys->p_aout_buffer );
695     return VLCDEC_SUCCESS;
696 }
697
698 #ifdef ENABLE_SOUT
699
700 /*****************************************************************************
701  * encoder_sys_t : flac encoder descriptor
702  *****************************************************************************/
703 typedef struct
704 {
705     /*
706      * Input properties
707      */
708     int i_headers;
709
710     int i_samples_delay;
711
712     FLAC__int32 *p_buffer;
713     unsigned int i_buffer;
714
715     block_t *p_chain;
716
717     /*
718      * FLAC properties
719      */
720     FLAC__StreamEncoder *p_flac;
721     FLAC__StreamMetadata_StreamInfo stream_info;
722
723     /*
724      * Common properties
725      */
726     vlc_tick_t i_pts;
727 } encoder_sys_t;
728
729 #define STREAMINFO_SIZE 34
730
731 static block_t *Encode( encoder_t *, block_t * );
732
733 /*****************************************************************************
734  * EncoderWriteCallback: called by libflac to output encoded samples
735  *****************************************************************************/
736 static FLAC__StreamEncoderWriteStatus
737 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
738                       const FLAC__byte buffer[],
739                       size_t bytes, unsigned samples,
740                       unsigned current_frame, void *client_data )
741 {
742     VLC_UNUSED(encoder); VLC_UNUSED(current_frame);
743     encoder_t *p_enc = (encoder_t *)client_data;
744     encoder_sys_t *p_sys = p_enc->p_sys;
745     block_t *p_block;
746
747     if( samples == 0 )
748     {
749         if( p_sys->i_headers == 1 )
750         {
751             msg_Dbg( p_enc, "Writing STREAMINFO: %zu", bytes );
752
753             /* Backup the STREAMINFO metadata block */
754             p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 8;
755             p_enc->fmt_out.p_extra = xmalloc( STREAMINFO_SIZE + 8);
756             memcpy(p_enc->fmt_out.p_extra, "fLaC", 4);
757             memcpy((uint8_t*)p_enc->fmt_out.p_extra + 4, buffer, STREAMINFO_SIZE );
758             /* Fake this as the last metadata block */
759             ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
760         }
761         p_sys->i_headers++;
762         return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
763     }
764
765     p_block = block_Alloc( bytes );
766     memcpy( p_block->p_buffer, buffer, bytes );
767
768     p_block->i_dts = p_block->i_pts = p_sys->i_pts;
769
770     p_sys->i_samples_delay -= samples;
771
772     p_block->i_length = vlc_tick_from_samples(samples, p_enc->fmt_in.audio.i_rate);
773
774     /* Update pts */
775     p_sys->i_pts += p_block->i_length;
776
777     block_ChainAppend( &p_sys->p_chain, p_block );
778
779     return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
780 }
781 /*****************************************************************************
782  * EncoderMetadataCallback: called by libflac to output metadata
783  *****************************************************************************/
784 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
785                                      const FLAC__StreamMetadata *metadata,
786                                      void *client_data )
787 {
788     VLC_UNUSED(encoder);
789     encoder_t *p_enc = (encoder_t *)client_data;
790
791     msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
792     return;
793 }
794
795 /*****************************************************************************
796  * OpenEncoder: probe the encoder and return score
797  *****************************************************************************/
798 static int OpenEncoder( vlc_object_t *p_this )
799 {
800     encoder_t *p_enc = (encoder_t *)p_this;
801     encoder_sys_t *p_sys;
802
803     if( p_enc->fmt_out.i_codec != VLC_CODEC_FLAC &&
804         !p_enc->obj.force )
805     {
806         return VLC_EGENERIC;
807     }
808
809     /* Allocate the memory needed to store the decoder's structure */
810     if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
811         return VLC_ENOMEM;
812     p_enc->p_sys = p_sys;
813     p_enc->pf_encode_audio = Encode;
814     p_enc->fmt_out.i_codec = VLC_CODEC_FLAC;
815
816     p_sys->i_headers = 0;
817     p_sys->p_buffer = 0;
818     p_sys->i_buffer = 0;
819     p_sys->i_samples_delay = 0;
820
821     /* Create flac encoder */
822     if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
823     {
824         msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
825         free( p_sys );
826         return VLC_EGENERIC;
827     }
828
829     FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
830     FLAC__stream_encoder_set_channels( p_sys->p_flac,
831                                        p_enc->fmt_in.audio.i_channels );
832     FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
833                                           p_enc->fmt_in.audio.i_rate );
834     FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
835     p_enc->fmt_in.i_codec = VLC_CODEC_S16N;
836
837     /* Get and store the STREAMINFO metadata block as a p_extra */
838     p_sys->p_chain = 0;
839
840 #ifdef USE_NEW_FLAC_API
841     if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
842                                           EncoderWriteCallback,
843                                           NULL,
844                                           NULL,
845                                           EncoderMetadataCallback,
846                                           p_enc )
847         != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
848     {
849         msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
850         FLAC__stream_encoder_delete( p_sys->p_flac );
851         free( p_sys );
852         return VLC_EGENERIC;
853     }
854 #else
855     FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
856         EncoderWriteCallback );
857     FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
858         EncoderMetadataCallback );
859     FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
860
861     FLAC__stream_encoder_init( p_sys->p_flac );
862 #endif
863
864     return VLC_SUCCESS;
865 }
866
867 /****************************************************************************
868  * Encode: the whole thing
869  ****************************************************************************
870  * This function spits out ogg packets.
871  ****************************************************************************/
872 static block_t *Encode( encoder_t *p_enc, block_t *p_aout_buf )
873 {
874     encoder_sys_t *p_sys = p_enc->p_sys;
875     block_t *p_chain;
876
877     /* FIXME: p_aout_buf is NULL when it's time to flush*/
878     if( unlikely( !p_aout_buf ) ) return NULL;
879
880     p_sys->i_pts = p_aout_buf->i_pts -
881                 vlc_tick_from_samples( p_sys->i_samples_delay,
882                             p_enc->fmt_in.audio.i_rate );
883
884     p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
885
886     /* Convert samples to FLAC__int32 */
887     if( p_sys->i_buffer < p_aout_buf->i_buffer * sizeof(FLAC__int32) )
888     {
889         p_sys->p_buffer =
890             xrealloc( p_sys->p_buffer, p_aout_buf->i_buffer * sizeof(FLAC__int32) );
891         p_sys->i_buffer = p_aout_buf->i_buffer * 2;
892     }
893
894     for( unsigned i = 0 ; i < p_aout_buf->i_buffer / 2 ; i++ )
895     {
896         p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
897     }
898
899     FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
900                                               p_aout_buf->i_nb_samples );
901
902     p_chain = p_sys->p_chain;
903     p_sys->p_chain = 0;
904
905     return p_chain;
906 }
907
908 /*****************************************************************************
909  * CloseEncoder: encoder destruction
910  *****************************************************************************/
911 static void CloseEncoder( vlc_object_t *p_this )
912 {
913     encoder_t *p_enc = (encoder_t *)p_this;
914     encoder_sys_t *p_sys = p_enc->p_sys;
915
916     FLAC__stream_encoder_delete( p_sys->p_flac );
917
918     free( p_sys->p_buffer );
919     free( p_sys );
920 }
921 #endif