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