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