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