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