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

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