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