mlp_parser.c 8.44 KB
Newer Older
Ian Caulfield's avatar
Ian Caulfield committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * MLP parser
 * Copyright (c) 2007 Ian Caulfield
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file mlp_parser.c
 * MLP parser
 */

27 28
#include <stdint.h>

29
#include "libavutil/crc.h"
Ian Caulfield's avatar
Ian Caulfield committed
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
#include "bitstream.h"
#include "parser.h"
#include "mlp_parser.h"

static const uint8_t mlp_quants[16] = {
    16, 20, 24, 0, 0, 0, 0, 0,
     0,  0,  0, 0, 0, 0, 0, 0,
};

static const uint8_t mlp_channels[32] = {
    1, 2, 3, 4, 3, 4, 5, 3, 4, 5, 4, 5, 6, 4, 5, 4,
    5, 6, 5, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};

static const uint8_t thd_chancount[13] = {
//  LR    C   LFE  LRs LRvh  LRc LRrs  Cs   Ts  LRsd  LRw  Cvh  LFE2
     2,   1,   1,   2,   2,   2,   2,   1,   1,   2,   2,   1,   1
};

static int mlp_samplerate(int in)
{
    if (in == 0xF)
        return 0;

    return (in & 8 ? 44100 : 48000) << (in & 7) ;
}

static int truehd_channels(int chanmap)
{
    int channels = 0, i;

    for (i = 0; i < 13; i++)
        channels += thd_chancount[i] * ((chanmap >> i) & 1);

    return channels;
}

static int crc_init = 0;
static AVCRC crc_2D[1024];

Diego Biurrun's avatar
Diego Biurrun committed
70 71
/** MLP uses checksums that seem to be based on the standard CRC algorithm, but
 *  are not (in implementation terms, the table lookup and XOR are reversed).
72
 *  We can implement this behavior using a standard av_crc on all but the
Ian Caulfield's avatar
Ian Caulfield committed
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
 *  last element, then XOR that with the last element.
 */

static uint16_t mlp_checksum16(const uint8_t *buf, unsigned int buf_size)
{
    uint16_t crc;

    if (!crc_init) {
        av_crc_init(crc_2D, 0, 16, 0x002D, sizeof(crc_2D));
        crc_init = 1;
    }

    crc = av_crc(crc_2D, 0, buf, buf_size - 2);
    crc ^= AV_RL16(buf + buf_size - 2);
    return crc;
}

/** Read a major sync info header - contains high level information about
 *  the stream - sample rate, channel arrangement etc. Most of this
 *  information is not actually necessary for decoding, only for playback.
93
 *  gb must be a freshly initialized GetBitContext with no bits read.
Ian Caulfield's avatar
Ian Caulfield committed
94 95
 */

