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

   1 /*****************************************************************************
   2  * flac.c: flac packetizer module.
   3  *****************************************************************************
   4  * Copyright (C) 1999-2001 VLC authors and VideoLAN
   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 it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * 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_common.h>
  34 #include <vlc_plugin.h>
  35 #include <vlc_codec.h>
  36
  37 #include <vlc_block_helper.h>
  38 #include <vlc_bits.h>
  39 #include "packetizer_helper.h"
  40
  41 /*****************************************************************************
  42  * Module descriptor
  43  *****************************************************************************/
  44 static int  Open ( vlc_object_t * );
  45 static void Close( vlc_object_t * );
  46
  47 vlc_module_begin()
  48     set_category( CAT_SOUT )
  49     set_subcategory( SUBCAT_SOUT_PACKETIZER )
  50     set_description( N_("Flac audio packetizer") )
  51     set_capability( "packetizer", 50 )
  52     set_callbacks( Open, Close )
  53 vlc_module_end()
  54
  55 /*****************************************************************************
  56  * decoder_sys_t : FLAC decoder descriptor
  57  *****************************************************************************/
  58 #define MAX_FLAC_HEADER_SIZE 16
  59 struct decoder_sys_t
  60 {
  61     /*
  62      * Input properties
  63      */
  64     int i_state;
  65
  66     block_bytestream_t bytestream;
  67
  68     /*
  69      * FLAC properties
  70      */
  71     struct
  72     {
  73         unsigned min_blocksize, max_blocksize;
  74         unsigned min_framesize, max_framesize;
  75         unsigned sample_rate;
  76         unsigned channels;
  77         unsigned bits_per_sample;
  78
  79     } stream_info;
  80     bool b_stream_info;
  81
  82     /*
  83      * Common properties
  84      */
  85     date_t  end_date;
  86     mtime_t i_pts;
  87
  88     int i_frame_length;
  89     size_t i_frame_size;
  90     unsigned int i_rate, i_channels, i_bits_per_sample;
  91 };
  92
  93 static const int pi_channels_maps[9] =
  94 {
  95     0,
  96     AOUT_CHAN_CENTER,
  97     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
  98     AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
  99     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
 100      | AOUT_CHAN_REARRIGHT,
 101     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 102      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
 103     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 104      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE,
 105     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 106      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_MIDDLELEFT
 107      | AOUT_CHAN_MIDDLERIGHT,
 108     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER | AOUT_CHAN_REARLEFT
 109      | AOUT_CHAN_REARRIGHT | AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT
 110      | AOUT_CHAN_LFE
 111 };
 112
 113
 114 /*****************************************************************************
 115  * Local prototypes
 116  *****************************************************************************/
 117 static block_t *Packetize( decoder_t *, block_t ** );
 118
 119 static int SyncInfo( decoder_t *, uint8_t *, unsigned int *,
 120                      unsigned int *, unsigned int * );
 121
 122 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
 123 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
 124
 125 static int Open( vlc_object_t *p_this )
 126 {
 127     decoder_t *p_dec = (decoder_t*)p_this;
 128     decoder_sys_t *p_sys;
 129
 130     if( p_dec->fmt_in.i_codec != VLC_CODEC_FLAC )
 131         return VLC_EGENERIC;
 132
 133     /* */
 134     p_dec->p_sys = p_sys = malloc(sizeof(*p_sys));
 135     if( !p_sys )
 136         return VLC_ENOMEM;
 137
 138     date_Set( &p_sys->end_date, 0 );
 139     p_sys->i_state       = STATE_NOSYNC;
 140     p_sys->b_stream_info = false;
 141     p_sys->i_pts         = VLC_TS_INVALID;
 142     block_BytestreamInit( &p_sys->bytestream );
 143
 144     /* */
 145     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
 146     p_dec->fmt_out.i_cat   = AUDIO_ES;
 147     p_dec->fmt_out.i_codec = VLC_CODEC_FLAC;
 148
 149     /* */
 150     p_dec->pf_decode_audio = NULL;
 151     p_dec->pf_packetize    = Packetize;
 152
 153     return VLC_SUCCESS;
 154 }
 155
 156 static void Close( vlc_object_t *p_this )
 157 {
 158     decoder_t *p_dec = (decoder_t *)p_this;
 159     decoder_sys_t *p_sys = p_dec->p_sys;
 160
 161     block_BytestreamRelease( &p_sys->bytestream );
 162     free( p_sys );
 163 }
 164
 165 /*****************************************************************************
 166  * ProcessHeader: process Flac header.
 167  *****************************************************************************/
 168 static void ProcessHeader( decoder_t *p_dec )
 169 {
 170     decoder_sys_t *p_sys = p_dec->p_sys;
 171
 172     bs_t bs;
 173
 174     if( p_dec->fmt_in.i_extra < 8 + 14 )
 175         return;
 176
 177     bs_init( &bs, (uint8_t*)p_dec->fmt_in.p_extra + 8, p_dec->fmt_in.i_extra - 8 );
 178
 179     p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
 180     p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
 181
 182     p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
 183     p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
 184
 185     p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
 186     p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
 187     p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
 188
 189     p_sys->b_stream_info = true;
 190
 191     p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
 192     p_dec->fmt_out.p_extra = xrealloc( p_dec->fmt_out.p_extra,
 193                                        p_dec->fmt_out.i_extra );
 194     memcpy( p_dec->fmt_out.p_extra,
 195             p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
 196 }
 197
 198 /* */
 199 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
 200 {
 201     decoder_sys_t *p_sys = p_dec->p_sys;
 202     uint8_t p_header[MAX_FLAC_HEADER_SIZE];
 203     block_t *p_sout_block;
 204
 205     if( !pp_block || !*pp_block ) return NULL;
 206
 207     if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
 208     {
 209         if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
 210         {
 211             p_sys->i_state = STATE_NOSYNC;
 212             block_BytestreamEmpty( &p_sys->bytestream );
 213         }
 214         date_Set( &p_sys->end_date, 0 );
 215         block_Release( *pp_block );
 216         return NULL;
 217     }
 218
 219     if( !p_sys->b_stream_info )
 220         ProcessHeader( p_dec );
 221
 222     if( p_sys->stream_info.channels > 8 )
 223     {
 224         msg_Err( p_dec, "This stream uses too many audio channels" );
 225         return NULL;
 226     }
 227
 228     if( !date_Get( &p_sys->end_date ) && (*pp_block)->i_pts <= VLC_TS_INVALID )
 229     {
 230         /* We've just started the stream, wait for the first PTS. */
 231         block_Release( *pp_block );
 232         return NULL;
 233     }
 234     else if( !date_Get( &p_sys->end_date ) )
 235     {
 236         /* The first PTS is as good as anything else. */
 237         p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
 238         date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
 239         date_Set( &p_sys->end_date, (*pp_block)->i_pts );
 240     }
 241
 242     block_BytestreamPush( &p_sys->bytestream, *pp_block );
 243
 244     while( 1 )
 245     {
 246         switch( p_sys->i_state )
 247         {
 248         case STATE_NOSYNC:
 249             while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
 250                    == VLC_SUCCESS )
 251             {
 252                 if( p_header[0] == 0xFF && (p_header[1] & 0xFE) == 0xF8 )
 253                 {
 254                     p_sys->i_state = STATE_SYNC;
 255                     break;
 256                 }
 257                 block_SkipByte( &p_sys->bytestream );
 258             }
 259             if( p_sys->i_state != STATE_SYNC )
 260             {
 261                 block_BytestreamFlush( &p_sys->bytestream );
 262
 263                 /* Need more data */
 264                 return NULL;
 265             }
 266
 267         case STATE_SYNC:
 268             /* New frame, set the Presentation Time Stamp */
 269             p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
 270             if( p_sys->i_pts > VLC_TS_INVALID &&
 271                 p_sys->i_pts != date_Get( &p_sys->end_date ) )
 272             {
 273                 date_Set( &p_sys->end_date, p_sys->i_pts );
 274             }
 275             p_sys->i_state = STATE_HEADER;
 276
 277         case STATE_HEADER:
 278             /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
 279             if( block_PeekBytes( &p_sys->bytestream, p_header,
 280                                  MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
 281             {
 282                 /* Need more data */
 283                 return NULL;
 284             }
 285
 286             /* Check if frame is valid and get frame info */
 287             p_sys->i_frame_length = SyncInfo( p_dec, p_header,
 288                                               &p_sys->i_channels,
 289                                               &p_sys->i_rate,
 290                                               &p_sys->i_bits_per_sample );
 291             if( !p_sys->i_frame_length )
 292             {
 293                 msg_Dbg( p_dec, "emulated sync word" );
 294                 block_SkipByte( &p_sys->bytestream );
 295                 p_sys->i_state = STATE_NOSYNC;
 296                 break;
 297             }
 298             if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
 299             {
 300                 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
 301                 const mtime_t i_end_date = date_Get( &p_sys->end_date );
 302                 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
 303                 date_Set( &p_sys->end_date, i_end_date );
 304             }
 305             p_sys->i_state = STATE_NEXT_SYNC;
 306             p_sys->i_frame_size = p_sys->b_stream_info && p_sys->stream_info.min_framesize > 0 ?
 307                                                             p_sys->stream_info.min_framesize : 1;
 308
 309         case STATE_NEXT_SYNC:
 310             /* TODO: If pp_block == NULL, flush the buffer without checking the
 311              * next sync word */
 312
 313             /* Check if next expected frame contains the sync word */
 314             while( block_PeekOffsetBytes( &p_sys->bytestream,
 315                                           p_sys->i_frame_size, p_header,
 316                                           MAX_FLAC_HEADER_SIZE )
 317                    == VLC_SUCCESS )
 318             {
 319                 if( p_header[0] == 0xFF && (p_header[1] & 0xFE) == 0xF8 )
 320                 {
 321                     /* Check if frame is valid and get frame info */
 322                     int i_frame_length =
 323                         SyncInfo( p_dec, p_header,
 324                                   &p_sys->i_channels,
 325                                   &p_sys->i_rate,
 326                                   &p_sys->i_bits_per_sample );
 327
 328                     if( i_frame_length )
 329                     {
 330                         p_sys->i_state = STATE_SEND_DATA;
 331                         break;
 332                     }
 333                 }
 334                 p_sys->i_frame_size++;
 335             }
 336
 337             if( p_sys->i_state != STATE_SEND_DATA )
 338             {
 339                 if( p_sys->b_stream_info && p_sys->stream_info.max_framesize > 0 &&
 340                     p_sys->i_frame_size > p_sys->stream_info.max_framesize )
 341                 {
 342                     block_SkipByte( &p_sys->bytestream );
 343                     p_sys->i_state = STATE_NOSYNC;
 344                     return NULL;
 345                 }
 346                 /* Need more data */
 347                 return NULL;
 348             }
 349
 350         case STATE_SEND_DATA:
 351             p_sout_block = block_Alloc( p_sys->i_frame_size );
 352
 353             /* Copy the whole frame into the buffer. When we reach this point
 354              * we already know we have enough data available. */
 355             block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
 356                             p_sys->i_frame_size );
 357
 358             /* Make sure we don't reuse the same pts twice */
 359             if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
 360                 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
 361
 362             p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
 363             p_dec->fmt_out.audio.i_physical_channels =
 364                 p_dec->fmt_out.audio.i_original_channels =
 365                     pi_channels_maps[p_sys->stream_info.channels];
 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 =
 374                 p_sout_block->i_dts = date_Get( &p_sys->end_date );
 375             date_Increment( &p_sys->end_date, p_sys->i_frame_length );
 376             p_sout_block->i_length =
 377                 date_Get( &p_sys->end_date ) - p_sout_block->i_pts;
 378
 379             return p_sout_block;
 380         }
 381     }
 382
 383     return NULL;
 384 }
 385
 386 /*****************************************************************************
 387  * SyncInfo: parse FLAC sync info
 388  *****************************************************************************/
 389 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
 390                      unsigned int * pi_channels,
 391                      unsigned int * pi_sample_rate,
 392                      unsigned int * pi_bits_per_sample )
 393 {
 394     decoder_sys_t *p_sys = p_dec->p_sys;
 395     int i_header, i_temp, i_read;
 396     unsigned i_blocksize = 0;
 397     int i_blocksize_hint = 0, i_sample_rate_hint = 0;
 398
 399     /* Check syncword */
 400     if( p_buf[0] != 0xFF || (p_buf[1] & 0xFE) != 0xF8 ) return 0;
 401
 402     /* Check there is no emulated sync code in the rest of the header */
 403     if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
 404
 405     /* Find blocksize (framelength) */
 406     switch( i_temp = p_buf[2] >> 4 )
 407     {
 408     case 0:
 409         if( p_sys->b_stream_info &&
 410             p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize )
 411             i_blocksize = p_sys->stream_info.min_blocksize;
 412         else return 0; /* We can't do anything with this */
 413         break;
 414
 415     case 1:
 416         i_blocksize = 192;
 417         break;
 418
 419     case 2:
 420     case 3:
 421     case 4:
 422     case 5:
 423         i_blocksize = 576 << (i_temp - 2);
 424         break;
 425
 426     case 6:
 427     case 7:
 428         i_blocksize_hint = i_temp;
 429         break;
 430
 431     case 8:
 432     case 9:
 433     case 10:
 434     case 11:
 435     case 12:
 436     case 13:
 437     case 14:
 438     case 15:
 439         i_blocksize = 256 << (i_temp - 8);
 440         break;
 441     }
 442     if( p_sys->b_stream_info &&
 443         ( i_blocksize < p_sys->stream_info.min_blocksize ||
 444           i_blocksize > p_sys->stream_info.max_blocksize ) )
 445         return 0;
 446
 447     /* Find samplerate */
 448     switch( i_temp = p_buf[2] & 0x0f )
 449     {
 450     case 0:
 451         if( p_sys->b_stream_info )
 452             *pi_sample_rate = p_sys->stream_info.sample_rate;
 453         else return 0; /* We can't do anything with this */
 454         break;
 455
 456     case 1:
 457         *pi_sample_rate = 88200;
 458         break;
 459
 460     case 2:
 461         *pi_sample_rate = 176400;
 462         break;
 463
 464     case 3:
 465         *pi_sample_rate = 192000;
 466         break;
 467
 468     case 4:
 469         *pi_sample_rate = 8000;
 470         break;
 471
 472     case 5:
 473         *pi_sample_rate = 16000;
 474         break;
 475
 476     case 6:
 477         *pi_sample_rate = 22050;
 478         break;
 479
 480     case 7:
 481         *pi_sample_rate = 24000;
 482         break;
 483
 484     case 8:
 485         *pi_sample_rate = 32000;
 486         break;
 487
 488     case 9:
 489         *pi_sample_rate = 44100;
 490         break;
 491
 492     case 10:
 493         *pi_sample_rate = 48000;
 494         break;
 495
 496     case 11:
 497         *pi_sample_rate = 96000;
 498         break;
 499
 500     case 12:
 501     case 13:
 502     case 14:
 503         i_sample_rate_hint = i_temp;
 504         break;
 505
 506     case 15:
 507         return 0;
 508     }
 509
 510     /* Find channels */
 511     i_temp = (unsigned)(p_buf[3] >> 4);
 512     if( i_temp & 8 )
 513     {
 514         if( ( i_temp & 7 ) >= 3 )
 515             return 0;
 516         *pi_channels = 2;
 517     }
 518     else
 519     {
 520         *pi_channels = i_temp + 1;
 521     }
 522
 523     /* Find bits per sample */
 524     switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
 525     {
 526     case 0:
 527         if( p_sys->b_stream_info )
 528             *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
 529         else
 530             return 0;
 531         break;
 532
 533     case 1:
 534         *pi_bits_per_sample = 8;
 535         break;
 536
 537     case 2:
 538         *pi_bits_per_sample = 12;
 539         break;
 540
 541     case 4:
 542         *pi_bits_per_sample = 16;
 543         break;
 544
 545     case 5:
 546         *pi_bits_per_sample = 20;
 547         break;
 548
 549     case 6:
 550         *pi_bits_per_sample = 24;
 551         break;
 552
 553     case 3:
 554     case 7:
 555         return 0;
 556         break;
 557     }
 558
 559     /* Zero padding bit */
 560     if( p_buf[3] & 0x01 ) return 0;
 561
 562     /* End of fixed size header */
 563     i_header = 4;
 564
 565     /* Check Sample/Frame number */
 566     if( read_utf8( &p_buf[i_header++], &i_read ) == INT64_C(0xffffffffffffffff) )
 567         return 0;
 568
 569     i_header += i_read;
 570
 571     /* Read blocksize */
 572     if( i_blocksize_hint )
 573     {
 574         int i_val1 = p_buf[i_header++];
 575         if( i_blocksize_hint == 7 )
 576         {
 577             int i_val2 = p_buf[i_header++];
 578             i_val1 = (i_val1 << 8) | i_val2;
 579         }
 580         i_blocksize = i_val1 + 1;
 581     }
 582
 583     /* Read sample rate */
 584     if( i_sample_rate_hint )
 585     {
 586         int i_val1 = p_buf[i_header++];
 587         if( i_sample_rate_hint != 12 )
 588         {
 589             int i_val2 = p_buf[i_header++];
 590             i_val1 = (i_val1 << 8) | i_val2;
 591         }
 592         if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
 593         else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
 594         else *pi_sample_rate = i_val1 * 10;
 595     }
 596
 597     /* Check the CRC-8 byte */
 598     if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
 599     {
 600         return 0;
 601     }
 602
 603     /* Sanity check using stream info header when possible */
 604     if( p_sys->b_stream_info )
 605     {
 606         if( i_blocksize < p_sys->stream_info.min_blocksize ||
 607             i_blocksize > p_sys->stream_info.max_blocksize )
 608             return 0;
 609         if( *pi_bits_per_sample != p_sys->stream_info.bits_per_sample )
 610             return 0;
 611         if( *pi_sample_rate != p_sys->stream_info.sample_rate )
 612             return 0;
 613     }
 614     return i_blocksize;
 615 }
 616
 617 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
 618 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
 619 {
 620     uint64_t i_result = 0;
 621     unsigned i, j;
 622
 623     if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
 624     {
 625         i_result = p_buf[0];
 626         i = 0;
 627     }
 628     else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
 629     {
 630         i_result = p_buf[0] & 0x1F;
 631         i = 1;
 632     }
 633     else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
 634     {
 635         i_result = p_buf[0] & 0x0F;
 636         i = 2;
 637     }
 638     else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
 639     {
 640         i_result = p_buf[0] & 0x07;
 641         i = 3;
 642     }
 643     else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
 644     {
 645         i_result = p_buf[0] & 0x03;
 646         i = 4;
 647     }
 648     else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
 649     {
 650         i_result = p_buf[0] & 0x01;
 651         i = 5;
 652     }
 653     else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
 654     {
 655         i_result = 0;
 656         i = 6;
 657     }
 658     else {
 659         return INT64_C(0xffffffffffffffff);
 660     }
 661
 662     for( j = 1; j <= i; j++ )
 663     {
 664         if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
 665         {
 666             return INT64_C(0xffffffffffffffff);
 667         }
 668         i_result <<= 6;
 669         i_result |= (p_buf[j] & 0x3F);
 670     }
 671
 672     *pi_read = i;
 673     return i_result;
 674 }
 675
 676 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
 677 static const uint8_t flac_crc8_table[256] = {
 678         0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
 679         0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
 680         0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
 681         0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
 682         0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
 683         0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
 684         0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
 685         0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
 686         0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
 687         0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
 688         0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
 689         0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
 690         0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
 691         0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
 692         0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
 693         0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
 694         0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
 695         0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
 696         0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
 697         0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
 698         0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
 699         0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
 700         0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
 701         0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
 702         0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
 703         0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
 704         0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
 705         0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
 706         0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
 707         0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
 708         0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
 709         0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
 710 };
 711
 712 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
 713 {
 714     uint8_t crc = 0;
 715
 716     while(len--)
 717         crc = flac_crc8_table[crc ^ *data++];
 718
 719     return crc;
 720 }
 721