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                 date_Init( &p_sys->end_date, p_sys->i_rate, 1 );
 289                 date_Set( &p_sys->end_date, p_sys->i_pts );
 290             }
 291             p_sys->i_state = STATE_NEXT_SYNC;
 292             p_sys->i_frame_size = p_sys->b_stream_info && p_sys->stream_info.min_framesize > 0 ?
 293                                                             p_sys->stream_info.min_framesize : 1;
 294
 295         case STATE_NEXT_SYNC:
 296             /* TODO: If pp_block == NULL, flush the buffer without checking the
 297              * next sync word */
 298
 299             /* Check if next expected frame contains the sync word */
 300             while( block_PeekOffsetBytes( &p_sys->bytestream,
 301                                           p_sys->i_frame_size, p_header,
 302                                           MAX_FLAC_HEADER_SIZE )
 303                    == VLC_SUCCESS )
 304             {
 305                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
 306                 {
 307                     /* Check if frame is valid and get frame info */
 308                     int i_frame_length =
 309                         SyncInfo( p_dec, p_header,
 310                                   &p_sys->i_channels,
 311                                   &p_sys->i_rate,
 312                                   &p_sys->i_bits_per_sample );
 313
 314                     if( i_frame_length )
 315                     {
 316                         p_sys->i_state = STATE_SEND_DATA;
 317                         break;
 318                     }
 319                 }
 320                 p_sys->i_frame_size++;
 321             }
 322
 323             if( p_sys->i_state != STATE_SEND_DATA )
 324             {
 325                 if( p_sys->b_stream_info && p_sys->stream_info.max_framesize > 0 &&
 326                     p_sys->i_frame_size > p_sys->stream_info.max_framesize )
 327                 {
 328                     block_SkipByte( &p_sys->bytestream );
 329                     p_sys->i_state = STATE_NOSYNC;
 330                     return NULL;
 331                 }
 332                 /* Need more data */
 333                 return NULL;
 334             }
 335
 336         case STATE_SEND_DATA:
 337             p_sout_block = block_New( p_dec, p_sys->i_frame_size );
 338
 339             /* Copy the whole frame into the buffer. When we reach this point
 340              * we already know we have enough data available. */
 341             block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
 342                             p_sys->i_frame_size );
 343
 344             /* Make sure we don't reuse the same pts twice */
 345             if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
 346                 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
 347
 348             /* So p_block doesn't get re-added several times */
 349             *pp_block = block_BytestreamPop( &p_sys->bytestream );
 350
 351             p_sys->i_state = STATE_NOSYNC;
 352
 353             /* Date management */
 354             p_sout_block->i_pts =
 355                 p_sout_block->i_dts = date_Get( &p_sys->end_date );
 356             date_Increment( &p_sys->end_date, p_sys->i_frame_length );
 357             p_sout_block->i_length =
 358                 date_Get( &p_sys->end_date ) - p_sout_block->i_pts;
 359
 360             return p_sout_block;
 361         }
 362     }
 363
 364     return NULL;
 365 }
 366
 367 /*****************************************************************************
 368  * SyncInfo: parse FLAC sync info
 369  *****************************************************************************/
 370 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
 371                      unsigned int * pi_channels,
 372                      unsigned int * pi_sample_rate,
 373                      int * pi_bits_per_sample )
 374 {
 375     decoder_sys_t *p_sys = p_dec->p_sys;
 376     int i_header, i_temp, i_read;
 377     unsigned i_blocksize = 0;
 378     int i_blocksize_hint = 0, i_sample_rate_hint = 0;
 379     uint64_t i_sample_number = 0;
 380
 381     bool b_variable_blocksize = ( p_sys->b_stream_info &&
 382         p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
 383     bool b_fixed_blocksize = ( p_sys->b_stream_info &&
 384         p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
 385
 386     /* Check syncword */
 387     if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
 388
 389     /* Check there is no emulated sync code in the rest of the header */
 390     if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
 391
 392     /* Find blocksize (framelength) */
 393     switch( i_temp = p_buf[2] >> 4 )
 394     {
 395     case 0:
 396         if( b_fixed_blocksize )
 397             i_blocksize = p_sys->stream_info.min_blocksize;
 398         else return 0; /* We can't do anything with this */
 399         break;
 400
 401     case 1:
 402         i_blocksize = 192;
 403         break;
 404
 405     case 2:
 406     case 3:
 407     case 4:
 408     case 5:
 409         i_blocksize = 576 << (i_temp - 2);
 410         break;
 411
 412     case 6:
 413     case 7:
 414         i_blocksize_hint = i_temp;
 415         break;
 416
 417     case 8:
 418     case 9:
 419     case 10:
 420     case 11:
 421     case 12:
 422     case 13:
 423     case 14:
 424     case 15:
 425         i_blocksize = 256 << (i_temp - 8);
 426         break;
 427     }
 428
 429     /* Find samplerate */
 430     switch( i_temp = p_buf[2] & 0x0f )
 431     {
 432     case 0:
 433         if( p_sys->b_stream_info )
 434             *pi_sample_rate = p_sys->stream_info.sample_rate;
 435         else return 0; /* We can't do anything with this */
 436         break;
 437
 438     case 1:
 439         *pi_sample_rate = 88200;
 440         break;
 441
 442     case 2:
 443         *pi_sample_rate = 176400;
 444         break;
 445
 446     case 3:
 447         *pi_sample_rate = 192000;
 448         break;
 449
 450     case 4:
 451         *pi_sample_rate = 8000;
 452         break;
 453
 454     case 5:
 455         *pi_sample_rate = 16000;
 456         break;
 457
 458     case 6:
 459         *pi_sample_rate = 22050;
 460         break;
 461
 462     case 7:
 463         *pi_sample_rate = 24000;
 464         break;
 465
 466     case 8:
 467         *pi_sample_rate = 32000;
 468         break;
 469
 470     case 9:
 471         *pi_sample_rate = 44100;
 472         break;
 473
 474     case 10:
 475         *pi_sample_rate = 48000;
 476         break;
 477
 478     case 11:
 479         *pi_sample_rate = 96000;
 480         break;
 481
 482     case 12:
 483     case 13:
 484     case 14:
 485         i_sample_rate_hint = i_temp;
 486         break;
 487
 488     case 15:
 489         return 0;
 490     }
 491
 492     /* Find channels */
 493     i_temp = (unsigned)(p_buf[3] >> 4);
 494     if( i_temp & 8 )
 495     {
 496         if( ( i_temp & 7 ) >= 3 )
 497             return 0;
 498         *pi_channels = 2;
 499     }
 500     else
 501     {
 502         *pi_channels = i_temp + 1;
 503     }
 504
 505     /* Find bits per sample */
 506     switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
 507     {
 508     case 0:
 509         if( p_sys->b_stream_info )
 510             *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
 511         else
 512             return 0;
 513         break;
 514
 515     case 1:
 516         *pi_bits_per_sample = 8;
 517         break;
 518
 519     case 2:
 520         *pi_bits_per_sample = 12;
 521         break;
 522
 523     case 4:
 524         *pi_bits_per_sample = 16;
 525         break;
 526
 527     case 5:
 528         *pi_bits_per_sample = 20;
 529         break;
 530
 531     case 6:
 532         *pi_bits_per_sample = 24;
 533         break;
 534
 535     case 3:
 536     case 7:
 537         return 0;
 538         break;
 539     }
 540
 541     /* Zero padding bit */
 542     if( p_buf[3] & 0x01 ) return 0;
 543
 544     /* End of fixed size header */
 545     i_header = 4;
 546
 547     /* Find Sample/Frame number */
 548     if( i_blocksize_hint && b_variable_blocksize )
 549     {
 550         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
 551         if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
 552     }
 553     else
 554     {
 555         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
 556         if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
 557
 558         if( p_sys->b_stream_info )
 559             i_sample_number *= p_sys->stream_info.min_blocksize;
 560     }
 561
 562     i_header += i_read;
 563
 564     /* Read blocksize */
 565     if( i_blocksize_hint )
 566     {
 567         int i_val1 = p_buf[i_header++];
 568         if( i_blocksize_hint == 7 )
 569         {
 570             int i_val2 = p_buf[i_header++];
 571             i_val1 = (i_val1 << 8) | i_val2;
 572         }
 573         i_blocksize = i_val1 + 1;
 574     }
 575
 576     /* Read sample rate */
 577     if( i_sample_rate_hint )
 578     {
 579         int i_val1 = p_buf[i_header++];
 580         if( i_sample_rate_hint != 12 )
 581         {
 582             int i_val2 = p_buf[i_header++];
 583             i_val1 = (i_val1 << 8) | i_val2;
 584         }
 585         if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
 586         else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
 587         else *pi_sample_rate = i_val1 * 10;
 588     }
 589
 590     /* Check the CRC-8 byte */
 591     if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
 592     {
 593         return 0;
 594     }
 595
 596     /* Sanity check using stream info header when possible */
 597     if( p_sys->b_stream_info )
 598     {
 599         if( i_blocksize < p_sys->stream_info.min_blocksize ||
 600             i_blocksize > p_sys->stream_info.max_blocksize )
 601             return 0;
 602     }
 603     return i_blocksize;
 604 }
 605
 606 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
 607 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
 608 {
 609     uint64_t i_result = 0;
 610     unsigned i, j;
 611
 612     if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
 613     {
 614         i_result = p_buf[0];
 615         i = 0;
 616     }
 617     else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
 618     {
 619         i_result = p_buf[0] & 0x1F;
 620         i = 1;
 621     }
 622     else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
 623     {
 624         i_result = p_buf[0] & 0x0F;
 625         i = 2;
 626     }
 627     else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
 628     {
 629         i_result = p_buf[0] & 0x07;
 630         i = 3;
 631     }
 632     else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
 633     {
 634         i_result = p_buf[0] & 0x03;
 635         i = 4;
 636     }
 637     else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
 638     {
 639         i_result = p_buf[0] & 0x01;
 640         i = 5;
 641     }
 642     else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
 643     {
 644         i_result = 0;
 645         i = 6;
 646     }
 647     else {
 648         return INT64_C(0xffffffffffffffff);
 649     }
 650
 651     for( j = 1; j <= i; j++ )
 652     {
 653         if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
 654         {
 655             return INT64_C(0xffffffffffffffff);
 656         }
 657         i_result <<= 6;
 658         i_result |= (p_buf[j] & 0x3F);
 659     }
 660
 661     *pi_read = i;
 662     return i_result;
 663 }
 664
 665 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
 666 static const uint8_t flac_crc8_table[256] = {
 667         0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
 668         0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
 669         0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
 670         0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
 671         0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
 672         0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
 673         0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
 674         0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
 675         0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
 676         0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
 677         0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
 678         0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
 679         0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
 680         0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
 681         0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
 682         0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
 683         0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
 684         0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
 685         0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
 686         0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
 687         0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
 688         0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
 689         0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
 690         0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
 691         0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
 692         0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
 693         0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
 694         0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
 695         0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
 696         0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
 697         0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
 698         0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
 699 };
 700
 701 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
 702 {
 703     uint8_t crc = 0;
 704
 705     while(len--)
 706         crc = flac_crc8_table[crc ^ *data++];
 707
 708     return crc;
 709 }
 710