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