3dda0073a18275fd5968eaec75ed0c4ec00679a0
[vlc.git] / modules / codec / flac.c
1 /*****************************************************************************
2  * flac.c: flac decoder/packetizer/encoder module making use of libflac
3  *****************************************************************************
4  * Copyright (C) 1999-2001 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@videolan.org>
8  *          Sigmund Augdal Helberg <dnumgis@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 #include <vlc/vlc.h>
30 #include <vlc_codec.h>
31 #include <vlc_aout.h>
32
33 #ifdef HAVE_FLAC_STREAM_DECODER_H
34 #   include <FLAC/stream_decoder.h>
35 #   include <FLAC/stream_encoder.h>
36 #   define USE_LIBFLAC
37 #endif
38
39 #include <vlc_block_helper.h>
40 #include <vlc_bits.h>
41
42 #define MAX_FLAC_HEADER_SIZE 16
43
44 #if defined(FLAC_API_VERSION_CURRENT) && FLAC_API_VERSION_CURRENT >= 8
45 #   define USE_NEW_FLAC_API
46 #endif
47
48 /*****************************************************************************
49  * decoder_sys_t : FLAC decoder descriptor
50  *****************************************************************************/
51 struct decoder_sys_t
52 {
53     /*
54      * Input properties
55      */
56     int i_state;
57
58     block_bytestream_t bytestream;
59
60     /*
61      * Input/Output properties
62      */
63     block_t *p_block;
64     aout_buffer_t *p_aout_buffer;
65
66     /*
67      * FLAC properties
68      */
69 #ifdef USE_LIBFLAC
70     FLAC__StreamDecoder *p_flac;
71     FLAC__StreamMetadata_StreamInfo stream_info;
72 #else
73     struct
74     {
75         unsigned min_blocksize, max_blocksize;
76         unsigned min_framesize, max_framesize;
77         unsigned sample_rate;
78         unsigned channels;
79         unsigned bits_per_sample;
80
81     } stream_info;
82 #endif
83     vlc_bool_t b_stream_info;
84
85     /*
86      * Common properties
87      */
88     audio_date_t end_date;
89     mtime_t i_pts;
90
91     int i_frame_size, i_frame_length, i_bits_per_sample;
92     unsigned int i_rate, i_channels, i_channels_conf;
93 };
94
95 enum {
96
97     STATE_NOSYNC,
98     STATE_SYNC,
99     STATE_HEADER,
100     STATE_NEXT_SYNC,
101     STATE_GET_DATA,
102     STATE_SEND_DATA
103 };
104
105 static int pi_channels_maps[7] =
106 {
107     0,
108     AOUT_CHAN_CENTER,
109     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
110     AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
111     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
112      | AOUT_CHAN_REARRIGHT,
113     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
114      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
115     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
116      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE
117 };
118
119 /*****************************************************************************
120  * Local prototypes
121  *****************************************************************************/
122 static int  OpenDecoder   ( vlc_object_t * );
123 static int  OpenPacketizer( vlc_object_t * );
124 static void CloseDecoder  ( vlc_object_t * );
125
126 #ifdef USE_LIBFLAC
127 static int OpenEncoder   ( vlc_object_t * );
128 static void CloseEncoder ( vlc_object_t * );
129 #endif
130
131 #ifdef USE_LIBFLAC
132 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
133 #endif
134 static block_t *PacketizeBlock( decoder_t *, block_t ** );
135
136 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *, unsigned int *,
137                      unsigned int *,int * );
138
139
140 #ifdef USE_LIBFLAC
141 static FLAC__StreamDecoderReadStatus
142 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
143                      FLAC__byte buffer[], unsigned *bytes, void *client_data );
144
145 static FLAC__StreamDecoderWriteStatus
146 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
147                       const FLAC__Frame *frame,
148                       const FLAC__int32 *const buffer[], void *client_data );
149
150 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
151                                      const FLAC__StreamMetadata *metadata,
152                                      void *client_data );
153 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
154                                   FLAC__StreamDecoderErrorStatus status,
155                                   void *client_data);
156
157 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
158                           int i_nb_channels, int i_samples );
159 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
160                           int i_nb_channels, int i_samples );
161
162 static void decoder_state_error( decoder_t *p_dec,
163                                  FLAC__StreamDecoderState state );
164 #endif
165
166 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
167 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
168
169 /*****************************************************************************
170  * Module descriptor
171  *****************************************************************************/
172 vlc_module_begin();
173
174     set_category( CAT_INPUT );
175     set_subcategory( SUBCAT_INPUT_ACODEC );
176
177 #ifdef USE_LIBFLAC
178     set_description( _("Flac audio decoder") );
179     set_capability( "decoder", 100 );
180     set_callbacks( OpenDecoder, CloseDecoder );
181
182     add_submodule();
183     set_description( _("Flac audio encoder") );
184     set_capability( "encoder", 100 );
185     set_callbacks( OpenEncoder, CloseEncoder );
186
187     add_submodule();
188 #endif
189     set_description( _("Flac audio packetizer") );
190     set_capability( "packetizer", 100 );
191     set_callbacks( OpenPacketizer, CloseDecoder );
192
193     add_shortcut( "flac" );
194 vlc_module_end();
195
196 /*****************************************************************************
197  * OpenDecoder: probe the decoder and return score
198  *****************************************************************************/
199 static int OpenDecoder( vlc_object_t *p_this )
200 {
201     decoder_t *p_dec = (decoder_t*)p_this;
202     decoder_sys_t *p_sys;
203
204     if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
205     {
206         return VLC_EGENERIC;
207     }
208
209     /* Allocate the memory needed to store the decoder's structure */
210     if( ( p_dec->p_sys = p_sys =
211           (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
212     {
213         msg_Err( p_dec, "out of memory" );
214         return VLC_EGENERIC;
215     }
216
217     /* Misc init */
218     aout_DateSet( &p_sys->end_date, 0 );
219     p_sys->i_state = STATE_NOSYNC;
220     p_sys->b_stream_info = VLC_FALSE;
221     p_sys->p_block=NULL;
222     p_sys->bytestream = block_BytestreamInit( p_dec );
223
224 #ifdef USE_LIBFLAC
225     /* Take care of flac init */
226     if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
227     {
228         msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
229         free( p_sys );
230         return VLC_EGENERIC;
231     }
232
233 #ifdef USE_NEW_FLAC_API
234     if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
235                                           DecoderReadCallback,
236                                           NULL,
237                                           NULL,
238                                           NULL,
239                                           NULL,
240                                           DecoderWriteCallback,
241                                           DecoderMetadataCallback,
242                                           DecoderErrorCallback,
243                                           p_dec )
244         != FLAC__STREAM_DECODER_INIT_STATUS_OK )
245     {
246         msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
247         FLAC__stream_decoder_delete( p_sys->p_flac );
248         free( p_sys );
249         return VLC_EGENERIC;
250     }
251 #else
252     FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
253                                             DecoderReadCallback );
254     FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
255                                              DecoderWriteCallback );
256     FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
257                                                 DecoderMetadataCallback );
258     FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
259                                              DecoderErrorCallback );
260     FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
261
262     FLAC__stream_decoder_init( p_sys->p_flac );
263 #endif
264 #endif
265
266     /* Set output properties */
267     p_dec->fmt_out.i_cat = AUDIO_ES;
268     p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
269
270     /* Set callbacks */
271 #ifdef USE_LIBFLAC
272     p_dec->pf_decode_audio = DecodeBlock;
273 #endif
274     p_dec->pf_packetize    = PacketizeBlock;
275
276     return VLC_SUCCESS;
277 }
278
279 static int OpenPacketizer( vlc_object_t *p_this )
280 {
281     decoder_t *p_dec = (decoder_t*)p_this;
282     int i_ret;
283
284     /* Hmmm, mem leak ?*/
285     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
286
287     i_ret = OpenDecoder( p_this );
288
289     /* Set output properties */
290     p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
291
292     if( i_ret != VLC_SUCCESS ) return i_ret;
293
294     return i_ret;
295 }
296
297 /*****************************************************************************
298  * CloseDecoder: flac decoder destruction
299  *****************************************************************************/
300 static void CloseDecoder( vlc_object_t *p_this )
301 {
302     decoder_t *p_dec = (decoder_t *)p_this;
303     decoder_sys_t *p_sys = p_dec->p_sys;
304
305 #ifdef USE_LIBFLAC
306     FLAC__stream_decoder_finish( p_sys->p_flac );
307     FLAC__stream_decoder_delete( p_sys->p_flac );
308 #endif
309
310     if( p_sys->p_block ) free( p_sys->p_block );
311     free( p_sys );
312 }
313
314 /*****************************************************************************
315  * ProcessHeader: process Flac header.
316  *****************************************************************************/
317 static void ProcessHeader( decoder_t *p_dec )
318 {
319     decoder_sys_t *p_sys = p_dec->p_sys;
320
321 #ifdef USE_LIBFLAC
322     if( !p_dec->fmt_in.i_extra ) return;
323
324     /* Decode STREAMINFO */
325     msg_Dbg( p_dec, "decode STREAMINFO" );
326     p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
327     memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
328             p_dec->fmt_in.i_extra );
329     FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
330     msg_Dbg( p_dec, "STREAMINFO decoded" );
331
332 #else
333     bs_t bs;
334
335     if( !p_dec->fmt_in.i_extra ) return;
336
337     bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
338
339     p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
340     p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
341
342     p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
343     p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
344
345     p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
346     p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
347     p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
348 #endif
349
350     if( !p_sys->b_stream_info ) return;
351
352     if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
353     {
354         p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
355         p_dec->fmt_out.p_extra =
356             realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
357         memcpy( p_dec->fmt_out.p_extra,
358                 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
359     }
360 }
361
362 /****************************************************************************
363  * PacketizeBlock: the whole thing
364  ****************************************************************************
365  * This function is called just after the thread is launched.
366  ****************************************************************************/
367 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
368 {
369     decoder_sys_t *p_sys = p_dec->p_sys;
370     uint8_t p_header[MAX_FLAC_HEADER_SIZE];
371     block_t *p_sout_block;
372
373     if( !pp_block || !*pp_block ) return NULL;
374
375     if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
376
377     if( p_sys->stream_info.channels > 6 )
378     {
379         msg_Err( p_dec, "This stream uses too many audio channels" );
380         return NULL;
381     }
382
383     if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
384     {
385         /* We've just started the stream, wait for the first PTS. */
386         block_Release( *pp_block );
387         return NULL;
388     }
389     else if( !aout_DateGet( &p_sys->end_date ) )
390     {
391         /* The first PTS is as good as anything else. */
392         aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
393     }
394
395     if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
396     {
397         p_sys->i_state = STATE_NOSYNC;
398     }
399
400     block_BytestreamPush( &p_sys->bytestream, *pp_block );
401
402     while( 1 )
403     {
404         switch( p_sys->i_state )
405         {
406         case STATE_NOSYNC:
407             while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
408                    == VLC_SUCCESS )
409             {
410                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
411                 {
412                     p_sys->i_state = STATE_SYNC;
413                     break;
414                 }
415                 block_SkipByte( &p_sys->bytestream );
416             }
417             if( p_sys->i_state != STATE_SYNC )
418             {
419                 block_BytestreamFlush( &p_sys->bytestream );
420
421                 /* Need more data */
422                 return NULL;
423             }
424
425         case STATE_SYNC:
426             /* New frame, set the Presentation Time Stamp */
427             p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
428             if( p_sys->i_pts != 0 &&
429                 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
430             {
431                 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
432             }
433             p_sys->i_state = STATE_HEADER;
434
435         case STATE_HEADER:
436             /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
437             if( block_PeekBytes( &p_sys->bytestream, p_header,
438                                  MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
439             {
440                 /* Need more data */
441                 return NULL;
442             }
443
444             /* Check if frame is valid and get frame info */
445             p_sys->i_frame_length = SyncInfo( p_dec, p_header,
446                                               &p_sys->i_channels,
447                                               &p_sys->i_channels_conf,
448                                               &p_sys->i_rate,
449                                               &p_sys->i_bits_per_sample );
450             if( !p_sys->i_frame_length )
451             {
452                 msg_Dbg( p_dec, "emulated sync word" );
453                 block_SkipByte( &p_sys->bytestream );
454                 p_sys->i_state = STATE_NOSYNC;
455                 break;
456             }
457             if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
458             {
459                 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
460                 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
461             }
462             p_sys->i_state = STATE_NEXT_SYNC;
463             p_sys->i_frame_size = 1;
464
465         case STATE_NEXT_SYNC:
466             /* TODO: If pp_block == NULL, flush the buffer without checking the
467              * next sync word */
468
469             /* Check if next expected frame contains the sync word */
470             while( block_PeekOffsetBytes( &p_sys->bytestream,
471                                           p_sys->i_frame_size, p_header,
472                                           MAX_FLAC_HEADER_SIZE )
473                    == VLC_SUCCESS )
474             {
475                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
476                 {
477                     /* Check if frame is valid and get frame info */
478                     int i_frame_length =
479                         SyncInfo( p_dec, p_header,
480                                   &p_sys->i_channels,
481                                   &p_sys->i_channels_conf,
482                                   &p_sys->i_rate,
483                                   &p_sys->i_bits_per_sample );
484
485                     if( i_frame_length )
486                     {
487                         p_sys->i_state = STATE_SEND_DATA;
488                         break;
489                     }
490                 }
491                 p_sys->i_frame_size++;
492             }
493
494             if( p_sys->i_state != STATE_SEND_DATA )
495             {
496                 /* Need more data */
497                 return NULL;
498             }
499
500         case STATE_SEND_DATA:
501             p_sout_block = block_New( p_dec, p_sys->i_frame_size );
502
503             /* Copy the whole frame into the buffer. When we reach this point
504              * we already know we have enough data available. */
505             block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
506                             p_sys->i_frame_size );
507
508             /* Make sure we don't reuse the same pts twice */
509             if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
510                 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
511
512             /* So p_block doesn't get re-added several times */
513             *pp_block = block_BytestreamPop( &p_sys->bytestream );
514
515             p_sys->i_state = STATE_NOSYNC;
516
517             /* Date management */
518             p_sout_block->i_pts =
519                 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
520             aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
521             p_sout_block->i_length =
522                 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
523
524             return p_sout_block;
525         }
526     }
527
528     return NULL;
529 }
530
531 #ifdef USE_LIBFLAC
532 /****************************************************************************
533  * DecodeBlock: the whole thing
534  ****************************************************************************/
535 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
536 {
537     decoder_sys_t *p_sys = p_dec->p_sys;
538
539     if( !pp_block || !*pp_block ) return NULL;
540
541     p_sys->p_aout_buffer = 0;
542     if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
543     {
544         if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
545         {
546             decoder_state_error( p_dec,
547                 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
548             FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
549         }
550
551         /* If the decoder is in the "aborted" state,
552          * FLAC__stream_decoder_process_single() won't return an error. */
553         if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
554             == FLAC__STREAM_DECODER_ABORTED )
555         {
556             FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
557         }
558
559         block_Release( p_sys->p_block );
560         p_sys->p_block = NULL;
561     }
562
563     return p_sys->p_aout_buffer;
564 }
565
566 /*****************************************************************************
567  * DecoderReadCallback: called by libflac when it needs more data
568  *****************************************************************************/
569 static FLAC__StreamDecoderReadStatus
570 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
571                      unsigned *bytes, void *client_data )
572 {
573     decoder_t *p_dec = (decoder_t *)client_data;
574     decoder_sys_t *p_sys = p_dec->p_sys;
575
576     if( p_sys->p_block && p_sys->p_block->i_buffer )
577     {
578         *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
579         memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
580         p_sys->p_block->i_buffer -= *bytes;
581         p_sys->p_block->p_buffer += *bytes;
582     }
583     else
584     {
585         *bytes = 0;
586         return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
587     }
588
589     return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
590 }
591
592 /*****************************************************************************
593  * DecoderWriteCallback: called by libflac to output decoded samples
594  *****************************************************************************/
595 static FLAC__StreamDecoderWriteStatus
596 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
597                       const FLAC__Frame *frame,
598                       const FLAC__int32 *const buffer[], void *client_data )
599 {
600     decoder_t *p_dec = (decoder_t *)client_data;
601     decoder_sys_t *p_sys = p_dec->p_sys;
602
603     p_sys->p_aout_buffer =
604         p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
605
606     if( p_sys->p_aout_buffer == NULL )
607         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
608
609     switch( frame->header.bits_per_sample )
610     {
611     case 16:
612         Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
613                       frame->header.channels, frame->header.blocksize );
614         break;
615     default:
616         Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
617                       frame->header.channels, frame->header.blocksize );
618     }
619
620     /* Date management (already done by packetizer) */
621     p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
622     p_sys->p_aout_buffer->end_date =
623         p_sys->p_block->i_pts + p_sys->p_block->i_length;
624
625     return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
626 }
627
628 /*****************************************************************************
629  * DecoderMetadataCallback: called by libflac to when it encounters metadata
630  *****************************************************************************/
631 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
632                                      const FLAC__StreamMetadata *metadata,
633                                      void *client_data )
634 {
635     decoder_t *p_dec = (decoder_t *)client_data;
636     decoder_sys_t *p_sys = p_dec->p_sys;
637
638     switch( metadata->data.stream_info.bits_per_sample )
639     {
640     case 8:
641         p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
642         break;
643     case 16:
644         p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
645         break;
646     default:
647         msg_Dbg( p_dec, "strange bit/sample value: %d",
648                  metadata->data.stream_info.bits_per_sample );
649         p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
650         break;
651     }
652
653     /* Setup the format */
654     p_dec->fmt_out.audio.i_rate     = metadata->data.stream_info.sample_rate;
655     p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
656     p_dec->fmt_out.audio.i_physical_channels =
657         p_dec->fmt_out.audio.i_original_channels =
658             pi_channels_maps[metadata->data.stream_info.channels];
659     p_dec->fmt_out.audio.i_bitspersample =
660         metadata->data.stream_info.bits_per_sample;
661
662     aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
663
664     msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
665              p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
666              p_dec->fmt_out.audio.i_bitspersample );
667
668     p_sys->b_stream_info = VLC_TRUE;
669     p_sys->stream_info = metadata->data.stream_info;
670
671     return;
672 }
673
674 /*****************************************************************************
675  * DecoderErrorCallback: called when the libflac decoder encounters an error
676  *****************************************************************************/
677 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
678                                   FLAC__StreamDecoderErrorStatus status,
679                                   void *client_data )
680 {
681     decoder_t *p_dec = (decoder_t *)client_data;
682
683     switch( status )
684     {
685     case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
686         msg_Warn( p_dec, "an error in the stream caused the decoder to "
687                  "lose synchronization." );
688         break;
689     case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
690         msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
691         break;
692     case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
693         msg_Err( p_dec, "frame's data did not match the CRC in the "
694                  "footer." );
695         break;
696     default:
697         msg_Err( p_dec, "got decoder error: %d", status );
698     }
699
700     FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
701     return;
702 }
703
704 /*****************************************************************************
705  * Interleave: helper function to interleave channels
706  *****************************************************************************/
707 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
708                           int i_nb_channels, int i_samples )
709 {
710     int i, j;
711     for ( j = 0; j < i_samples; j++ )
712     {
713         for ( i = 0; i < i_nb_channels; i++ )
714         {
715             p_out[j * i_nb_channels + i] = pp_in[i][j];
716         }
717     }
718 }
719 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
720                           int i_nb_channels, int i_samples )
721 {
722     int i, j;
723     for ( j = 0; j < i_samples; j++ )
724     {
725         for ( i = 0; i < i_nb_channels; i++ )
726         {
727             p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
728         }
729     }
730 }
731
732 /*****************************************************************************
733  * decoder_state_error: print meaningful error messages
734  *****************************************************************************/
735 static void decoder_state_error( decoder_t *p_dec,
736                                  FLAC__StreamDecoderState state )
737 {
738     switch ( state )
739     {
740     case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
741         msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
742         break;
743     case FLAC__STREAM_DECODER_READ_METADATA:
744         msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
745                  "reading metadata." );
746         break;
747     case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
748         msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
749                  "searching for the frame sync code." );
750         break;
751     case FLAC__STREAM_DECODER_READ_FRAME:
752         msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
753                  "reading a frame." );
754         break;
755     case FLAC__STREAM_DECODER_END_OF_STREAM:
756         msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
757         break;
758 #ifdef USE_NEW_FLAC_API
759     case FLAC__STREAM_DECODER_OGG_ERROR:
760         msg_Err( p_dec, "error occurred in the Ogg layer." );
761         break;
762     case FLAC__STREAM_DECODER_SEEK_ERROR:
763         msg_Err( p_dec, "error occurred while seeking." );
764         break;
765 #endif
766     case FLAC__STREAM_DECODER_ABORTED:
767         msg_Warn( p_dec, "the decoder was aborted by the read callback." );
768         break;
769 #ifndef USE_NEW_FLAC_API
770     case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
771         msg_Warn( p_dec, "the decoder encountered reserved fields in use "
772                  "in the stream." );
773         break;
774 #endif
775     case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
776         msg_Err( p_dec, "error when allocating memory." );
777         break;
778 #ifndef USE_NEW_FLAC_API
779     case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
780         msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
781                  "decoder was already initialized, usually because "
782                  "FLAC__stream_decoder_finish() was not called." );
783         break;
784     case FLAC__STREAM_DECODER_INVALID_CALLBACK:
785         msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
786                  "all callbacks being set." );
787         break;
788 #endif
789     case FLAC__STREAM_DECODER_UNINITIALIZED:
790         msg_Err( p_dec, "decoder in uninitialized state." );
791         break;
792     default:
793         msg_Warn(p_dec, "unknown error" );
794     }
795 }
796 #endif
797
798 /*****************************************************************************
799  * SyncInfo: parse FLAC sync info
800  *****************************************************************************/
801 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
802                      unsigned int * pi_channels,
803                      unsigned int * pi_channels_conf,
804                      unsigned int * pi_sample_rate,
805                      int * pi_bits_per_sample )
806 {
807     decoder_sys_t *p_sys = p_dec->p_sys;
808     int i_header, i_temp, i_read;
809     int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
810     uint64_t i_sample_number = 0;
811
812     vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
813         p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
814     vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
815         p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
816
817     /* Check syncword */
818     if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
819
820     /* Check there is no emulated sync code in the rest of the header */
821     if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
822
823     /* Find blocksize (framelength) */
824     switch( i_temp = p_buf[2] >> 4 )
825     {
826     case 0:
827         if( b_fixed_blocksize )
828             i_blocksize = p_sys->stream_info.min_blocksize;
829         else return 0; /* We can't do anything with this */
830         break;
831
832     case 1:
833         i_blocksize = 192;
834         break;
835
836     case 2:
837     case 3:
838     case 4:
839     case 5:
840         i_blocksize = 576 << (i_temp - 2);
841         break;
842
843     case 6:
844     case 7:
845         i_blocksize_hint = i_temp;
846         break;
847
848     case 8:
849     case 9:
850     case 10:
851     case 11:
852     case 12:
853     case 13:
854     case 14:
855     case 15:
856         i_blocksize = 256 << (i_temp - 8);
857         break;
858     }
859
860     /* Find samplerate */
861     switch( i_temp = p_buf[2] & 0x0f )
862     {
863     case 0:
864         if( p_sys->b_stream_info )
865             *pi_sample_rate = p_sys->stream_info.sample_rate;
866         else return 0; /* We can't do anything with this */
867         break;
868
869     case 1:
870     case 2:
871     case 3:
872         return 0;
873         break;
874
875     case 4:
876         *pi_sample_rate = 8000;
877         break;
878
879     case 5:
880         *pi_sample_rate = 16000;
881         break;
882
883     case 6:
884         *pi_sample_rate = 22050;
885         break;
886
887     case 7:
888         *pi_sample_rate = 24000;
889         break;
890
891     case 8:
892         *pi_sample_rate = 32000;
893         break;
894
895     case 9:
896         *pi_sample_rate = 44100;
897         break;
898
899     case 10:
900         *pi_sample_rate = 48000;
901         break;
902
903     case 11:
904         *pi_sample_rate = 96000;
905         break;
906
907     case 12:
908     case 13:
909     case 14:
910         i_sample_rate_hint = i_temp;
911         break;
912
913     case 15:
914         return 0;
915     }
916
917     /* Find channels */
918     i_temp = (unsigned)(p_buf[3] >> 4);
919     if( i_temp & 8 )
920     {
921 #ifdef USE_LIBFLAC
922         int i_channel_assignment; /* ??? */
923
924         switch( i_temp & 7 )
925         {
926         case 0:
927             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
928             break;
929         case 1:
930             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
931             break;
932         case 2:
933             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
934             break;
935         default:
936             return 0;
937             break;
938         }
939 #endif
940
941         *pi_channels = 2;
942     }
943     else
944     {
945         *pi_channels = i_temp + 1;
946         *pi_channels_conf = pi_channels_maps[ *pi_channels ];
947     }
948
949     /* Find bits per sample */
950     switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
951     {
952     case 0:
953         if( p_sys->b_stream_info )
954             *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
955         else
956             return 0;
957         break;
958
959     case 1:
960         *pi_bits_per_sample = 8;
961         break;
962
963     case 2:
964         *pi_bits_per_sample = 12;
965         break;
966
967     case 4:
968         *pi_bits_per_sample = 16;
969         break;
970
971     case 5:
972         *pi_bits_per_sample = 20;
973         break;
974
975     case 6:
976         *pi_bits_per_sample = 24;
977         break;
978
979     case 3:
980     case 7:
981         return 0;
982         break;
983     }
984
985     /* Zero padding bit */
986     if( p_buf[3] & 0x01 ) return 0;
987
988     /* End of fixed size header */
989     i_header = 4;
990
991     /* Find Sample/Frame number */
992     if( i_blocksize_hint && b_variable_blocksize )
993     {
994         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
995         if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
996     }
997     else
998     {
999         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1000         if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
1001
1002         if( p_sys->b_stream_info )
1003             i_sample_number *= p_sys->stream_info.min_blocksize;
1004     }
1005
1006     i_header += i_read;
1007
1008     /* Read blocksize */
1009     if( i_blocksize_hint )
1010     {
1011         int i_val1 = p_buf[i_header++];
1012         if( i_blocksize_hint == 7 )
1013         {
1014             int i_val2 = p_buf[i_header++];
1015             i_val1 = (i_val1 << 8) | i_val2;
1016         }
1017         i_blocksize = i_val1 + 1;
1018     }
1019
1020     /* Read sample rate */
1021     if( i_sample_rate_hint )
1022     {
1023         int i_val1 = p_buf[i_header++];
1024         if( i_sample_rate_hint != 12 )
1025         {
1026             int i_val2 = p_buf[i_header++];
1027             i_val1 = (i_val1 << 8) | i_val2;
1028         }
1029         if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1030         else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1031         else *pi_sample_rate = i_val1 * 10;
1032     }
1033
1034     /* Check the CRC-8 byte */
1035     if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1036     {
1037         return 0;
1038     }
1039
1040     return i_blocksize;
1041 }
1042
1043 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1044 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1045 {
1046     uint64_t i_result = 0;
1047     unsigned i, j;
1048
1049     if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1050     {
1051         i_result = p_buf[0];
1052         i = 0;
1053     }
1054     else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1055     {
1056         i_result = p_buf[0] & 0x1F;
1057         i = 1;
1058     }
1059     else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1060     {
1061         i_result = p_buf[0] & 0x0F;
1062         i = 2;
1063     }
1064     else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1065     {
1066         i_result = p_buf[0] & 0x07;
1067         i = 3;
1068     }
1069     else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1070     {
1071         i_result = p_buf[0] & 0x03;
1072         i = 4;
1073     }
1074     else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1075     {
1076         i_result = p_buf[0] & 0x01;
1077         i = 5;
1078     }
1079     else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1080     {
1081         i_result = 0;
1082         i = 6;
1083     }
1084     else {
1085         return I64C(0xffffffffffffffff);
1086     }
1087
1088     for( j = 1; j <= i; j++ )
1089     {
1090         if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1091         {
1092             return I64C(0xffffffffffffffff);
1093         }
1094         i_result <<= 6;
1095         i_result |= (p_buf[j] & 0x3F);
1096     }
1097
1098     *pi_read = i;
1099     return i_result;
1100 }
1101
1102 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1103 static uint8_t const flac_crc8_table[256] = {
1104         0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1105         0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1106         0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1107         0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1108         0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1109         0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1110         0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1111         0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1112         0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1113         0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1114         0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1115         0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1116         0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1117         0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1118         0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1119         0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1120         0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1121         0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1122         0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1123         0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1124         0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1125         0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1126         0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1127         0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1128         0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1129         0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1130         0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1131         0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1132         0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1133         0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1134         0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1135         0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1136 };
1137
1138 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1139 {
1140     uint8_t crc = 0;
1141
1142     while(len--)
1143         crc = flac_crc8_table[crc ^ *data++];
1144
1145     return crc;
1146 }
1147
1148 #ifdef USE_LIBFLAC
1149 /*****************************************************************************
1150  * encoder_sys_t : flac encoder descriptor
1151  *****************************************************************************/
1152 struct encoder_sys_t
1153 {
1154     /*
1155      * Input properties
1156      */
1157     int i_headers;
1158
1159     int i_samples_delay;
1160     int i_channels;
1161
1162     FLAC__int32 *p_buffer;
1163     unsigned int i_buffer;
1164
1165     block_t *p_chain;
1166
1167     /*
1168      * FLAC properties
1169      */
1170     FLAC__StreamEncoder *p_flac;
1171     FLAC__StreamMetadata_StreamInfo stream_info;
1172
1173     /*
1174      * Common properties
1175      */
1176     mtime_t i_pts;
1177 };
1178
1179 #define STREAMINFO_SIZE 38
1180
1181 static block_t *Encode( encoder_t *, aout_buffer_t * );
1182
1183 static FLAC__StreamEncoderWriteStatus
1184 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1185                       const FLAC__byte buffer[],
1186                       unsigned bytes, unsigned samples,
1187                       unsigned current_frame, void *client_data );
1188
1189 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1190                                      const FLAC__StreamMetadata *metadata,
1191                                      void *client_data );
1192
1193 /*****************************************************************************
1194  * OpenEncoder: probe the encoder and return score
1195  *****************************************************************************/
1196 static int OpenEncoder( vlc_object_t *p_this )
1197 {
1198     encoder_t *p_enc = (encoder_t *)p_this;
1199     encoder_sys_t *p_sys;
1200
1201     if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1202         !p_enc->b_force )
1203     {
1204         return VLC_EGENERIC;
1205     }
1206
1207     /* Allocate the memory needed to store the decoder's structure */
1208     if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1209     {
1210         msg_Err( p_enc, "out of memory" );
1211         return VLC_EGENERIC;
1212     }
1213     p_enc->p_sys = p_sys;
1214     p_enc->pf_encode_audio = Encode;
1215     p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1216
1217     p_sys->i_headers = 0;
1218     p_sys->p_buffer = 0;
1219     p_sys->i_buffer = 0;
1220     p_sys->i_samples_delay = 0;
1221
1222     /* Create flac encoder */
1223     if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1224     {
1225         msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1226         free( p_sys );
1227         return VLC_EGENERIC;
1228     }
1229
1230     FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1231     FLAC__stream_encoder_set_channels( p_sys->p_flac,
1232                                        p_enc->fmt_in.audio.i_channels );
1233     FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1234                                           p_enc->fmt_in.audio.i_rate );
1235     FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1236     p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1237
1238     /* Get and store the STREAMINFO metadata block as a p_extra */
1239     p_sys->p_chain = 0;
1240
1241 #ifdef USE_NEW_FLAC_API
1242     if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1243                                           EncoderWriteCallback,
1244                                           NULL,
1245                                           NULL,
1246                                           EncoderMetadataCallback,
1247                                           p_enc )
1248         != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1249     {
1250         msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1251         FLAC__stream_encoder_delete( p_sys->p_flac );
1252         free( p_sys );
1253         return VLC_EGENERIC;
1254     }
1255 #else
1256     FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1257         EncoderWriteCallback );
1258     FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1259         EncoderMetadataCallback );
1260     FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1261
1262     FLAC__stream_encoder_init( p_sys->p_flac );
1263 #endif
1264
1265     return VLC_SUCCESS;
1266 }
1267
1268 /****************************************************************************
1269  * Encode: the whole thing
1270  ****************************************************************************
1271  * This function spits out ogg packets.
1272  ****************************************************************************/
1273 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1274 {
1275     encoder_sys_t *p_sys = p_enc->p_sys;
1276     block_t *p_chain;
1277     unsigned int i;
1278
1279     p_sys->i_pts = p_aout_buf->start_date -
1280                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1281                 (mtime_t)p_enc->fmt_in.audio.i_rate;
1282
1283     p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1284
1285     /* Convert samples to FLAC__int32 */
1286     if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1287     {
1288         p_sys->p_buffer =
1289             realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1290         p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1291     }
1292
1293     for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1294     {
1295         p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1296     }
1297
1298     FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1299                                               p_aout_buf->i_nb_samples );
1300
1301     p_chain = p_sys->p_chain;
1302     p_sys->p_chain = 0;
1303
1304     return p_chain;
1305 }
1306
1307 /*****************************************************************************
1308  * CloseEncoder: encoder destruction
1309  *****************************************************************************/
1310 static void CloseEncoder( vlc_object_t *p_this )
1311 {
1312     encoder_t *p_enc = (encoder_t *)p_this;
1313     encoder_sys_t *p_sys = p_enc->p_sys;
1314
1315     FLAC__stream_encoder_delete( p_sys->p_flac );
1316
1317     if( p_sys->p_buffer ) free( p_sys->p_buffer );
1318     free( p_sys );
1319 }
1320
1321 /*****************************************************************************
1322  * EncoderMetadataCallback: called by libflac to output metadata
1323  *****************************************************************************/
1324 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1325                                      const FLAC__StreamMetadata *metadata,
1326                                      void *client_data )
1327 {
1328     encoder_t *p_enc = (encoder_t *)client_data;
1329
1330     msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1331     return;
1332 }
1333
1334 /*****************************************************************************
1335  * EncoderWriteCallback: called by libflac to output encoded samples
1336  *****************************************************************************/
1337 static FLAC__StreamEncoderWriteStatus
1338 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1339                       const FLAC__byte buffer[],
1340                       unsigned bytes, unsigned samples,
1341                       unsigned current_frame, void *client_data )
1342 {
1343     encoder_t *p_enc = (encoder_t *)client_data;
1344     encoder_sys_t *p_sys = p_enc->p_sys;
1345     block_t *p_block;
1346
1347     if( samples == 0 )
1348     {
1349         if( p_sys->i_headers == 1 )
1350         {
1351             msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1352
1353             /* Backup the STREAMINFO metadata block */
1354             p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1355             p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1356             memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1357             memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1358                     STREAMINFO_SIZE );
1359
1360             /* Fake this as the last metadata block */
1361             ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1362         }
1363         p_sys->i_headers++;
1364         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1365     }
1366
1367     p_block = block_New( p_enc, bytes );
1368     memcpy( p_block->p_buffer, buffer, bytes );
1369
1370     p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1371
1372     p_sys->i_samples_delay -= samples;
1373
1374     p_block->i_length = (mtime_t)1000000 *
1375         (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1376
1377     /* Update pts */
1378     p_sys->i_pts += p_block->i_length;
1379
1380     block_ChainAppend( &p_sys->p_chain, p_block );
1381
1382     return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1383 }
1384 #endif