libavcodec/mlp_parse.c

   1 /*
   2  * Copyright (c) 2007 Ian Caulfield
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <stdint.h>
  22
  23 #include "libavutil/channel_layout.h"
  24 #include "get_bits.h"
  25 #include "mlp_parse.h"
  26 #include "mlp.h"
  27
  28 static const uint8_t mlp_quants[16] = {
  29     16, 20, 24, 0, 0, 0, 0, 0,
  30      0,  0,  0, 0, 0, 0, 0, 0,
  31 };
  32
  33 static const uint8_t mlp_channels[32] = {
  34     1, 2, 3, 4, 3, 4, 5, 3, 4, 5, 4, 5, 6, 4, 5, 4,
  35     5, 6, 5, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  36 };
  37
  38 static const uint64_t mlp_layout[32] = {
  39     AV_CH_LAYOUT_MONO,
  40     AV_CH_LAYOUT_STEREO,
  41     AV_CH_LAYOUT_2_1,
  42     AV_CH_LAYOUT_QUAD,
  43     AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY,
  44     AV_CH_LAYOUT_2_1|AV_CH_LOW_FREQUENCY,
  45     AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY,
  46     AV_CH_LAYOUT_SURROUND,
  47     AV_CH_LAYOUT_4POINT0,
  48     AV_CH_LAYOUT_5POINT0_BACK,
  49     AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY,
  50     AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY,
  51     AV_CH_LAYOUT_5POINT1_BACK,
  52     AV_CH_LAYOUT_4POINT0,
  53     AV_CH_LAYOUT_5POINT0_BACK,
  54     AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY,
  55     AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY,
  56     AV_CH_LAYOUT_5POINT1_BACK,
  57     AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY,
  58     AV_CH_LAYOUT_5POINT0_BACK,
  59     AV_CH_LAYOUT_5POINT1_BACK,
  60     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  61 };
  62
  63 static int mlp_get_major_sync_size(const uint8_t * buf, int bufsize)
  64 {
  65     int has_extension, extensions = 0;
  66     int size = 28;
  67     if (bufsize < 28)
  68         return -1;
  69
  70     if (AV_RB32(buf) == 0xf8726fba) {
  71         has_extension = buf[25] & 1;
  72         if (has_extension) {
  73             extensions = buf[26] >> 4;
  74             size += 2 + extensions * 2;
  75         }
  76     }
  77     return size;
  78 }
  79
  80 /** Read a major sync info header - contains high level information about
  81  *  the stream - sample rate, channel arrangement etc. Most of this
  82  *  information is not actually necessary for decoding, only for playback.
  83  *  gb must be a freshly initialized GetBitContext with no bits read.
  84  */
  85
  86 int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, GetBitContext *gb)
  87 {
  88     int ratebits, channel_arrangement, header_size;
  89     uint16_t checksum;
  90
  91     av_assert1(get_bits_count(gb) == 0);
  92
  93     header_size = mlp_get_major_sync_size(gb->buffer, gb->size_in_bits >> 3);
  94     if (header_size < 0 || gb->size_in_bits < header_size << 3) {
  95         av_log(log, AV_LOG_ERROR, "packet too short, unable to read major sync\n");
  96         return -1;
  97     }
  98
  99     checksum = ff_mlp_checksum16(gb->buffer, header_size - 2);
 100     if (checksum != AV_RL16(gb->buffer+header_size-2)) {
 101         av_log(log, AV_LOG_ERROR, "major sync info header checksum error\n");
 102         return AVERROR_INVALIDDATA;
 103     }
 104
 105     if (get_bits(gb, 24) != 0xf8726f) /* Sync words */
 106         return AVERROR_INVALIDDATA;
 107
 108     mh->stream_type = get_bits(gb, 8);
 109     mh->header_size = header_size;
 110
 111     if (mh->stream_type == 0xbb) {
 112         mh->group1_bits = mlp_quants[get_bits(gb, 4)];
 113         mh->group2_bits = mlp_quants[get_bits(gb, 4)];
 114
 115         ratebits = get_bits(gb, 4);
 116         mh->group1_samplerate = mlp_samplerate(ratebits);
 117         mh->group2_samplerate = mlp_samplerate(get_bits(gb, 4));
 118
 119         skip_bits(gb, 11);
 120
 121         mh->channel_arrangement=
 122         channel_arrangement    = get_bits(gb, 5);
 123         mh->channels_mlp       = mlp_channels[channel_arrangement];
 124         mh->channel_layout_mlp = mlp_layout[channel_arrangement];
 125     } else if (mh->stream_type == 0xba) {
 126         mh->group1_bits = 24; // TODO: Is this information actually conveyed anywhere?
 127         mh->group2_bits = 0;
 128
 129         ratebits = get_bits(gb, 4);
 130         mh->group1_samplerate = mlp_samplerate(ratebits);
 131         mh->group2_samplerate = 0;
 132
 133         skip_bits(gb, 4);
 134
 135         mh->channel_modifier_thd_stream0 = get_bits(gb, 2);
 136         mh->channel_modifier_thd_stream1 = get_bits(gb, 2);
 137
 138         mh->channel_arrangement=
 139         channel_arrangement            = get_bits(gb, 5);
 140         mh->channels_thd_stream1       = truehd_channels(channel_arrangement);
 141         mh->channel_layout_thd_stream1 = truehd_layout(channel_arrangement);
 142
 143         mh->channel_modifier_thd_stream2 = get_bits(gb, 2);
 144
 145         channel_arrangement            = get_bits(gb, 13);
 146         mh->channels_thd_stream2       = truehd_channels(channel_arrangement);
 147         mh->channel_layout_thd_stream2 = truehd_layout(channel_arrangement);
 148     } else
 149         return AVERROR_INVALIDDATA;
 150
 151     mh->access_unit_size = 40 << (ratebits & 7);
 152     mh->access_unit_size_pow2 = 64 << (ratebits & 7);
 153
 154     skip_bits_long(gb, 48);
 155
 156     mh->is_vbr = get_bits1(gb);
 157
 158     mh->peak_bitrate = (get_bits(gb, 15) * mh->group1_samplerate + 8) >> 4;
 159
 160     mh->num_substreams = get_bits(gb, 4);
 161
 162     skip_bits(gb, 2);
 163     mh->extended_substream_info = get_bits(gb, 2);
 164     mh->substream_info = get_bits(gb, 8);
 165
 166     skip_bits_long(gb, (header_size - 18) * 8);
 167
 168     return 0;
 169 }