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

   1 /*****************************************************************************
   2  * flac.c: flac packetizer module.
   3  *****************************************************************************
   4  * Copyright (C) 1999-2001 VLC authors and VideoLAN
   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 it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * 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 #define MIN_FLAC_FRAME_SIZE ((48+(8 + 4 + 1*4)+16)/8)
  60 struct decoder_sys_t
  61 {
  62     /*
  63      * Input properties
  64      */
  65     int i_state;
  66
  67     block_bytestream_t bytestream;
  68
  69     /*
  70      * FLAC properties
  71      */
  72     struct
  73     {
  74         unsigned min_blocksize, max_blocksize;
  75         unsigned min_framesize, max_framesize;
  76         unsigned sample_rate;
  77         unsigned channels;
  78         unsigned bits_per_sample;
  79
  80     } stream_info;
  81     bool b_stream_info;
  82
  83     /*
  84      * Common properties
  85      */
  86     mtime_t i_pts;
  87     mtime_t i_duration;
  88
  89     int i_frame_length;
  90     size_t i_frame_size;
  91     uint16_t crc;
  92     unsigned int i_rate, i_channels, i_bits_per_sample;
  93     size_t i_buf;
  94     uint8_t *p_buf;
  95 };
  96
  97 static const int pi_channels_maps[9] =
  98 {
  99     0,
 100     AOUT_CHAN_CENTER,
 101     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
 102     AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
 103     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
 104      | AOUT_CHAN_REARRIGHT,
 105     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 106      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
 107     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 108      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE,
 109     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 110      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_MIDDLELEFT
 111      | AOUT_CHAN_MIDDLERIGHT,
 112     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER | AOUT_CHAN_REARLEFT
 113      | AOUT_CHAN_REARRIGHT | AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT
 114      | AOUT_CHAN_LFE
 115 };
 116
 117
 118 /*****************************************************************************
 119  * ProcessHeader: process Flac header.
 120  *****************************************************************************/
 121 static void ProcessHeader(decoder_t *p_dec)
 122 {
 123     decoder_sys_t *p_sys = p_dec->p_sys;
 124
 125     bs_t bs;
 126     int i_extra = p_dec->fmt_in.i_extra;
 127     char *p_extra = p_dec->fmt_in.p_extra;
 128
 129     if (i_extra > 8 && !memcmp(p_extra, "fLaC", 4)) {
 130         i_extra -= 8;
 131         p_extra += 8;
 132     }
 133
 134     if (p_dec->fmt_in.i_extra < 14)
 135         return;
 136
 137     bs_init(&bs, p_extra, i_extra);
 138
 139     p_sys->stream_info.min_blocksize = bs_read(&bs, 16);
 140     p_sys->stream_info.min_blocksize =
 141             __MIN( __MAX( p_sys->stream_info.min_blocksize, 16 ), 65535 );
 142     p_sys->stream_info.max_blocksize = bs_read(&bs, 16);
 143     p_sys->stream_info.max_blocksize =
 144                 __MAX( __MIN( p_sys->stream_info.max_blocksize, 65535 ), 16 );
 145
 146     p_sys->stream_info.min_framesize = bs_read(&bs, 24);
 147     p_sys->stream_info.min_framesize =
 148             __MAX( p_sys->stream_info.min_framesize, MIN_FLAC_FRAME_SIZE );
 149     p_sys->stream_info.max_framesize = bs_read(&bs, 24);
 150
 151     p_sys->stream_info.sample_rate = bs_read(&bs, 20);
 152     p_sys->stream_info.channels = bs_read(&bs, 3) + 1;
 153     p_sys->stream_info.bits_per_sample = bs_read(&bs, 5) + 1;
 154
 155     p_sys->b_stream_info = true;
 156
 157     p_dec->fmt_out.i_extra = i_extra;
 158     free(p_dec->fmt_out.p_extra);
 159     p_dec->fmt_out.p_extra = malloc(i_extra);
 160     if (p_dec->fmt_out.p_extra)
 161         memcpy(p_dec->fmt_out.p_extra, p_extra, i_extra);
 162     else
 163         p_dec->fmt_out.i_extra = 0;
 164 }
 165
 166 /* Will return INT64_MAX for an invalid utf-8 sequence */
 167 static int64_t read_utf8(const uint8_t *p_buf, int *pi_read)
 168 {
 169     /* Max coding bits is 56 - 8 */
 170     /* Value max precision is 36 bits */
 171     int64_t i_result = 0;
 172     unsigned i;
 173
 174     if (!(p_buf[0] & 0x80)) { /* 0xxxxxxx */
 175         i_result = p_buf[0];
 176         i = 0;
 177     } else if (p_buf[0] & 0xC0 && !(p_buf[0] & 0x20)) { /* 110xxxxx */
 178         i_result = p_buf[0] & 0x1F;
 179         i = 1;
 180     } else if (p_buf[0] & 0xE0 && !(p_buf[0] & 0x10)) { /* 1110xxxx */
 181         i_result = p_buf[0] & 0x0F;
 182         i = 2;
 183     } else if (p_buf[0] & 0xF0 && !(p_buf[0] & 0x08)) { /* 11110xxx */
 184         i_result = p_buf[0] & 0x07;
 185         i = 3;
 186     } else if (p_buf[0] & 0xF8 && !(p_buf[0] & 0x04)) { /* 111110xx */
 187         i_result = p_buf[0] & 0x03;
 188         i = 4;
 189     } else if (p_buf[0] & 0xFC && !(p_buf[0] & 0x02)) { /* 1111110x */
 190         i_result = p_buf[0] & 0x01;
 191         i = 5;
 192     } else if (p_buf[0] & 0xFE && !(p_buf[0] & 0x01)) { /* 11111110 */
 193         i_result = 0;
 194         i = 6;
 195     } else {
 196         return INT64_MAX;
 197     }
 198
 199     for (unsigned j = 1; j <= i; j++) {
 200         if (!(p_buf[j] & 0x80) || (p_buf[j] & 0x40)) { /* 10xxxxxx */
 201             return INT64_MAX;
 202         }
 203         i_result <<= 6;
 204         i_result |= (p_buf[j] & 0x3F);
 205     }
 206
 207     *pi_read = i;
 208     return i_result;
 209 }
 210
 211 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
 212 static const uint8_t flac_crc8_table[256] = {
 213         0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
 214         0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
 215         0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
 216         0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
 217         0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
 218         0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
 219         0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
 220         0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
 221         0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
 222         0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
 223         0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
 224         0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
 225         0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
 226         0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
 227         0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
 228         0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
 229         0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
 230         0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
 231         0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
 232         0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
 233         0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
 234         0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
 235         0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
 236         0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
 237         0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
 238         0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
 239         0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
 240         0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
 241         0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
 242         0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
 243         0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
 244         0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
 245 };
 246
 247 static uint8_t flac_crc8(const uint8_t *data, unsigned len)
 248 {
 249     uint8_t crc = 0;
 250
 251     while (len--)
 252         crc = flac_crc8_table[crc ^ *data++];
 253
 254     return crc;
 255 }
 256
 257 /* CRC-16, poly = x^16 + x^15 + x^2 + x^0, init = 0 */
 258 static const uint16_t flac_crc16_table[256] = {
 259     0x0000,  0x8005,  0x800f,  0x000a,  0x801b,  0x001e,  0x0014,  0x8011,
 260     0x8033,  0x0036,  0x003c,  0x8039,  0x0028,  0x802d,  0x8027,  0x0022,
 261     0x8063,  0x0066,  0x006c,  0x8069,  0x0078,  0x807d,  0x8077,  0x0072,
 262     0x0050,  0x8055,  0x805f,  0x005a,  0x804b,  0x004e,  0x0044,  0x8041,
 263     0x80c3,  0x00c6,  0x00cc,  0x80c9,  0x00d8,  0x80dd,  0x80d7,  0x00d2,
 264     0x00f0,  0x80f5,  0x80ff,  0x00fa,  0x80eb,  0x00ee,  0x00e4,  0x80e1,
 265     0x00a0,  0x80a5,  0x80af,  0x00aa,  0x80bb,  0x00be,  0x00b4,  0x80b1,
 266     0x8093,  0x0096,  0x009c,  0x8099,  0x0088,  0x808d,  0x8087,  0x0082,
 267     0x8183,  0x0186,  0x018c,  0x8189,  0x0198,  0x819d,  0x8197,  0x0192,
 268     0x01b0,  0x81b5,  0x81bf,  0x01ba,  0x81ab,  0x01ae,  0x01a4,  0x81a1,
 269     0x01e0,  0x81e5,  0x81ef,  0x01ea,  0x81fb,  0x01fe,  0x01f4,  0x81f1,
 270     0x81d3,  0x01d6,  0x01dc,  0x81d9,  0x01c8,  0x81cd,  0x81c7,  0x01c2,
 271     0x0140,  0x8145,  0x814f,  0x014a,  0x815b,  0x015e,  0x0154,  0x8151,
 272     0x8173,  0x0176,  0x017c,  0x8179,  0x0168,  0x816d,  0x8167,  0x0162,
 273     0x8123,  0x0126,  0x012c,  0x8129,  0x0138,  0x813d,  0x8137,  0x0132,
 274     0x0110,  0x8115,  0x811f,  0x011a,  0x810b,  0x010e,  0x0104,  0x8101,
 275     0x8303,  0x0306,  0x030c,  0x8309,  0x0318,  0x831d,  0x8317,  0x0312,
 276     0x0330,  0x8335,  0x833f,  0x033a,  0x832b,  0x032e,  0x0324,  0x8321,
 277     0x0360,  0x8365,  0x836f,  0x036a,  0x837b,  0x037e,  0x0374,  0x8371,
 278     0x8353,  0x0356,  0x035c,  0x8359,  0x0348,  0x834d,  0x8347,  0x0342,
 279     0x03c0,  0x83c5,  0x83cf,  0x03ca,  0x83db,  0x03de,  0x03d4,  0x83d1,
 280     0x83f3,  0x03f6,  0x03fc,  0x83f9,  0x03e8,  0x83ed,  0x83e7,  0x03e2,
 281     0x83a3,  0x03a6,  0x03ac,  0x83a9,  0x03b8,  0x83bd,  0x83b7,  0x03b2,
 282     0x0390,  0x8395,  0x839f,  0x039a,  0x838b,  0x038e,  0x0384,  0x8381,
 283     0x0280,  0x8285,  0x828f,  0x028a,  0x829b,  0x029e,  0x0294,  0x8291,
 284     0x82b3,  0x02b6,  0x02bc,  0x82b9,  0x02a8,  0x82ad,  0x82a7,  0x02a2,
 285     0x82e3,  0x02e6,  0x02ec,  0x82e9,  0x02f8,  0x82fd,  0x82f7,  0x02f2,
 286     0x02d0,  0x82d5,  0x82df,  0x02da,  0x82cb,  0x02ce,  0x02c4,  0x82c1,
 287     0x8243,  0x0246,  0x024c,  0x8249,  0x0258,  0x825d,  0x8257,  0x0252,
 288     0x0270,  0x8275,  0x827f,  0x027a,  0x826b,  0x026e,  0x0264,  0x8261,
 289     0x0220,  0x8225,  0x822f,  0x022a,  0x823b,  0x023e,  0x0234,  0x8231,
 290     0x8213,  0x0216,  0x021c,  0x8219,  0x0208,  0x820d,  0x8207,  0x0202
 291 };
 292
 293 static uint16_t flac_crc16(uint16_t crc, uint8_t byte)
 294 {
 295     return (crc << 8) ^ flac_crc16_table[(crc >> 8) ^ byte];
 296 }
 297
 298 /* Gives the previous CRC value, before hashing last_byte through it */
 299 static uint16_t flac_crc16_undo(uint16_t crc, const uint8_t last_byte)
 300 {
 301     /*
 302      * Given a byte b, gives a position X in flac_crc16_table, such as:
 303      *      flac_crc16_rev_table[flac_crc16_table[X] & 0xff] == X
 304      * This works because flac_crc16_table[i] & 0xff yields 256 unique values.
 305      */
 306     static const uint8_t flac_crc16_rev_table[256] = {
 307         0x00, 0x7f, 0xff, 0x80, 0x7e, 0x01, 0x81, 0xfe,
 308         0xfc, 0x83, 0x03, 0x7c, 0x82, 0xfd, 0x7d, 0x02,
 309         0x78, 0x07, 0x87, 0xf8, 0x06, 0x79, 0xf9, 0x86,
 310         0x84, 0xfb, 0x7b, 0x04, 0xfa, 0x85, 0x05, 0x7a,
 311         0xf0, 0x8f, 0x0f, 0x70, 0x8e, 0xf1, 0x71, 0x0e,
 312         0x0c, 0x73, 0xf3, 0x8c, 0x72, 0x0d, 0x8d, 0xf2,
 313         0x88, 0xf7, 0x77, 0x08, 0xf6, 0x89, 0x09, 0x76,
 314         0x74, 0x0b, 0x8b, 0xf4, 0x0a, 0x75, 0xf5, 0x8a,
 315         0x60, 0x1f, 0x9f, 0xe0, 0x1e, 0x61, 0xe1, 0x9e,
 316         0x9c, 0xe3, 0x63, 0x1c, 0xe2, 0x9d, 0x1d, 0x62,
 317         0x18, 0x67, 0xe7, 0x98, 0x66, 0x19, 0x99, 0xe6,
 318         0xe4, 0x9b, 0x1b, 0x64, 0x9a, 0xe5, 0x65, 0x1a,
 319         0x90, 0xef, 0x6f, 0x10, 0xee, 0x91, 0x11, 0x6e,
 320         0x6c, 0x13, 0x93, 0xec, 0x12, 0x6d, 0xed, 0x92,
 321         0xe8, 0x97, 0x17, 0x68, 0x96, 0xe9, 0x69, 0x16,
 322         0x14, 0x6b, 0xeb, 0x94, 0x6a, 0x15, 0x95, 0xea,
 323         0xc0, 0xbf, 0x3f, 0x40, 0xbe, 0xc1, 0x41, 0x3e,
 324         0x3c, 0x43, 0xc3, 0xbc, 0x42, 0x3d, 0xbd, 0xc2,
 325         0xb8, 0xc7, 0x47, 0x38, 0xc6, 0xb9, 0x39, 0x46,
 326         0x44, 0x3b, 0xbb, 0xc4, 0x3a, 0x45, 0xc5, 0xba,
 327         0x30, 0x4f, 0xcf, 0xb0, 0x4e, 0x31, 0xb1, 0xce,
 328         0xcc, 0xb3, 0x33, 0x4c, 0xb2, 0xcd, 0x4d, 0x32,
 329         0x48, 0x37, 0xb7, 0xc8, 0x36, 0x49, 0xc9, 0xb6,
 330         0xb4, 0xcb, 0x4b, 0x34, 0xca, 0xb5, 0x35, 0x4a,
 331         0xa0, 0xdf, 0x5f, 0x20, 0xde, 0xa1, 0x21, 0x5e,
 332         0x5c, 0x23, 0xa3, 0xdc, 0x22, 0x5d, 0xdd, 0xa2,
 333         0xd8, 0xa7, 0x27, 0x58, 0xa6, 0xd9, 0x59, 0x26,
 334         0x24, 0x5b, 0xdb, 0xa4, 0x5a, 0x25, 0xa5, 0xda,
 335         0x50, 0x2f, 0xaf, 0xd0, 0x2e, 0x51, 0xd1, 0xae,
 336         0xac, 0xd3, 0x53, 0x2c, 0xd2, 0xad, 0x2d, 0x52,
 337         0x28, 0x57, 0xd7, 0xa8, 0x56, 0x29, 0xa9, 0xd6,
 338         0xd4, 0xab, 0x2b, 0x54, 0xaa, 0xd5, 0x55, 0x2a,
 339     };
 340     uint8_t idx = flac_crc16_rev_table[crc & 0xff];
 341     return ((idx ^ last_byte) << 8) | ((crc ^ flac_crc16_table[idx]) >> 8);
 342 }
 343
 344 /*****************************************************************************
 345  * SyncInfo: parse FLAC sync info
 346  *****************************************************************************/
 347 static int SyncInfo(decoder_t *p_dec, uint8_t *p_buf,
 348                      unsigned int * pi_channels,
 349                      unsigned int * pi_sample_rate,
 350                      unsigned int * pi_bits_per_sample,
 351                      mtime_t * pi_pts,
 352                      mtime_t * pi_duration )
 353 {
 354     decoder_sys_t *p_sys = p_dec->p_sys;
 355
 356     /* Check syncword */
 357     if (p_buf[0] != 0xFF || (p_buf[1] & 0xFE) != 0xF8)
 358         return 0;
 359
 360     /* Check there is no emulated sync code in the rest of the header */
 361     if (p_buf[2] == 0xff || p_buf[3] == 0xFF)
 362         return 0;
 363
 364     /* Find blocksize (framelength) */
 365     int blocksize_hint = 0;
 366     unsigned blocksize = p_buf[2] >> 4;
 367     if (blocksize >= 8) {
 368         blocksize = 256 << (blocksize - 8);
 369     } else if (blocksize == 0) { /* value 0 is reserved */
 370         if (p_sys->b_stream_info &&
 371             p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize)
 372             blocksize = p_sys->stream_info.min_blocksize;
 373         else
 374             return 0; /* We can't do anything with this */
 375     } else if (blocksize == 1) {
 376         blocksize = 192;
 377     } else if (blocksize == 6 || blocksize == 7) {
 378         blocksize_hint = blocksize;
 379         blocksize = 0;
 380     } else /* 2, 3, 4, 5 */ {
 381         blocksize = 576 << (blocksize - 2);
 382     }
 383
 384     if (p_sys->b_stream_info && !blocksize_hint )
 385         if (blocksize < p_sys->stream_info.min_blocksize ||
 386             blocksize > p_sys->stream_info.max_blocksize)
 387             return 0;
 388
 389     /* Find samplerate */
 390     int samplerate_hint = p_buf[2] & 0xf;;
 391     unsigned int samplerate;
 392     if (samplerate_hint == 0) {
 393         if (p_sys->b_stream_info)
 394             samplerate = p_sys->stream_info.sample_rate;
 395         else
 396             return 0; /* We can't do anything with this */
 397     } else if (samplerate_hint == 15) {
 398         return 0; /* invalid */
 399     } else if (samplerate_hint < 12) {
 400         static const int16_t flac_samplerate[12] = {
 401             0,    8820, 17640, 19200,
 402             800,  1600, 2205,  2400,
 403             3200, 4410, 4800,  9600,
 404         };
 405         samplerate = flac_samplerate[samplerate_hint] * 10;
 406     } else {
 407         samplerate = 0; /* at end of header */
 408     }
 409
 410     /* Find channels */
 411     unsigned channels = p_buf[3] >> 4;
 412     if (channels >= 8) {
 413         if (channels >= 11) /* reserved */
 414             return 0;
 415         channels = 2;
 416     } else
 417         channels++;
 418
 419
 420     /* Find bits per sample */
 421     static const int8_t flac_bits_per_sample[8] = {
 422         0, 8, 12, -1, 16, 20, 24, -1
 423     };
 424     int bits_per_sample = flac_bits_per_sample[(p_buf[3] & 0x0e) >> 1];
 425     if (bits_per_sample == 0) {
 426         if (p_sys->b_stream_info)
 427             bits_per_sample = p_sys->stream_info.bits_per_sample;
 428         else
 429             return 0;
 430     } else if (bits_per_sample < 0)
 431         return 0;
 432
 433
 434     /* reserved for future use */
 435     if (p_buf[3] & 0x01)
 436         return 0;
 437
 438     /* End of fixed size header */
 439     int i_header = 4;
 440
 441     /* Check Sample/Frame number */
 442     int i_read;
 443     int64_t i_fsnumber = read_utf8(&p_buf[i_header++], &i_read);
 444     if ( i_fsnumber == INT64_MAX )
 445         return 0;
 446
 447     i_header += i_read;
 448
 449     /* Read blocksize */
 450     if (blocksize_hint) {
 451         blocksize = p_buf[i_header++];
 452         if (blocksize_hint == 7) {
 453             blocksize <<= 8;
 454             blocksize |= p_buf[i_header++];
 455         }
 456         blocksize++;
 457     }
 458
 459     /* Read sample rate */
 460     if (samplerate == 0) {
 461         samplerate = p_buf[i_header++];
 462         if (samplerate_hint != 12) { /* 16 bits */
 463             samplerate <<= 8;
 464             samplerate |= p_buf[i_header++];
 465         }
 466
 467         if (samplerate_hint == 12)
 468             samplerate *= 1000;
 469         else if (samplerate_hint == 14)
 470             samplerate *= 10;
 471     }
 472
 473     if ( !samplerate )
 474         return 0;
 475
 476     /* Check the CRC-8 byte */
 477     if (flac_crc8(p_buf, i_header) != p_buf[i_header])
 478         return 0;
 479
 480     /* Sanity check using stream info header when possible */
 481     if (p_sys->b_stream_info) {
 482         if (blocksize < p_sys->stream_info.min_blocksize ||
 483             blocksize > p_sys->stream_info.max_blocksize)
 484             return 0;
 485         if ((unsigned)bits_per_sample != p_sys->stream_info.bits_per_sample)
 486             return 0;
 487         if (samplerate != p_sys->stream_info.sample_rate)
 488             return 0;
 489     }
 490
 491     if( pi_pts )
 492     {
 493         *pi_pts = VLC_TS_0;
 494         if ( (p_buf[1] & 0x01) == 0  ) /* Fixed blocksize stream / Frames */
 495             *pi_pts += CLOCK_FREQ * blocksize * i_fsnumber / samplerate;
 496         else /* Variable blocksize stream / Samples */
 497             *pi_pts += CLOCK_FREQ * i_fsnumber / samplerate;
 498     }
 499
 500     if ( pi_duration )
 501         *pi_duration = CLOCK_FREQ * blocksize / samplerate;
 502
 503     *pi_bits_per_sample = bits_per_sample;
 504     *pi_sample_rate = samplerate;
 505     *pi_channels = channels;
 506
 507     return blocksize;
 508 }
 509
 510 /* */
 511 static block_t *Packetize(decoder_t *p_dec, block_t **pp_block)
 512 {
 513     decoder_sys_t *p_sys = p_dec->p_sys;
 514     uint8_t p_header[MAX_FLAC_HEADER_SIZE];
 515     block_t *out, *in = NULL;
 516
 517     if ( pp_block && *pp_block)
 518     {
 519         in = *pp_block;
 520
 521         if (in->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED)) {
 522             if (in->i_flags&BLOCK_FLAG_CORRUPTED) {
 523                 p_sys->i_state = STATE_NOSYNC;
 524                 block_BytestreamEmpty(&p_sys->bytestream);
 525             }
 526             block_Release(*pp_block);
 527             return NULL;
 528         }
 529     }
 530
 531     if (!p_sys->b_stream_info)
 532         ProcessHeader(p_dec);
 533
 534     if (p_sys->stream_info.channels > 8) {
 535         msg_Err(p_dec, "This stream uses too many audio channels (%d > 8)",
 536             p_sys->stream_info.channels);
 537         return NULL;
 538     }
 539
 540     if ( p_sys->i_pts <= VLC_TS_INVALID )
 541     {
 542         if ( in && in->i_pts == p_sys->i_pts )
 543         {
 544             /* We've just started the stream, wait for the first PTS. */
 545             block_Release(in);
 546             return NULL;
 547         }
 548         p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
 549     }
 550
 551     if ( in )
 552         block_BytestreamPush(&p_sys->bytestream, in);
 553
 554     while (1) switch (p_sys->i_state) {
 555     case STATE_NOSYNC:
 556         while (!block_PeekBytes(&p_sys->bytestream, p_header, 2)) {
 557             if (p_header[0] == 0xFF && (p_header[1] & 0xFE) == 0xF8) {
 558                 p_sys->i_state = STATE_SYNC;
 559                 break;
 560             }
 561             block_SkipByte(&p_sys->bytestream);
 562         }
 563         if (p_sys->i_state != STATE_SYNC) {
 564             block_BytestreamFlush(&p_sys->bytestream);
 565             return NULL; /* Need more data */
 566         }
 567
 568     case STATE_SYNC:
 569         /* Sync state is unverified until we have read frame header and checked CRC
 570            Once validated, we'll send data from NEXT_SYNC state where we'll
 571            compute frame size */
 572         p_sys->i_state = STATE_HEADER;
 573
 574     case STATE_HEADER:
 575         /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
 576         if (block_PeekBytes(&p_sys->bytestream, p_header, MAX_FLAC_HEADER_SIZE))
 577             return NULL; /* Need more data */
 578
 579         /* Check if frame is valid and get frame info */
 580         p_sys->i_frame_length = SyncInfo(p_dec, p_header,
 581                                           &p_sys->i_channels,
 582                                           &p_sys->i_rate,
 583                                           &p_sys->i_bits_per_sample,
 584                                           &p_sys->i_pts,
 585                                           &p_sys->i_duration );
 586         if (!p_sys->i_frame_length) {
 587             msg_Dbg(p_dec, "emulated sync word");
 588             block_SkipByte(&p_sys->bytestream);
 589             p_sys->i_state = STATE_NOSYNC;
 590             break;
 591         }
 592         if (p_sys->i_rate != p_dec->fmt_out.audio.i_rate) {
 593             p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
 594         }
 595         p_sys->i_state = STATE_NEXT_SYNC;
 596         p_sys->i_frame_size = ( p_sys->b_stream_info ) ? p_sys->stream_info.min_framesize :
 597                                                          MIN_FLAC_FRAME_SIZE;
 598
 599         /* We have to read until next frame sync code to compute current frame size
 600          * from that boundary.
 601          * The confusing part below is that sync code needs to be verified in case
 602          * it would appear in data, so we also need to check next frame header CRC
 603          */
 604     case STATE_NEXT_SYNC:
 605     {
 606         /* Calculate the initial CRC for the minimal frame size,
 607          * We'll update it as we look for the next start code. */
 608         if (p_sys->i_buf < p_sys->i_frame_size)
 609         {
 610             uint8_t *p_buf = realloc(p_sys->p_buf, p_sys->i_frame_size);
 611             if (!p_buf)
 612                 return NULL;
 613             p_sys->p_buf = p_buf;
 614             p_sys->i_buf = p_sys->i_frame_size;
 615         }
 616
 617         if (block_PeekOffsetBytes(&p_sys->bytestream, 0, p_sys->p_buf, p_sys->i_frame_size)) {
 618             return NULL;
 619         }
 620
 621         uint16_t crc = 0;
 622         for (unsigned i = 0; i < p_sys->i_frame_size; i++)
 623             crc = flac_crc16(crc, p_sys->p_buf[i]);
 624         p_sys->crc = crc;
 625
 626         /* Check if next expected frame contains the sync word */
 627         while (!block_PeekOffsetBytes(&p_sys->bytestream, p_sys->i_frame_size,
 628                     p_header, MAX_FLAC_HEADER_SIZE)) {
 629             if (p_header[0] == 0xFF && (p_header[1] & 0xFE) == 0xF8) {
 630                 /* Check if frame is valid and get frame info */
 631                 int i_frame_length =
 632                     SyncInfo(p_dec, p_header,
 633                               &p_sys->i_channels,
 634                               &p_sys->i_rate,
 635                               &p_sys->i_bits_per_sample,
 636                               NULL, NULL );
 637
 638                 if (i_frame_length) {
 639                     uint8_t crc_bytes[2];
 640                     block_PeekOffsetBytes(&p_sys->bytestream,
 641                         p_sys->i_frame_size - 2, crc_bytes, 2);
 642                     /* Get the frame CRC */
 643                     uint16_t stream_crc = (crc_bytes[0] << 8) | crc_bytes[1];
 644                     /* Calculate the frame CRC: remove the last 2 bytes */
 645                     uint16_t crc = flac_crc16_undo(p_sys->crc, crc_bytes[1]);
 646                              crc = flac_crc16_undo(crc,        crc_bytes[0]);
 647                     if (stream_crc != crc) {
 648                         msg_Warn(p_dec, "Bad CRC for frame size %zu: 0x%x != 0x%x",
 649                             p_sys->i_frame_size, crc, stream_crc);
 650                         block_SkipByte(&p_sys->bytestream);
 651                         p_sys->i_state = STATE_NOSYNC;
 652                     } else {
 653                         p_sys->i_state = STATE_SEND_DATA;
 654                         p_sys->crc = 0;
 655                         break;
 656                     }
 657                 }
 658             }
 659             p_sys->crc = flac_crc16(p_sys->crc, p_header[0]); /* update CRC */
 660             p_sys->i_frame_size++;
 661         }
 662
 663         if (p_sys->i_state != STATE_SEND_DATA) {
 664             if (p_sys->b_stream_info && p_sys->stream_info.max_framesize > 0 &&
 665                 p_sys->i_frame_size > p_sys->stream_info.max_framesize) {
 666                 block_SkipByte(&p_sys->bytestream);
 667                 msg_Warn(p_dec, "Frame is too big (%zu > %d), couldn't find start code",
 668                         p_sys->i_frame_size, p_sys->stream_info.max_framesize);
 669                 p_sys->i_state = STATE_NOSYNC;
 670                 return NULL;
 671             }
 672
 673             if ( !in )
 674             {
 675                 /* There's no following frame, so we need to read current
 676                  * data until the frame footer matches (crc16) == stream crc.
 677                  * In the worst case, if crc might be a false positive and data
 678                  * will be truncated. */
 679                 uint8_t crc_bytes[2];
 680                 if ( !block_PeekOffsetBytes(&p_sys->bytestream,
 681                                     p_sys->i_frame_size - 2, crc_bytes, 2) )
 682                 {
 683                     while ( true )
 684                     {
 685                         /* Read the frame CRC */
 686                         uint16_t stream_crc = (crc_bytes[0] << 8) | crc_bytes[1];
 687                         /* Calculate the frame CRC: remove the last 2 bytes */
 688                         uint16_t crc = flac_crc16_undo(p_sys->crc, crc_bytes[1]);
 689                                  crc = flac_crc16_undo(crc,        crc_bytes[0]);
 690                         if (stream_crc == crc)
 691                         {
 692                             p_sys->i_state = STATE_SEND_DATA;
 693                             break;
 694                         }
 695                         p_sys->i_frame_size++;
 696                         if ( block_PeekOffsetBytes(&p_sys->bytestream,
 697                                                    p_sys->i_frame_size - 2, crc_bytes, 2) )
 698                             break;
 699                         /* Update current crc */
 700                         p_sys->crc = flac_crc16(p_sys->crc, crc_bytes[1]);
 701                     }
 702                 }
 703
 704                 if ( p_sys->i_state != STATE_SEND_DATA )
 705                     return NULL;
 706             }
 707             else
 708             {
 709                 /* Need more data */
 710                 return NULL;
 711             }
 712         }
 713     }
 714     case STATE_SEND_DATA:
 715         out = block_Alloc(p_sys->i_frame_size);
 716
 717         /* Copy the whole frame into the buffer. When we reach this point
 718          * we already know we have enough data available. */
 719         block_GetBytes(&p_sys->bytestream, out->p_buffer,
 720                         p_sys->i_frame_size);
 721
 722         p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
 723         p_dec->fmt_out.audio.i_physical_channels =
 724             p_dec->fmt_out.audio.i_original_channels =
 725                 pi_channels_maps[p_sys->stream_info.channels];
 726
 727         /* So p_block doesn't get re-added several times */
 728         if ( in )
 729             *pp_block = block_BytestreamPop(&p_sys->bytestream);
 730         else
 731             block_BytestreamFlush(&p_sys->bytestream);
 732
 733         p_sys->i_state = STATE_NOSYNC;
 734
 735         out->i_dts = out->i_pts = p_sys->i_pts;
 736         out->i_length = p_sys->i_duration;
 737
 738         return out;
 739     }
 740
 741     return NULL;
 742 }
 743
 744 static int Open(vlc_object_t *p_this)
 745 {
 746     decoder_t *p_dec = (decoder_t*)p_this;
 747     decoder_sys_t *p_sys;
 748
 749     if (p_dec->fmt_in.i_codec != VLC_CODEC_FLAC)
 750         return VLC_EGENERIC;
 751
 752     /* */
 753     p_dec->p_sys = p_sys = malloc(sizeof(*p_sys));
 754     if (!p_sys)
 755         return VLC_ENOMEM;
 756
 757     p_sys->i_state       = STATE_NOSYNC;
 758     p_sys->b_stream_info = false;
 759     p_sys->i_pts         = VLC_TS_INVALID;
 760     p_sys->i_buf         = 0;
 761     p_sys->p_buf         = NULL;
 762     block_BytestreamInit(&p_sys->bytestream);
 763
 764     /* */
 765     es_format_Copy(&p_dec->fmt_out, &p_dec->fmt_in);
 766     p_dec->fmt_out.i_cat   = AUDIO_ES;
 767     p_dec->fmt_out.i_codec = VLC_CODEC_FLAC;
 768
 769     /* */
 770     p_dec->pf_decode_audio = NULL;
 771     p_dec->pf_packetize    = Packetize;
 772
 773     return VLC_SUCCESS;
 774 }
 775
 776 static void Close(vlc_object_t *p_this)
 777 {
 778     decoder_t *p_dec = (decoder_t *)p_this;
 779     decoder_sys_t *p_sys = p_dec->p_sys;
 780
 781     es_format_Clean(&p_dec->fmt_out);
 782     block_BytestreamRelease(&p_sys->bytestream);
 783     free(p_sys->p_buf);
 784     free(p_sys);
 785 }