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