96
int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, GetBitContext *gb)
Ian Caulfield's avatar
Ian Caulfield committed
97 98 99 100
{
    int ratebits;
    uint16_t checksum;

101 102 103
    assert(get_bits_count(gb) == 0);

    if (gb->size_in_bits < 28 << 3) {
Diego Biurrun's avatar
Diego Biurrun committed
104
        av_log(log, AV_LOG_ERROR, "packet too short, unable to read major sync\n");
Ian Caulfield's avatar
Ian Caulfield committed
105 106 107
        return -1;
    }

108 109
    checksum = mlp_checksum16(gb->buffer, 26);
    if (checksum != AV_RL16(gb->buffer+26)) {
Diego Biurrun's avatar
Diego Biurrun committed
110
        av_log(log, AV_LOG_ERROR, "major sync info header checksum error\n");
Ian Caulfield's avatar
Ian Caulfield committed
111 112 113
        return -1;
    }

114
    if (get_bits_long(gb, 24) != 0xf8726f) /* Sync words */
Ian Caulfield's avatar
Ian Caulfield committed
115 116
        return -1;

117
    mh->stream_type = get_bits(gb, 8);
Ian Caulfield's avatar
Ian Caulfield committed
118 119

    if (mh->stream_type == 0xbb) {
120 121
        mh->group1_bits = mlp_quants[get_bits(gb, 4)];
        mh->group2_bits = mlp_quants[get_bits(gb, 4)];
Ian Caulfield's avatar
Ian Caulfield committed
122

123
        ratebits = get_bits(gb, 4);
Ian Caulfield's avatar
Ian Caulfield committed
124
        mh->group1_samplerate = mlp_samplerate(ratebits);
125
        mh->group2_samplerate = mlp_samplerate(get_bits(gb, 4));
Ian Caulfield's avatar
Ian Caulfield committed
126

127
        skip_bits(gb, 11);
Ian Caulfield's avatar
Ian Caulfield committed
128

129
        mh->channels_mlp = get_bits(gb, 5);
Ian Caulfield's avatar
Ian Caulfield committed
130 131 132 133
    } else if (mh->stream_type == 0xba) {
        mh->group1_bits = 24; // TODO: Is this information actually conveyed anywhere?
        mh->group2_bits = 0;

134
        ratebits = get_bits(gb, 4);
Ian Caulfield's avatar
Ian Caulfield committed
135 136 137
        mh->group1_samplerate = mlp_samplerate(ratebits);
        mh->group2_samplerate = 0;

138
        skip_bits(gb, 8);
Ian Caulfield's avatar
Ian Caulfield committed
139

140
        mh->channels_thd_stream1 = get_bits(gb, 5);
Ian Caulfield's avatar
Ian Caulfield committed
141

142
        skip_bits(gb, 2);
Ian Caulfield's avatar
Ian Caulfield committed
143

144
        mh->channels_thd_stream2 = get_bits(gb, 13);
Ian Caulfield's avatar
Ian Caulfield committed
145 146 147 148 149 150
    } else
        return -1;

    mh->access_unit_size = 40 << (ratebits & 7);
    mh->access_unit_size_pow2 = 64 << (ratebits & 7);

151
    skip_bits_long(gb, 48);
Ian Caulfield's avatar
Ian Caulfield committed
152

153
    mh->is_vbr = get_bits1(gb);
Ian Caulfield's avatar
Ian Caulfield committed
154

155
    mh->peak_bitrate = (get_bits(gb, 15) * mh->group1_samplerate + 8) >> 4;
Ian Caulfield's avatar
Ian Caulfield committed
156

157
    mh->num_substreams = get_bits(gb, 4);
Ian Caulfield's avatar
Ian Caulfield committed
158

159
    skip_bits_long(gb, 4 + 11 * 8);
Ian Caulfield's avatar
Ian Caulfield committed
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242

    return 0;
}

typedef struct MLPParseContext
{
    ParseContext pc;

    int bytes_left;

    int in_sync;

    int num_substreams;
} MLPParseContext;

