media/mp4/aac.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/mp4/aac.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "media/base/bit_reader.h"
  11 #include "media/mp4/rcheck.h"
  12
  13 // The following conversion table is extracted from ISO 14496 Part 3 -
  14 // Table 1.16 - Sampling Frequency Index.
  15 static const int kFrequencyMap[] = {
  16   96000, 88200, 64000, 48000, 44100, 32000, 24000,
  17   22050, 16000, 12000, 11025, 8000, 7350
  18 };
  19
  20 namespace media {
  21
  22 static ChannelLayout ConvertChannelConfigToLayout(uint8 channel_config) {
  23   switch (channel_config) {
  24     case 1:
  25       return CHANNEL_LAYOUT_MONO;
  26     case 2:
  27       return CHANNEL_LAYOUT_STEREO;
  28     case 3:
  29       return CHANNEL_LAYOUT_SURROUND;
  30     case 4:
  31       return CHANNEL_LAYOUT_4_0;
  32     case 5:
  33       return CHANNEL_LAYOUT_5_0;
  34     case 6:
  35       return CHANNEL_LAYOUT_5_1;
  36     case 8:
  37       return CHANNEL_LAYOUT_7_1;
  38     default:
  39       break;
  40   }
  41
  42   return CHANNEL_LAYOUT_UNSUPPORTED;
  43 }
  44
  45 namespace mp4 {
  46
  47 AAC::AAC()
  48     : profile_(0), frequency_index_(0), channel_config_(0), frequency_(0),
  49       extension_frequency_(0), channel_layout_(CHANNEL_LAYOUT_UNSUPPORTED) {
  50 }
  51
  52 AAC::~AAC() {
  53 }
  54
  55 bool AAC::Parse(const std::vector<uint8>& data) {
  56 #if defined(OS_ANDROID)
  57   codec_specific_data_ = data;
  58 #endif
  59   if (data.empty())
  60     return false;
  61
  62   BitReader reader(&data[0], data.size());
  63   uint8 extension_type = 0;
  64   bool ps_present = false;
  65   uint8 extension_frequency_index = 0xff;
  66
  67   frequency_ = 0;
  68   extension_frequency_ = 0;
  69
  70   // The following code is written according to ISO 14496 Part 3 Table 1.13 -
  71   // Syntax of AudioSpecificConfig.
  72
  73   // Read base configuration
  74   RCHECK(reader.ReadBits(5, &profile_));
  75   RCHECK(reader.ReadBits(4, &frequency_index_));
  76   if (frequency_index_ == 0xf)
  77     RCHECK(reader.ReadBits(24, &frequency_));
  78   RCHECK(reader.ReadBits(4, &channel_config_));
  79
  80   // Read extension configuration.
  81   if (profile_ == 5 || profile_ == 29) {
  82     ps_present = (profile_ == 29);
  83     extension_type = 5;
  84     RCHECK(reader.ReadBits(4, &extension_frequency_index));
  85     if (extension_frequency_index == 0xf)
  86       RCHECK(reader.ReadBits(24, &extension_frequency_));
  87     RCHECK(reader.ReadBits(5, &profile_));
  88   }
  89
  90   RCHECK(SkipDecoderGASpecificConfig(&reader));
  91   RCHECK(SkipErrorSpecificConfig());
  92
  93   // Read extension configuration again
  94   // Note: The check for 16 available bits comes from the AAC spec.
  95   if (extension_type != 5 && reader.bits_available() >= 16) {
  96     uint16 sync_extension_type;
  97     uint8 sbr_present_flag;
  98     uint8 ps_present_flag;
  99
 100     if (reader.ReadBits(11, &sync_extension_type) &&
 101         sync_extension_type == 0x2b7) {
 102       if (reader.ReadBits(5, &extension_type) && extension_type == 5) {
 103         RCHECK(reader.ReadBits(1, &sbr_present_flag));
 104
 105         if (sbr_present_flag) {
 106           RCHECK(reader.ReadBits(4, &extension_frequency_index));
 107
 108           if (extension_frequency_index == 0xf)
 109             RCHECK(reader.ReadBits(24, &extension_frequency_));
 110
 111           // Note: The check for 12 available bits comes from the AAC spec.
 112           if (reader.bits_available() >= 12) {
 113             RCHECK(reader.ReadBits(11, &sync_extension_type));
 114             if (sync_extension_type == 0x548) {
 115               RCHECK(reader.ReadBits(1, &ps_present_flag));
 116               ps_present = ps_present_flag != 0;
 117             }
 118           }
 119         }
 120       }
 121     }
 122   }
 123
 124   if (frequency_ == 0) {
 125     RCHECK(frequency_index_ < arraysize(kFrequencyMap));
 126     frequency_ = kFrequencyMap[frequency_index_];
 127   }
 128
 129   if (extension_frequency_ == 0 && extension_frequency_index != 0xff) {
 130     RCHECK(extension_frequency_index < arraysize(kFrequencyMap));
 131     extension_frequency_ = kFrequencyMap[extension_frequency_index];
 132   }
 133
 134   // When Parametric Stereo is on, mono will be played as stereo.
 135   if (ps_present && channel_config_ == 1)
 136     channel_layout_ = CHANNEL_LAYOUT_STEREO;
 137   else
 138     channel_layout_ = ConvertChannelConfigToLayout(channel_config_);
 139
 140   return frequency_ != 0 && channel_layout_ != CHANNEL_LAYOUT_UNSUPPORTED &&
 141       profile_ >= 1 && profile_ <= 4 && frequency_index_ != 0xf &&
 142       channel_config_ <= 7;
 143 }
 144
 145 int AAC::GetOutputSamplesPerSecond(bool sbr_in_mimetype) const {
 146   if (extension_frequency_ > 0)
 147     return extension_frequency_;
 148
 149   if (!sbr_in_mimetype)
 150     return frequency_;
 151
 152   // The following code is written according to ISO 14496 Part 3 Table 1.11 and
 153   // Table 1.22. (Table 1.11 refers to the capping to 48000, Table 1.22 refers
 154   // to SBR doubling the AAC sample rate.)
 155   // TODO(acolwell) : Extend sample rate cap to 96kHz for Level 5 content.
 156   DCHECK_GT(frequency_, 0);
 157   return std::min(2 * frequency_, 48000);
 158 }
 159
 160 ChannelLayout AAC::GetChannelLayout(bool sbr_in_mimetype) const {
 161   // Check for implicit signalling of HE-AAC and indicate stereo output
 162   // if the mono channel configuration is signalled.
 163   // See ISO-14496-3 Section 1.6.6.1.2 for details about this special casing.
 164   if (sbr_in_mimetype && channel_config_ == 1)
 165     return CHANNEL_LAYOUT_STEREO;
 166
 167   return channel_layout_;
 168 }
 169
 170 bool AAC::ConvertEsdsToADTS(std::vector<uint8>* buffer) const {
 171   size_t size = buffer->size() + kADTSHeaderSize;
 172
 173   DCHECK(profile_ >= 1 && profile_ <= 4 && frequency_index_ != 0xf &&
 174          channel_config_ <= 7);
 175
 176   // ADTS header uses 13 bits for packet size.
 177   if (size >= (1 << 13))
 178     return false;
 179
 180   std::vector<uint8>& adts = *buffer;
 181
 182   adts.insert(buffer->begin(), kADTSHeaderSize, 0);
 183   adts[0] = 0xff;
 184   adts[1] = 0xf1;
 185   adts[2] = ((profile_ - 1) << 6) + (frequency_index_ << 2) +
 186       (channel_config_ >> 2);
 187   adts[3] = ((channel_config_ & 0x3) << 6) + (size >> 11);
 188   adts[4] = (size & 0x7ff) >> 3;
 189   adts[5] = ((size & 7) << 5) + 0x1f;
 190   adts[6] = 0xfc;
 191
 192   return true;
 193 }
 194
 195 // Currently this function only support GASpecificConfig defined in
 196 // ISO 14496 Part 3 Table 4.1 - Syntax of GASpecificConfig()
 197 bool AAC::SkipDecoderGASpecificConfig(BitReader* bit_reader) const {
 198   switch (profile_) {
 199     case 1:
 200     case 2:
 201     case 3:
 202     case 4:
 203     case 6:
 204     case 7:
 205     case 17:
 206     case 19:
 207     case 20:
 208     case 21:
 209     case 22:
 210     case 23:
 211       return SkipGASpecificConfig(bit_reader);
 212     default:
 213       break;
 214   }
 215
 216   return false;
 217 }
 218
 219 bool AAC::SkipErrorSpecificConfig() const {
 220   switch (profile_) {
 221     case 17:
 222     case 19:
 223     case 20:
 224     case 21:
 225     case 22:
 226     case 23:
 227     case 24:
 228     case 25:
 229     case 26:
 230     case 27:
 231       return false;
 232     default:
 233       break;
 234   }
 235
 236   return true;
 237 }
 238
 239 // The following code is written according to ISO 14496 part 3 Table 4.1 -
 240 // GASpecificConfig.
 241 bool AAC::SkipGASpecificConfig(BitReader* bit_reader) const {
 242   uint8 extension_flag = 0;
 243   uint8 depends_on_core_coder;
 244   uint16 dummy;
 245
 246   RCHECK(bit_reader->ReadBits(1, &dummy));  // frameLengthFlag
 247   RCHECK(bit_reader->ReadBits(1, &depends_on_core_coder));
 248   if (depends_on_core_coder == 1)
 249     RCHECK(bit_reader->ReadBits(14, &dummy));  // coreCoderDelay
 250
 251   RCHECK(bit_reader->ReadBits(1, &extension_flag));
 252   RCHECK(channel_config_ != 0);
 253
 254   if (profile_ == 6 || profile_ == 20)
 255     RCHECK(bit_reader->ReadBits(3, &dummy));  // layerNr
 256
 257   if (extension_flag) {
 258     if (profile_ == 22) {
 259       RCHECK(bit_reader->ReadBits(5, &dummy));  // numOfSubFrame
 260       RCHECK(bit_reader->ReadBits(11, &dummy));  // layer_length
 261     }
 262
 263     if (profile_ == 17 || profile_ == 19 || profile_ == 20 || profile_ == 23) {
 264       RCHECK(bit_reader->ReadBits(3, &dummy));  // resilience flags
 265     }
 266
 267     RCHECK(bit_reader->ReadBits(1, &dummy));  // extensionFlag3
 268   }
 269
 270   return true;
 271 }
 272
 273 }  // namespace mp4
 274
 275 }  // namespace media