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