git.sesse.net Git - vlc/blob - modules/codec/flac.c

   1 /*****************************************************************************
   2  * flac.c: flac decoder/packetizer module making use of libflac
   3  *****************************************************************************
   4  * Copyright (C) 1999-2001 VideoLAN
   5  * $Id: flac.c,v 1.2 2003/11/21 12:18:54 gbazin Exp $
   6  *
   7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
   8  *          Sigmund Augdal <sigmunau@idi.ntnu.no>
   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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <vlc/vlc.h>
  29 #include <vlc/decoder.h>
  30 #include <vlc/input.h>
  31
  32 #include <FLAC/stream_decoder.h>
  33
  34 #include "vlc_block_helper.h"
  35
  36 #define MAX_FLAC_HEADER_SIZE 16
  37
  38 /*****************************************************************************
  39  * decoder_sys_t : FLAC decoder descriptor
  40  *****************************************************************************/
  41 struct decoder_sys_t
  42 {
  43     /* Module mode */
  44     vlc_bool_t b_packetizer;
  45
  46     /*
  47      * Input properties
  48      */
  49     int i_state;
  50
  51     block_bytestream_t bytestream;
  52
  53     /*
  54      * Input/Output properties
  55      */
  56     block_t *p_block;
  57     aout_buffer_t *p_aout_buffer;
  58
  59     /*
  60      * FLAC properties
  61      */
  62     FLAC__StreamDecoder *p_flac;
  63
  64     vlc_bool_t b_stream_info;
  65     FLAC__StreamMetadata_StreamInfo stream_info;
  66
  67     /*
  68      * Common properties
  69      */
  70     audio_date_t end_date;
  71     mtime_t i_pts;
  72
  73     int i_frame_size, i_frame_length, i_bits_per_sample;
  74     unsigned int i_rate, i_channels, i_channels_conf;
  75 };
  76
  77 enum {
  78
  79     STATE_NOSYNC,
  80     STATE_SYNC,
  81     STATE_HEADER,
  82     STATE_NEXT_SYNC,
  83     STATE_GET_DATA,
  84     STATE_SEND_DATA
  85 };
  86
  87 static int pi_channels_maps[6] =
  88 {
  89     0,
  90     AOUT_CHAN_CENTER,
  91     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
  92     AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
  93     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
  94      | AOUT_CHAN_REARRIGHT,
  95     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
  96      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
  97 };
  98
  99 /*****************************************************************************
 100  * Local prototypes
 101  *****************************************************************************/
 102 static int  OpenDecoder   ( vlc_object_t * );
 103 static int  OpenPacketizer( vlc_object_t * );
 104 static void CloseDecoder  ( vlc_object_t * );
 105
 106 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
 107 static block_t *PacketizeBlock( decoder_t *, block_t ** );
 108
 109 static int SyncInfo( decoder_t *, uint8_t *, int *, int *, int *,int * );
 110
 111
 112 static FLAC__StreamDecoderReadStatus
 113 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
 114                      FLAC__byte buffer[], unsigned *bytes, void *client_data );
 115
 116 static FLAC__StreamDecoderWriteStatus
 117 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
 118                       const FLAC__Frame *frame,
 119                       const FLAC__int32 *const buffer[], void *client_data );
 120
 121 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
 122                                      const FLAC__StreamMetadata *metadata,
 123                                      void *client_data );
 124 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
 125                                   FLAC__StreamDecoderErrorStatus status,
 126                                   void *client_data);
 127
 128 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
 129                           int i_nb_channels, int i_samples );
 130 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
 131                           int i_nb_channels, int i_samples );
 132
 133 static void decoder_state_error( decoder_t *p_dec,
 134                                  FLAC__StreamDecoderState state );
 135
 136 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
 137 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
 138
 139 /*****************************************************************************
 140  * Module descriptor
 141  *****************************************************************************/
 142 vlc_module_begin();
 143
 144     set_description( _("Flac audio decoder") );
 145     set_capability( "decoder", 100 );
 146     set_callbacks( OpenDecoder, CloseDecoder );
 147
 148     add_submodule();
 149     set_description( _("Flac audio packetizer") );
 150     set_capability( "packetizer", 100 );
 151     set_callbacks( OpenPacketizer, CloseDecoder );
 152
 153 vlc_module_end();
 154
 155 /*****************************************************************************
 156  * OpenDecoder: probe the decoder and return score
 157  *****************************************************************************/
 158 static int OpenDecoder( vlc_object_t *p_this )
 159 {
 160     decoder_t *p_dec = (decoder_t*)p_this;
 161     decoder_sys_t *p_sys;
 162
 163     if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
 164     {
 165         return VLC_EGENERIC;
 166     }
 167
 168     /* Allocate the memory needed to store the decoder's structure */
 169     if( ( p_dec->p_sys = p_sys =
 170           (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
 171     {
 172         msg_Err( p_dec, "out of memory" );
 173         return VLC_EGENERIC;
 174     }
 175
 176     /* Misc init */
 177     aout_DateSet( &p_sys->end_date, 0 );
 178     p_sys->b_packetizer = VLC_FALSE;
 179     p_sys->i_state = STATE_NOSYNC;
 180
 181     p_sys->bytestream = block_BytestreamInit( p_dec );
 182
 183     /* Take care of flac init */
 184     if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
 185     {
 186         msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
 187         free( p_sys );
 188         return VLC_EGENERIC;
 189     }
 190
 191     FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
 192                                             DecoderReadCallback );
 193     FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
 194                                              DecoderWriteCallback );
 195     FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
 196                                                 DecoderMetadataCallback );
 197     FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
 198                                              DecoderErrorCallback );
 199     FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
 200
 201     FLAC__stream_decoder_init( p_sys->p_flac );
 202
 203     /* Set output properties */
 204     p_dec->fmt_out.i_cat = AUDIO_ES;
 205     p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
 206
 207     /* Set callbacks */
 208     p_dec->pf_decode_audio = DecodeBlock;
 209     p_dec->pf_packetize    = PacketizeBlock;
 210
 211
 212     /* Decode STREAMINFO */
 213     msg_Dbg( p_dec, "decode STREAMINFO" );
 214     p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra + 4 );
 215     memcpy( p_sys->p_block->p_buffer + 4, p_dec->fmt_in.p_extra,
 216             p_dec->fmt_in.i_extra );
 217     memcpy( p_sys->p_block->p_buffer, "fLaC", 4 );
 218     FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
 219     msg_Dbg( p_dec, "STREAMINFO decoded" );
 220
 221     return VLC_SUCCESS;
 222 }
 223
 224 static int OpenPacketizer( vlc_object_t *p_this )
 225 {
 226     decoder_t *p_dec = (decoder_t*)p_this;
 227
 228     int i_ret = OpenDecoder( p_this );
 229
 230     if( i_ret == VLC_SUCCESS )
 231     {
 232         p_dec->p_sys->b_packetizer = VLC_TRUE;
 233         p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
 234     }
 235
 236     return i_ret;
 237 }
 238
 239 /****************************************************************************
 240  * PacketizeBlock: the whole thing
 241  ****************************************************************************
 242  * This function is called just after the thread is launched.
 243  ****************************************************************************/
 244 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
 245 {
 246     decoder_sys_t *p_sys = p_dec->p_sys;
 247     uint8_t p_header[MAX_FLAC_HEADER_SIZE];
 248     block_t *p_sout_block;
 249
 250     if( !pp_block || !*pp_block ) return NULL;
 251
 252 #if 0
 253     if( (*pp_block)->b_discontinuity )
 254     {
 255         p_sys->i_state = STATE_NOSYNC;
 256     }
 257 #endif
 258
 259     block_BytestreamPush( &p_sys->bytestream, *pp_block );
 260
 261     while( 1 )
 262     {
 263         switch( p_sys->i_state )
 264         {
 265         case STATE_NOSYNC:
 266             while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
 267                    == VLC_SUCCESS )
 268             {
 269                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
 270                 {
 271                     p_sys->i_state = STATE_SYNC;
 272                     break;
 273                 }
 274                 block_SkipByte( &p_sys->bytestream );
 275             }
 276             if( p_sys->i_state != STATE_SYNC )
 277             {
 278                 block_BytestreamFlush( &p_sys->bytestream );
 279
 280                 /* Need more data */
 281                 return NULL;
 282             }
 283
 284         case STATE_SYNC:
 285             /* New frame, set the Presentation Time Stamp */
 286             p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
 287             if( p_sys->i_pts != 0 &&
 288                 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
 289             {
 290                 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
 291             }
 292             p_sys->i_state = STATE_HEADER;
 293
 294         case STATE_HEADER:
 295             /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
 296             if( block_PeekBytes( &p_sys->bytestream, p_header,
 297                                  MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
 298             {
 299                 /* Need more data */
 300                 return NULL;
 301             }
 302
 303             /* Check if frame is valid and get frame info */
 304             p_sys->i_frame_length = SyncInfo( p_dec, p_header,
 305                                               &p_sys->i_channels,
 306                                               &p_sys->i_channels_conf,
 307                                               &p_sys->i_rate,
 308                                               &p_sys->i_bits_per_sample );
 309             if( !p_sys->i_frame_length )
 310             {
 311                 msg_Dbg( p_dec, "emulated sync word" );
 312                 block_SkipByte( &p_sys->bytestream );
 313                 p_sys->i_state = STATE_NOSYNC;
 314                 break;
 315             }
 316             p_sys->i_state = STATE_NEXT_SYNC;
 317             p_sys->i_frame_size = 1;
 318
 319         case STATE_NEXT_SYNC:
 320             /* TODO: If pp_block == NULL, flush the buffer without checking the
 321              * next sync word */
 322
 323             /* Check if next expected frame contains the sync word */
 324             while( block_PeekOffsetBytes( &p_sys->bytestream,
 325                                           p_sys->i_frame_size, p_header,
 326                                           MAX_FLAC_HEADER_SIZE )
 327                    == VLC_SUCCESS )
 328             {
 329                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
 330                 {
 331                     /* Check if frame is valid and get frame info */
 332                     p_sys->i_frame_length =
 333                         SyncInfo( p_dec, p_header,
 334                                   &p_sys->i_channels,
 335                                   &p_sys->i_channels_conf,
 336                                   &p_sys->i_rate,
 337                                   &p_sys->i_bits_per_sample );
 338
 339                     if( p_sys->i_frame_length )
 340                     {
 341                         p_sys->i_state = STATE_SEND_DATA;
 342                         break;
 343                     }
 344                 }
 345                 p_sys->i_frame_size++;
 346             }
 347
 348             if( p_sys->i_state != STATE_SEND_DATA )
 349             {
 350                 /* Need more data */
 351                 return NULL;
 352             }
 353             break;
 354
 355         case STATE_SEND_DATA:
 356             p_sout_block = block_New( p_dec, p_sys->i_frame_size );
 357
 358             /* Copy the whole frame into the buffer. When we reach this point
 359              * we already know we have enough data available. */
 360             block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
 361                             p_sys->i_frame_size );
 362
 363             /* Make sure we don't reuse the same pts twice */
 364             if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
 365                 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
 366
 367             /* So p_block doesn't get re-added several times */
 368             *pp_block = block_BytestreamPop( &p_sys->bytestream );
 369
 370             p_sys->i_state = STATE_NOSYNC;
 371
 372             /* Date management */
 373             p_sout_block->i_pts = aout_DateGet( &p_sys->end_date );
 374             p_sout_block->i_length =
 375                 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
 376
 377             return p_sout_block;
 378         }
 379     }
 380
 381     return NULL;
 382 }
 383
 384 /****************************************************************************
 385  * DecodeBlock: the whole thing
 386  ****************************************************************************/
 387 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
 388 {
 389     decoder_sys_t *p_sys = p_dec->p_sys;
 390
 391     if( !pp_block || !*pp_block ) return NULL;
 392
 393     if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
 394     {
 395         /* We've just started the stream, wait for the first PTS. */
 396         block_Release( *pp_block );
 397         return NULL;
 398     }
 399
 400     p_sys->p_aout_buffer = 0;
 401     if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
 402     {
 403         if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
 404         {
 405             decoder_state_error( p_dec,
 406                 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
 407             FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
 408         }
 409
 410         /* If the decoder is in the "aborted" state,
 411          * FLAC__stream_decoder_process_single() won't return an error. */
 412         if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
 413             == FLAC__STREAM_DECODER_ABORTED )
 414         {
 415             FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
 416         }
 417
 418         block_Release( p_sys->p_block );
 419     }
 420
 421     return p_sys->p_aout_buffer;
 422 }
 423
 424 /*****************************************************************************
 425  * CloseDecoder: flac decoder destruction
 426  *****************************************************************************/
 427 static void CloseDecoder( vlc_object_t *p_this )
 428 {
 429     decoder_t *p_dec = (decoder_t *)p_this;
 430     decoder_sys_t *p_sys = p_dec->p_sys;
 431
 432     FLAC__stream_decoder_finish( p_sys->p_flac );
 433     FLAC__stream_decoder_delete( p_sys->p_flac );
 434     free( p_sys );
 435 }
 436
 437 /*****************************************************************************
 438  * DecoderReadCallback: called by libflac when it needs more data
 439  *****************************************************************************/
 440 static FLAC__StreamDecoderReadStatus
 441 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
 442                      unsigned *bytes, void *client_data )
 443 {
 444     decoder_t *p_dec = (decoder_t *)client_data;
 445     decoder_sys_t *p_sys = p_dec->p_sys;
 446
 447     if( p_sys->p_block && p_sys->p_block->i_buffer )
 448     {
 449         *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
 450         memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
 451         p_sys->p_block->i_buffer -= *bytes;
 452         p_sys->p_block->p_buffer += *bytes;
 453     }
 454     else
 455     {
 456         *bytes = 0;
 457         return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 458     }
 459
 460     return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 461 }
 462
 463 /*****************************************************************************
 464  * DecoderWriteCallback: called by libflac to output decoded samples
 465  *****************************************************************************/
 466 static FLAC__StreamDecoderWriteStatus
 467 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
 468                       const FLAC__Frame *frame,
 469                       const FLAC__int32 *const buffer[], void *client_data )
 470 {
 471     decoder_t *p_dec = (decoder_t *)client_data;
 472     decoder_sys_t *p_sys = p_dec->p_sys;
 473
 474     if( p_sys->p_block && p_sys->p_block->i_pts != 0 &&
 475         p_sys->p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
 476     {
 477         aout_DateSet( &p_sys->end_date, p_sys->p_block->i_pts );
 478     }
 479     else if( !aout_DateGet( &p_sys->end_date ) )
 480     {
 481         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 482     }
 483
 484     if( p_sys->p_block ) p_sys->p_block->i_pts = 0;
 485
 486     p_sys->p_aout_buffer =
 487         p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
 488
 489     if( p_sys->p_aout_buffer == NULL )
 490         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 491
 492     switch( frame->header.bits_per_sample )
 493     {
 494     case 16:
 495         Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
 496                       frame->header.channels, frame->header.blocksize );
 497         break;
 498     default:
 499         Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
 500                       frame->header.channels, frame->header.blocksize );
 501     }
 502
 503     /* Date management */
 504     p_sys->p_aout_buffer->start_date = aout_DateGet( &p_sys->end_date );
 505     p_sys->p_aout_buffer->end_date =
 506         aout_DateIncrement( &p_sys->end_date, frame->header.blocksize );
 507
 508     return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 509 }
 510
 511 /*****************************************************************************
 512  * DecoderMetadataCallback: called by libflac to when it encounters metadata
 513  *****************************************************************************/
 514 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
 515                                      const FLAC__StreamMetadata *metadata,
 516                                      void *client_data )
 517 {
 518     decoder_t *p_dec = (decoder_t *)client_data;
 519     decoder_sys_t *p_sys = p_dec->p_sys;
 520
 521     switch( metadata->data.stream_info.bits_per_sample )
 522     {
 523     case 8:
 524         p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
 525         break;
 526     case 16:
 527         p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
 528         break;
 529     default:
 530         msg_Dbg( p_dec, "strange bps %d",
 531                  metadata->data.stream_info.bits_per_sample );
 532         p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
 533         break;
 534     }
 535
 536     /* Setup the format */
 537     p_dec->fmt_out.audio.i_rate     = metadata->data.stream_info.sample_rate;
 538     p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
 539     p_dec->fmt_out.audio.i_physical_channels =
 540         p_dec->fmt_out.audio.i_original_channels =
 541             pi_channels_maps[metadata->data.stream_info.channels];
 542     p_dec->fmt_out.audio.i_bitspersample =
 543         metadata->data.stream_info.bits_per_sample;
 544
 545     aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
 546
 547     msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
 548              p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
 549              p_dec->fmt_out.audio.i_bitspersample );
 550
 551     p_sys->b_stream_info = VLC_TRUE;
 552     p_sys->stream_info = metadata->data.stream_info;
 553
 554     return;
 555 }
 556
 557 /*****************************************************************************
 558  * DecoderErrorCallback: called when the libflac decoder encounters an error
 559  *****************************************************************************/
 560 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
 561                                   FLAC__StreamDecoderErrorStatus status,
 562                                   void *client_data )
 563 {
 564     decoder_t *p_dec = (decoder_t *)client_data;
 565
 566     switch( status )
 567     {
 568     case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
 569         msg_Err( p_dec, "An error in the stream caused the decoder to "
 570                  "loose synchronization." );
 571         break;
 572     case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
 573         msg_Err( p_dec, "The decoder encountered a corrupted frame header." );
 574         break;
 575     case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
 576         msg_Err( p_dec, "The frame's data did not match the CRC in the "
 577                  "footer." );
 578         break;
 579     default:
 580         msg_Err( p_dec, "got decoder error: %d", status );
 581     }
 582
 583     FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
 584     return;
 585 }
 586
 587 /*****************************************************************************
 588  * Interleave: helper function to interleave channels
 589  *****************************************************************************/
 590 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
 591                           int i_nb_channels, int i_samples )
 592 {
 593     int i, j;
 594     for ( j = 0; j < i_samples; j++ )
 595     {
 596         for ( i = 0; i < i_nb_channels; i++ )
 597         {
 598             p_out[j * i_nb_channels + i] = pp_in[i][j];
 599         }
 600     }
 601 }
 602 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
 603                           int i_nb_channels, int i_samples )
 604 {
 605     int i, j;
 606     for ( j = 0; j < i_samples; j++ )
 607     {
 608         for ( i = 0; i < i_nb_channels; i++ )
 609         {
 610             p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
 611         }
 612     }
 613 }
 614
 615 /*****************************************************************************
 616  * decoder_state_error: print meaningful error messages
 617  *****************************************************************************/
 618 static void decoder_state_error( decoder_t *p_dec,
 619                                  FLAC__StreamDecoderState state )
 620 {
 621     switch ( state )
 622     {
 623     case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
 624         msg_Err( p_dec, "The decoder is ready to search for metadata." );
 625         break;
 626     case FLAC__STREAM_DECODER_READ_METADATA:
 627         msg_Err( p_dec, "The decoder is ready to or is in the process of "
 628                  "reading metadata." );
 629         break;
 630     case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
 631         msg_Err( p_dec, "The decoder is ready to or is in the process of "
 632                  "searching for the frame sync code." );
 633         break;
 634     case FLAC__STREAM_DECODER_READ_FRAME:
 635         msg_Err( p_dec, "The decoder is ready to or is in the process of "
 636                  "reading a frame." );
 637         break;
 638     case FLAC__STREAM_DECODER_END_OF_STREAM:
 639         msg_Err( p_dec, "The decoder has reached the end of the stream." );
 640         break;
 641     case FLAC__STREAM_DECODER_ABORTED:
 642         msg_Err( p_dec, "The decoder was aborted by the read callback." );
 643         break;
 644     case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
 645         msg_Err( p_dec, "The decoder encountered reserved fields in use "
 646                  "in the stream." );
 647         break;
 648     case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
 649         msg_Err( p_dec, "An error occurred allocating memory." );
 650         break;
 651     case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
 652         msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
 653                  "decoder was already initialized, usually because "
 654                  "FLAC__stream_decoder_finish() was not called." );
 655         break;
 656     case FLAC__STREAM_DECODER_INVALID_CALLBACK:
 657         msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
 658                  "all callbacks being set." );
 659         break;
 660     case FLAC__STREAM_DECODER_UNINITIALIZED:
 661         msg_Err( p_dec, "The decoder is in the uninitialized state." );
 662         break;
 663     default:
 664         msg_Err(p_dec, "unknown error" );
 665     }
 666 }
 667
 668 /*****************************************************************************
 669  * SyncInfo: parse FLAC sync info
 670  *****************************************************************************/
 671 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
 672                      int * pi_channels, int * pi_channels_conf,
 673                      int * pi_sample_rate, int * pi_bits_per_sample )
 674 {
 675     decoder_sys_t *p_sys = p_dec->p_sys;
 676     int i_header, i_temp, i_read;
 677     int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
 678     uint64_t i_sample_number = 0;
 679
 680     vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
 681         p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
 682     vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
 683         p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
 684
 685     /* Check syncword */
 686     if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
 687
 688     /* Check there is no emulated sync code in the rest of the header */
 689     if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
 690
 691     /* Find blocksize (framelength) */
 692     switch( i_temp = p_buf[2] >> 4 )
 693     {
 694     case 0:
 695         if( b_fixed_blocksize )
 696             i_blocksize = p_sys->stream_info.min_blocksize;
 697         else return 0; /* We can't do anything with this */
 698         break;
 699
 700     case 1:
 701         i_blocksize = 192;
 702         break;
 703
 704     case 2:
 705     case 3:
 706     case 4:
 707     case 5:
 708         i_blocksize = 576 << (i_temp - 2);
 709         break;
 710
 711     case 6:
 712     case 7:
 713         i_blocksize_hint = i_temp;
 714         break;
 715
 716     case 8:
 717     case 9:
 718     case 10:
 719     case 11:
 720     case 12:
 721     case 13:
 722     case 14:
 723     case 15:
 724         i_blocksize = 256 << (i_temp - 8);
 725         break;
 726     }
 727
 728     /* Find samplerate */
 729     switch( i_temp = p_buf[2] & 0x0f )
 730     {
 731     case 0:
 732         if( p_sys->b_stream_info )
 733             *pi_sample_rate = p_sys->stream_info.sample_rate;
 734         else return 0; /* We can't do anything with this */
 735         break;
 736
 737     case 1:
 738     case 2:
 739     case 3:
 740         return 0;
 741         break;
 742
 743     case 4:
 744         *pi_sample_rate = 8000;
 745         break;
 746
 747     case 5:
 748         *pi_sample_rate = 16000;
 749         break;
 750
 751     case 6:
 752         *pi_sample_rate = 22050;
 753         break;
 754
 755     case 7:
 756         *pi_sample_rate = 24000;
 757         break;
 758
 759     case 8:
 760         *pi_sample_rate = 32000;
 761         break;
 762
 763     case 9:
 764         *pi_sample_rate = 44100;
 765         break;
 766
 767     case 10:
 768         *pi_sample_rate = 48000;
 769         break;
 770
 771     case 11:
 772         *pi_sample_rate = 96000;
 773         break;
 774
 775     case 12:
 776     case 13:
 777     case 14:
 778         i_sample_rate_hint = i_temp;
 779         break;
 780
 781     case 15:
 782         return 0;
 783     }
 784
 785     /* Find channels */
 786     i_temp = (unsigned)(p_buf[3] >> 4);
 787     if( i_temp & 8 )
 788     {
 789         int i_channel_assignment; /* ??? */
 790
 791         *pi_channels = 2;
 792         switch( i_temp & 7 )
 793         {
 794         case 0:
 795             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
 796             break;
 797         case 1:
 798             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
 799             break;
 800         case 2:
 801             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
 802             break;
 803         default:
 804             return 0;
 805             break;
 806         }
 807     }
 808     else
 809     {
 810         *pi_channels = i_temp + 1;
 811         *pi_channels_conf = pi_channels_maps[ *pi_channels ];
 812     }
 813
 814     /* Find bits per sample */
 815     switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
 816     {
 817     case 0:
 818         if( p_sys->b_stream_info )
 819             *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
 820         else
 821             return 0;
 822         break;
 823
 824     case 1:
 825         *pi_bits_per_sample = 8;
 826         break;
 827
 828     case 2:
 829         *pi_bits_per_sample = 12;
 830         break;
 831
 832     case 4:
 833         *pi_bits_per_sample = 16;
 834         break;
 835
 836     case 5:
 837         *pi_bits_per_sample = 20;
 838         break;
 839
 840     case 6:
 841         *pi_bits_per_sample = 24;
 842         break;
 843
 844     case 3:
 845     case 7:
 846         return 0;
 847         break;
 848     }
 849
 850     /* Zero padding bit */
 851     if( p_buf[3] & 0x01 ) return 0;
 852
 853     /* End of fixed size header */
 854     i_header = 4;
 855
 856     /* Find Sample/Frame number */
 857     if( i_blocksize_hint && b_variable_blocksize )
 858     {
 859         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
 860         if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
 861     }
 862     else
 863     {
 864         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
 865         if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
 866
 867         if( p_sys->b_stream_info )
 868             i_sample_number *= p_sys->stream_info.min_blocksize;
 869     }
 870
 871     i_header += i_read;
 872
 873     /* Read blocksize */
 874     if( i_blocksize_hint )
 875     {
 876         int i_val1 = p_buf[i_header++];
 877         if( i_blocksize_hint == 7 )
 878         {
 879             int i_val2 = p_buf[i_header++];
 880             i_val1 = (i_val1 << 8) | i_val2;
 881         }
 882         i_blocksize = i_val1 + 1;
 883     }
 884
 885     /* Read sample rate */
 886     if( i_sample_rate_hint )
 887     {
 888         int i_val1 = p_buf[i_header++];
 889         if( i_sample_rate_hint != 12 )
 890         {
 891             int i_val2 = p_buf[i_header++];
 892             i_val1 = (i_val1 << 8) | i_val2;
 893         }
 894         if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
 895         else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
 896         else *pi_sample_rate = i_val1 * 10;
 897     }
 898
 899     /* Check the CRC-8 byte */
 900     if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
 901     {
 902         return 0;
 903     }
 904
 905     return i_blocksize;
 906 }
 907
 908 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
 909 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
 910 {
 911     uint64_t i_result = 0;
 912     unsigned i, j;
 913
 914     if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
 915     {
 916         i_result = p_buf[0];
 917         i = 0;
 918     }
 919     else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
 920     {
 921         i_result = p_buf[0] & 0x1F;
 922         i = 1;
 923     }
 924     else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
 925     {
 926         i_result = p_buf[0] & 0x0F;
 927         i = 2;
 928     }
 929     else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
 930     {
 931         i_result = p_buf[0] & 0x07;
 932         i = 3;
 933     }
 934     else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
 935     {
 936         i_result = p_buf[0] & 0x03;
 937         i = 4;
 938     }
 939     else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
 940     {
 941         i_result = p_buf[0] & 0x01;
 942         i = 5;
 943     }
 944     else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
 945     {
 946         i_result = 0;
 947         i = 6;
 948     }
 949     else {
 950         return I64C(0xffffffffffffffff);
 951     }
 952
 953     for( j = 1; j <= i; j++ )
 954     {
 955         if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
 956         {
 957             return I64C(0xffffffffffffffff);
 958         }
 959         i_result <<= 6;
 960         i_result |= (p_buf[j] & 0x3F);
 961     }
 962
 963     *pi_read = i;
 964     return i_result;
 965 }
 966
 967 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
 968 static uint8_t const flac_crc8_table[256] = {
 969         0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
 970         0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
 971         0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
 972         0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
 973         0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
 974         0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
 975         0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
 976         0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
 977         0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
 978         0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
 979         0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
 980         0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
 981         0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
 982         0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
 983         0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
 984         0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
 985         0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
 986         0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
 987         0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
 988         0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
 989         0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
 990         0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
 991         0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
 992         0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
 993         0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
 994         0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
 995         0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
 996         0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
 997         0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
 998         0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
 999         0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1000         0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1001 };
1002
1003 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1004 {
1005     uint8_t crc = 0;
1006
1007     while(len--)
1008         crc = flac_crc8_table[crc ^ *data++];
1009
1010     return crc;
1011 }