ec3_audio_util.cc

// Copyright 2016 Google LLC. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
 
#include <packager/media/codecs/ec3_audio_util.h>
 
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <vector>
 
#include <absl/log/check.h>
#include <absl/log/log.h>
#include <absl/strings/escaping.h>
 
#include <packager/media/base/bit_reader.h>
#include <packager/media/base/rcheck.h>
#include <packager/utils/bytes_to_string_view.h>
 
namespace shaka {
namespace media {
 
namespace {
 
// Channels bit map. 16 bits.
// Bit,      Location
// 0(MSB),   Left
// 1,        Center
// 2,        Right
// 3,        Left Surround
// 4,        Right Surround
// 5,        Left center/Right center pair
// 6,        Left rear surround/Right rear surround pair
// 7,        Center surround
// 8,        Top center surround
// 9,        Left surround direct/Right surround direct pair
// 10,       Left wide/Right wide pair
// 11,       Lvertical height/Right vertical height pair
// 12,       Center vertical height
// 13,       Lts/Rts pair
// 14,       LFE2
// 15,       LFE
enum kEC3AudioChannelMap {
  kLeft = 0x8000,
  kCenter = 0x4000,
  kRight = 0x2000,
  kLeftSurround = 0x1000,
  kRightSurround = 0x800,
  kLcRcPair = 0x400,
  kLrsRrsPair = 0x200,
  kCenterSurround = 0x100,
  kTopCenterSurround = 0x80,
  kLsdRsdPair = 0x40,
  kLwRwPair = 0x20,
  kLvhRvhPair = 0x10,
  kCenterVerticalHeight = 0x8,
  kLtsRtsPair = 0x4,
  kLFE2 = 0x2,
  kLFEScreen = 0x1
};
// Number of channels for the channel bit above. The first entry corresponds to
// kLeft, which has one channel. All the XxxPairs bits have two channels.
const size_t kChannelCountArray[] = {
    1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 2, 1, 1,
};
static_assert(std::size(kChannelCountArray) == 16u,
              "Channel count array should have 16 entries.");
 
// EC3 Audio coding mode map (acmod) to determine EC3 audio channel layout. The
// value stands for the existence of Left, Center, Right, Left surround, and
// Right surround.
const uint16_t kEC3AudioCodingModeMap[] = {
    kLeft | kRight,
    kCenter,
    kLeft | kRight,
    kLeft | kCenter | kRight,
    kLeft | kRight | kLeftSurround | kRightSurround,
    kLeft | kCenter | kRight | kLeftSurround | kRightSurround,
    kLeft | kRight | kLeftSurround | kRightSurround,
    kLeft | kCenter | kRight | kLeftSurround | kRightSurround,
};
 
// Reverse bit order.
uint8_t ReverseBits8(uint8_t n) {
  n = ((n >> 1) & 0x55) | ((n & 0x55) << 1);
  n = ((n >> 2) & 0x33) | ((n & 0x33) << 2);
  return ((n >> 4) & 0x0f) | ((n & 0x0f) << 4);
}
 
// Mapping of channel configurations to the MPEG audio value based on
// ETSI TS 102 366 V1.4.1 Digital Audio Compression (AC-3, Enhanced AC-3)
// Standard Table I.1.1
uint32_t EC3ChannelMaptoMPEGValue(uint32_t channel_map) {
  uint32_t ret = 0;
 
  switch (channel_map) {
    case kCenter:
      ret = 1;
      break;
    case kLeft | kRight:
      ret = 2;
      break;
    case kCenter | kLeft | kRight:
      ret = 3;
      break;
    case kCenter | kLeft | kRight | kCenterSurround:
      ret = 4;
      break;
    case kCenter | kLeft | kRight | kLeftSurround | kRightSurround:
      ret = 5;
      break;
    case kCenter | kLeft | kRight | kLeftSurround | kRightSurround | kLFEScreen:
      ret = 6;
      break;
    case kCenter | kLeft | kRight | kLwRwPair | kLeftSurround | kRightSurround |
        kLFEScreen:
      ret = 7;
      break;
    case kLeft | kRight | kCenterSurround:
      ret = 9;
      break;
    case kLeft | kRight | kLeftSurround | kRightSurround:
      ret = 10;
      break;
    case kCenter | kLeft | kRight | kLrsRrsPair | kCenterSurround | kLFEScreen:
      ret = 11;
      break;
    case kCenter | kLeft | kRight | kLeftSurround | kRightSurround |
        kLrsRrsPair | kLFEScreen:
      ret = 12;
      break;
    case kCenter | kLeft | kRight | kLeftSurround | kRightSurround |
        kLFEScreen | kLvhRvhPair:
      ret = 14;
      break;
    case kCenter | kLeft | kRight | kLeftSurround | kRightSurround |
        kLFEScreen | kLvhRvhPair | kLtsRtsPair:
      ret = 16;
      break;
    case kCenter | kLeft | kRight | kLeftSurround | kRightSurround |
        kLFEScreen | kLvhRvhPair | kCenterVerticalHeight | kLtsRtsPair |
        kTopCenterSurround:
      ret = 17;
      break;
    case kCenter | kLeft | kRight | kLsdRsdPair | kLrsRrsPair | kLFEScreen |
        kLvhRvhPair | kLtsRtsPair:
      ret = 19;
      break;
    default:
      ret = 0xFFFFFFFF;
  }
  return ret;
}
 
bool ExtractEc3Data(const std::vector<uint8_t>& ec3_data,
                    uint8_t* audio_coding_mode,
                    bool* lfe_channel_on,
                    uint16_t* dependent_substreams_layout,
                    uint32_t* ec3_joc_complexity) {
  BitReader bit_reader(ec3_data.data(), ec3_data.size());
  // Read number of independent substreams and parse the independent substreams.
  uint8_t number_independent_substreams;
  RCHECK(bit_reader.SkipBits(13) &&
         bit_reader.ReadBits(3, &number_independent_substreams));
  // The value of this field is one less than the number of independent
  // substreams present.
  ++number_independent_substreams;
 
  // Parse audio_coding_mode, dependent_substreams_layout and lfe_channel_on
  // from the first independent substream.
  // Independent substream in EC3Specific box:
  // fscod: 2 bits
  // bsid: 5 bits
  // reserved_1: 1 bit
  // asvc: 1 bit
  // bsmod: 3 bits
  // acmod: 3 bits
  // lfeon: 1 bit
  // reserved_2: 3 bits
  // num_dep_sub: 4 bits
  // If num_dep_sub > 0, chan_loc is present and the size is 9 bits.
  // Otherwise, reserved_3 is present and the size is 1 bit.
  // chan_loc: 9 bits
  // reserved_3: 1 bit
  RCHECK(bit_reader.SkipBits(12));
  RCHECK(bit_reader.ReadBits(3, audio_coding_mode));
  RCHECK(bit_reader.ReadBits(1, lfe_channel_on));
 
  uint8_t number_dependent_substreams = 0;
  RCHECK(bit_reader.SkipBits(3));
  RCHECK(bit_reader.ReadBits(4, &number_dependent_substreams));
 
  *dependent_substreams_layout = 0;
  if (number_dependent_substreams > 0) {
    RCHECK(bit_reader.ReadBits(9, dependent_substreams_layout));
  } else {
    RCHECK(bit_reader.SkipBits(1));
  }
  *ec3_joc_complexity = 0;
  if (bit_reader.bits_available() < 16) {
    return true;
  }
 
  RCHECK(bit_reader.SkipBits(7));
  bool ec3_joc_flag;
  RCHECK(bit_reader.ReadBits(1, &ec3_joc_flag));
  if (ec3_joc_flag) {
    RCHECK(bit_reader.ReadBits(8, ec3_joc_complexity));
  }
  return true;
}
 
}  // namespace
 
bool CalculateEC3ChannelMap(const std::vector<uint8_t>& ec3_data,
                            uint32_t* channel_map) {
  uint8_t audio_coding_mode;
  bool lfe_channel_on;
  uint16_t dependent_substreams_layout;
  uint32_t ec3_joc_complexity;
  if (!ExtractEc3Data(ec3_data, &audio_coding_mode, &lfe_channel_on,
                      &dependent_substreams_layout, &ec3_joc_complexity)) {
    LOG(WARNING) << "Seeing invalid EC3 data: "
                 << absl::BytesToHexString(
                        byte_vector_to_string_view(ec3_data));
    return false;
  }
 
  // Dependent substreams layout bit map:
  // Bit,    Location
  // 0,      Lc/Rc pair
  // 1,      Lrs/Rrs pair
  // 2,      Cs
  // 3,      Ts
  // 4,      Lsd/Rsd pair
  // 5,      Lw/Rw pair
  // 6,      Lvh/Rvh pair
  // 7,      Cvh
  // 8(MSB), LFE2
  // Reverse bit order of dependent substreams channel layout (LFE2 not
  // included) to apply on channel_map bit 5 - 12.
  const uint8_t reversed_dependent_substreams_layout =
      ReverseBits8(dependent_substreams_layout & 0xFF);
 
  *channel_map = kEC3AudioCodingModeMap[audio_coding_mode] |
                 (reversed_dependent_substreams_layout << 3);
  if (dependent_substreams_layout & 0x100)
    *channel_map |= kLFE2;
  if (lfe_channel_on)
    *channel_map |= kLFEScreen;
  return true;
}
 
bool CalculateEC3ChannelMPEGValue(const std::vector<uint8_t>& ec3_data,
                                  uint32_t* ec3_channel_mpeg_value) {
  uint32_t channel_map;
  if (!CalculateEC3ChannelMap(ec3_data, &channel_map))
    return false;
  *ec3_channel_mpeg_value = EC3ChannelMaptoMPEGValue(channel_map);
  return true;
}
 
size_t GetEc3NumChannels(const std::vector<uint8_t>& ec3_data) {
  uint32_t channel_map;
  if (!CalculateEC3ChannelMap(ec3_data, &channel_map))
    return 0;
 
  size_t num_channels = 0;
  int bit = kLeft;
  for (size_t channel_count : kChannelCountArray) {
    if (channel_map & bit)
      num_channels += channel_count;
    bit >>= 1;
  }
  DCHECK_EQ(bit, 0);
  return num_channels;
}
 
bool GetEc3JocComplexity(const std::vector<uint8_t>& ec3_data,
                         uint32_t* ec3_joc_complexity) {
  uint8_t audio_coding_mode;
  bool lfe_channel_on;
  uint16_t dependent_substreams_layout;
 
  if (!ExtractEc3Data(ec3_data, &audio_coding_mode, &lfe_channel_on,
                      &dependent_substreams_layout, ec3_joc_complexity)) {
    LOG(WARNING) << "Seeing invalid EC3 data: "
                 << absl::BytesToHexString(
                        byte_vector_to_string_view(ec3_data));
    return false;
  }
  return true;
}
 
}  // namespace media
}  // namespace shaka