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