static int mlp_parse(AVCodecParserContext *s,
                     AVCodecContext *avctx,
                     const uint8_t **poutbuf, int *poutbuf_size,
                     const uint8_t *buf, int buf_size)
{
    MLPParseContext *mp = s->priv_data;
    int sync_present;
    uint8_t parity_bits;
    int next;
    int i, p = 0;

    *poutbuf_size = 0;
    if (buf_size == 0)
        return 0;

    if (!mp->in_sync) {
        // Not in sync - find a major sync header

        for (i = 0; i < buf_size; i++) {
            mp->pc.state = (mp->pc.state << 8) | buf[i];
            if ((mp->pc.state & 0xfffffffe) == 0xf8726fba) {
                mp->in_sync = 1;
                mp->bytes_left = 0;
                break;
            }
        }

        if (!mp->in_sync) {
            ff_combine_frame(&mp->pc, END_NOT_FOUND, &buf, &buf_size);
            return buf_size;
        }

        ff_combine_frame(&mp->pc, i - 7, &buf, &buf_size);

        return i - 7;
    }

    if (mp->bytes_left == 0) {
        // Find length of this packet

        /* Copy overread bytes from last frame into buffer. */
        for(; mp->pc.overread>0; mp->pc.overread--) {
            mp->pc.buffer[mp->pc.index++]= mp->pc.buffer[mp->pc.overread_index++];
        }

        if (mp->pc.index + buf_size < 2) {
            ff_combine_frame(&mp->pc, END_NOT_FOUND, &buf, &buf_size);
            return buf_size;
        }

        mp->bytes_left = ((mp->pc.index > 0 ? mp->pc.buffer[0] : buf[0]) << 8)
                       |  (mp->pc.index > 1 ? mp->pc.buffer[1] : buf[1-mp->pc.index]);
        mp->bytes_left = (mp->bytes_left & 0xfff) * 2;
        mp->bytes_left -= mp->pc.index;
    }

    next = (mp->bytes_left > buf_size) ? END_NOT_FOUND : mp->bytes_left;

    if (ff_combine_frame(&mp->pc, next, &buf, &buf_size) < 0) {
        mp->bytes_left -= buf_size;
        return buf_size;
    }

    mp->bytes_left = 0;

    sync_present = (AV_RB32(buf + 4) & 0xfffffffe) == 0xf8726fba;

    if (!sync_present) {
243 244
        /* The first nibble of a frame is a parity check of the 4-byte
         * access unit header and all the 2- or 4-byte substream headers. */
245
        // Only check when this isn't a sync frame - syncs have a checksum.
Ian Caulfield's avatar
Ian Caulfield committed
246 247

        parity_bits = 0;
248
        for (i = -1; i < mp->num_substreams; i++) {
Ian Caulfield's avatar
Ian Caulfield committed
249 250 251
            parity_bits ^= buf[p++];
            parity_bits ^= buf[p++];

252
            if (i < 0 || buf[p-2] & 0x80) {
Ian Caulfield's avatar
Ian Caulfield committed
253 254 255 256 257 258
                parity_bits ^= buf[p++];
                parity_bits ^= buf[p++];
            }
        }

        if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
259
            av_log(avctx, AV_LOG_INFO, "mlpparse: Parity check failed.\n");
Ian Caulfield's avatar
Ian Caulfield committed
260 261 262
            goto lost_sync;
        }
    } else {
263
        GetBitContext gb;
Ian Caulfield's avatar
Ian Caulfield committed
264 265
        MLPHeaderInfo mh;

266 267
        init_get_bits(&gb, buf + 4, (buf_size - 4) << 3);
        if (ff_mlp_read_major_sync(avctx, &mh, &gb) < 0)
Ian Caulfield's avatar
Ian Caulfield committed
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
            goto lost_sync;

#ifdef CONFIG_AUDIO_NONSHORT
        avctx->bits_per_sample = mh.group1_bits;
        if (avctx->bits_per_sample > 16)
            avctx->sample_fmt = SAMPLE_FMT_S32;
#endif
        avctx->sample_rate = mh.group1_samplerate;
        avctx->frame_size = mh.access_unit_size;

        if (mh.stream_type == 0xbb) {
            /* MLP stream */
            avctx->channels = mlp_channels[mh.channels_mlp];
        } else { /* mh.stream_type == 0xba */
            /* TrueHD stream */
            if (mh.channels_thd_stream2)
                avctx->channels = truehd_channels(mh.channels_thd_stream2);
            else
                avctx->channels = truehd_channels(mh.channels_thd_stream1);
        }

        if (!mh.is_vbr) /* Stream is CBR */
            avctx->bit_rate = mh.peak_bitrate;

        mp->num_substreams = mh.num_substreams;
    }

    *poutbuf = buf;
    *poutbuf_size = buf_size;

    return next;

lost_sync:
    mp->in_sync = 0;
302
    return 1;
Ian Caulfield's avatar
Ian Caulfield committed
303 304 305 306 307 308 309 310 311
}

AVCodecParser mlp_parser = {
    { CODEC_ID_MLP },
    sizeof(MLPParseContext),
    NULL,
    mlp_parse,
    NULL,
};