git.sesse.net Git - ffmpeg/blob - libavcodec/dolby_e_parse.c

   1 /*
   2  * Copyright (C) 2017 foo86
   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 "get_bits.h"
  22 #include "put_bits.h"
  23 #include "dolby_e.h"
  24
  25 static const uint8_t nb_programs_tab[MAX_PROG_CONF + 1] = {
  26     2, 3, 2, 3, 4, 5, 4, 5, 6, 7, 8, 1, 2, 3, 3, 4, 5, 6, 1, 2, 3, 4, 1, 1
  27 };
  28
  29 static const uint8_t nb_channels_tab[MAX_PROG_CONF + 1] = {
  30     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8
  31 };
  32
  33 static const uint16_t sample_rate_tab[16] = {
  34     0, 42965, 43008, 44800, 53706, 53760
  35 };
  36
  37 static int skip_input(DBEContext *s, int nb_words)
  38 {
  39     if (nb_words > s->input_size) {
  40         return AVERROR_INVALIDDATA;
  41     }
  42
  43     s->input      += nb_words * s->word_bytes;
  44     s->input_size -= nb_words;
  45     return 0;
  46 }
  47
  48 static int parse_key(DBEContext *s)
  49 {
  50     if (s->key_present) {
  51         const uint8_t *key = s->input;
  52         int      ret = skip_input(s, 1);
  53         if (ret < 0)
  54             return ret;
  55         return AV_RB24(key) >> 24 - s->word_bits;
  56     }
  57     return 0;
  58 }
  59
  60 int ff_dolby_e_convert_input(DBEContext *s, int nb_words, int key)
  61 {
  62     const uint8_t *src = s->input;
  63     uint8_t *dst = s->buffer;
  64     PutBitContext pb;
  65     int i;
  66
  67     av_assert0(nb_words <= 1024u);
  68
  69     if (nb_words > s->input_size) {
  70         if (s->avctx)
  71             av_log(s->avctx, AV_LOG_ERROR, "Packet too short\n");
  72         return AVERROR_INVALIDDATA;
  73     }
  74
  75     switch (s->word_bits) {
  76     case 16:
  77         for (i = 0; i < nb_words; i++, src += 2, dst += 2)
  78             AV_WB16(dst, AV_RB16(src) ^ key);
  79         break;
  80     case 20:
  81         init_put_bits(&pb, s->buffer, sizeof(s->buffer));
  82         for (i = 0; i < nb_words; i++, src += 3)
  83             put_bits(&pb, 20, AV_RB24(src) >> 4 ^ key);
  84         flush_put_bits(&pb);
  85         break;
  86     case 24:
  87         for (i = 0; i < nb_words; i++, src += 3, dst += 3)
  88             AV_WB24(dst, AV_RB24(src) ^ key);
  89         break;
  90     default:
  91         av_assert0(0);
  92     }
  93
  94     return init_get_bits(&s->gb, s->buffer, nb_words * s->word_bits);
  95 }
  96
  97 int ff_dolby_e_parse_header(DBEContext *s, const uint8_t *buf, int buf_size)
  98 {
  99     DolbyEHeaderInfo *const header = &s->metadata;
 100     int hdr, ret, key, mtd_size;
 101
 102     if (buf_size < 3)
 103         return AVERROR_INVALIDDATA;
 104
 105     hdr = AV_RB24(buf);
 106     if ((hdr & 0xfffffe) == 0x7888e) {
 107         s->word_bits = 24;
 108     } else if ((hdr & 0xffffe0) == 0x788e0) {
 109         s->word_bits = 20;
 110     } else if ((hdr & 0xfffe00) == 0x78e00) {
 111         s->word_bits = 16;
 112     } else {
 113         if (s->avctx)
 114             av_log(s->avctx, AV_LOG_ERROR, "Invalid frame header\n");
 115         return AVERROR_INVALIDDATA;
 116     }
 117
 118     s->word_bytes  = s->word_bits + 7 >> 3;
 119     s->input       = buf + s->word_bytes;
 120     s->input_size  = buf_size / s->word_bytes - 1;
 121     s->key_present = hdr >> 24 - s->word_bits & 1;
 122
 123     if ((key = parse_key(s)) < 0)
 124         return key;
 125     if ((ret = ff_dolby_e_convert_input(s, 1, key)) < 0)
 126         return ret;
 127
 128     skip_bits(&s->gb, 4);
 129     mtd_size = get_bits(&s->gb, 10);
 130     if (!mtd_size) {
 131         if (s->avctx)
 132             av_log(s->avctx, AV_LOG_ERROR, "Invalid metadata size\n");
 133         return AVERROR_INVALIDDATA;
 134     }
 135
 136     if ((ret = ff_dolby_e_convert_input(s, mtd_size, key)) < 0)
 137         return ret;
 138
 139     skip_bits(&s->gb, 14);
 140     header->prog_conf = get_bits(&s->gb, 6);
 141     if (header->prog_conf > MAX_PROG_CONF) {
 142         if (s->avctx)
 143             av_log(s->avctx, AV_LOG_ERROR, "Invalid program configuration\n");
 144         return AVERROR_INVALIDDATA;
 145     }
 146
 147     header->nb_channels = nb_channels_tab[header->prog_conf];
 148     header->nb_programs = nb_programs_tab[header->prog_conf];
 149
 150     header->fr_code      = get_bits(&s->gb, 4);
 151     header->fr_code_orig = get_bits(&s->gb, 4);
 152     if (!(header->sample_rate = sample_rate_tab[header->fr_code]) ||
 153         !sample_rate_tab[header->fr_code_orig]) {
 154         if (s->avctx)
 155             av_log(s->avctx, AV_LOG_ERROR, "Invalid frame rate code\n");
 156         return AVERROR_INVALIDDATA;
 157     }
 158
 159     skip_bits_long(&s->gb, 88);
 160     for (int i = 0; i < header->nb_channels; i++)
 161         header->ch_size[i] = get_bits(&s->gb, 10);
 162     header->mtd_ext_size = get_bits(&s->gb, 8);
 163     header->meter_size   = get_bits(&s->gb, 8);
 164
 165     skip_bits_long(&s->gb, 10 * header->nb_programs);
 166     for (int i = 0; i < header->nb_channels; i++) {
 167         header->rev_id[i]     = get_bits(&s->gb,  4);
 168         skip_bits1(&s->gb);
 169         header->begin_gain[i] = get_bits(&s->gb, 10);
 170         header->end_gain[i]   = get_bits(&s->gb, 10);
 171     }
 172
 173     if (get_bits_left(&s->gb) < 0) {
 174         if (s->avctx)
 175             av_log(s->avctx, AV_LOG_ERROR, "Read past end of metadata\n");
 176         return AVERROR_INVALIDDATA;
 177     }
 178
 179     return skip_input(s, mtd_size + 1);
 180 }