media/mp2t/es_parser_adts.cc

   1 // Copyright 2013 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/mp2t/es_parser_adts.h"
   6
   7 #include <list>
   8
   9 #include "base/basictypes.h"
  10 #include "base/logging.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "media/base/audio_timestamp_helper.h"
  13 #include "media/base/bit_reader.h"
  14 #include "media/base/buffers.h"
  15 #include "media/base/channel_layout.h"
  16 #include "media/base/stream_parser_buffer.h"
  17 #include "media/mp2t/mp2t_common.h"
  18
  19 // Adts header is at least 7 bytes (can be 9 bytes).
  20 static const int kAdtsHeaderMinSize = 7;
  21
  22 static const int adts_frequency_table[16] = {
  23   96000,
  24   88200,
  25   64000,
  26   48000,
  27   44100,
  28   32000,
  29   24000,
  30   22050,
  31   16000,
  32   12000,
  33   11025,
  34   8000,
  35   7350,
  36   0,
  37   0,
  38   0,
  39 };
  40 static const int kMaxSupportedFrequencyIndex = 12;
  41
  42 static media::ChannelLayout adts_channel_layout[8] = {
  43   media::CHANNEL_LAYOUT_NONE,
  44   media::CHANNEL_LAYOUT_MONO,
  45   media::CHANNEL_LAYOUT_STEREO,
  46   media::CHANNEL_LAYOUT_SURROUND,
  47   media::CHANNEL_LAYOUT_4_0,
  48   media::CHANNEL_LAYOUT_5_0_BACK,
  49   media::CHANNEL_LAYOUT_5_1_BACK,
  50   media::CHANNEL_LAYOUT_7_1,
  51 };
  52
  53 // Number of samples per frame.
  54 static const int kNumberSamplesPerAACFrame = 1024;
  55
  56 static int ExtractAdtsFrameSize(const uint8* adts_header) {
  57   return ((static_cast<int>(adts_header[5]) >> 5) |
  58           (static_cast<int>(adts_header[4]) << 3) |
  59           ((static_cast<int>(adts_header[3]) & 0x3) << 11));
  60 }
  61
  62 static int ExtractAdtsFrequencyIndex(const uint8* adts_header) {
  63   return ((adts_header[2] >> 2) & 0xf);
  64 }
  65
  66 static int ExtractAdtsChannelConfig(const uint8* adts_header) {
  67   return (((adts_header[3] >> 6) & 0x3) |
  68           ((adts_header[2] & 0x1) << 2));
  69 }
  70
  71 // Return true if buf corresponds to an ADTS syncword.
  72 // |buf| size must be at least 2.
  73 static bool isAdtsSyncWord(const uint8* buf) {
  74   return (buf[0] == 0xff) && ((buf[1] & 0xf6) == 0xf0);
  75 }
  76
  77 // Look for an ADTS syncword.
  78 // |new_pos| returns
  79 // - either the byte position of the ADTS frame (if found)
  80 // - or the byte position of 1st byte that was not processed (if not found).
  81 // In every case, the returned value in |new_pos| is such that new_pos >= pos
  82 // |frame_sz| returns the size of the ADTS frame (if found).
  83 // Return whether a syncword was found.
  84 static bool LookForSyncWord(const uint8* raw_es, int raw_es_size,
  85                             int pos,
  86                             int* new_pos, int* frame_sz) {
  87   DCHECK_GE(pos, 0);
  88   DCHECK_LE(pos, raw_es_size);
  89
  90   int max_offset = raw_es_size - kAdtsHeaderMinSize;
  91   if (pos >= max_offset) {
  92     // Do not change the position if:
  93     // - max_offset < 0: not enough bytes to get a full header
  94     //   Since pos >= 0, this is a subcase of the next condition.
  95     // - pos >= max_offset: might be the case after reading one full frame,
  96     //   |pos| is then incremented by the frame size and might then point
  97     //   to the end of the buffer.
  98     *new_pos = pos;
  99     return false;
 100   }
 101
 102   for (int offset = pos; offset < max_offset; offset++) {
 103     const uint8* cur_buf = &raw_es[offset];
 104
 105     if (!isAdtsSyncWord(cur_buf))
 106       // The first 12 bits must be 1.
 107       // The layer field (2 bits) must be set to 0.
 108       continue;
 109
 110     int frame_size = ExtractAdtsFrameSize(cur_buf);
 111     if (frame_size < kAdtsHeaderMinSize) {
 112       // Too short to be an ADTS frame.
 113       continue;
 114     }
 115
 116     // Check whether there is another frame
 117     // |size| apart from the current one.
 118     int remaining_size = raw_es_size - offset;
 119     if (remaining_size >= frame_size + 2 &&
 120         !isAdtsSyncWord(&cur_buf[frame_size])) {
 121       continue;
 122     }
 123
 124     *new_pos = offset;
 125     *frame_sz = frame_size;
 126     return true;
 127   }
 128
 129   *new_pos = max_offset;
 130   return false;
 131 }
 132
 133 namespace media {
 134 namespace mp2t {
 135
 136 EsParserAdts::EsParserAdts(
 137     const NewAudioConfigCB& new_audio_config_cb,
 138     const EmitBufferCB& emit_buffer_cb,
 139     bool sbr_in_mimetype)
 140   : new_audio_config_cb_(new_audio_config_cb),
 141     emit_buffer_cb_(emit_buffer_cb),
 142     sbr_in_mimetype_(sbr_in_mimetype) {
 143 }
 144
 145 EsParserAdts::~EsParserAdts() {
 146 }
 147
 148 bool EsParserAdts::Parse(const uint8* buf, int size,
 149                          base::TimeDelta pts,
 150                          base::TimeDelta dts) {
 151   int raw_es_size;
 152   const uint8* raw_es;
 153
 154   // The incoming PTS applies to the access unit that comes just after
 155   // the beginning of |buf|.
 156   if (pts != kNoTimestamp()) {
 157     es_byte_queue_.Peek(&raw_es, &raw_es_size);
 158     pts_list_.push_back(EsPts(raw_es_size, pts));
 159   }
 160
 161   // Copy the input data to the ES buffer.
 162   es_byte_queue_.Push(buf, size);
 163   es_byte_queue_.Peek(&raw_es, &raw_es_size);
 164
 165   // Look for every ADTS frame in the ES buffer starting at offset = 0
 166   int es_position = 0;
 167   int frame_size;
 168   while (LookForSyncWord(raw_es, raw_es_size, es_position,
 169                          &es_position, &frame_size)) {
 170     DVLOG(LOG_LEVEL_ES)
 171         << "ADTS syncword @ pos=" << es_position
 172         << " frame_size=" << frame_size;
 173     DVLOG(LOG_LEVEL_ES)
 174         << "ADTS header: "
 175         << base::HexEncode(&raw_es[es_position], kAdtsHeaderMinSize);
 176
 177     // Do not process the frame if this one is a partial frame.
 178     int remaining_size = raw_es_size - es_position;
 179     if (frame_size > remaining_size)
 180       break;
 181
 182     // Update the audio configuration if needed.
 183     DCHECK_GE(frame_size, kAdtsHeaderMinSize);
 184     if (!UpdateAudioConfiguration(&raw_es[es_position]))
 185       return false;
 186
 187     // Get the PTS & the duration of this access unit.
 188     while (!pts_list_.empty() &&
 189            pts_list_.front().first <= es_position) {
 190       audio_timestamp_helper_->SetBaseTimestamp(pts_list_.front().second);
 191       pts_list_.pop_front();
 192     }
 193
 194     base::TimeDelta current_pts = audio_timestamp_helper_->GetTimestamp();
 195     base::TimeDelta frame_duration =
 196         audio_timestamp_helper_->GetFrameDuration(kNumberSamplesPerAACFrame);
 197
 198     // Emit an audio frame.
 199     bool is_key_frame = true;
 200     scoped_refptr<StreamParserBuffer> stream_parser_buffer =
 201         StreamParserBuffer::CopyFrom(
 202             &raw_es[es_position],
 203             frame_size,
 204             is_key_frame);
 205     stream_parser_buffer->SetDecodeTimestamp(current_pts);
 206     stream_parser_buffer->set_timestamp(current_pts);
 207     stream_parser_buffer->set_duration(frame_duration);
 208     emit_buffer_cb_.Run(stream_parser_buffer);
 209
 210     // Update the PTS of the next frame.
 211     audio_timestamp_helper_->AddFrames(kNumberSamplesPerAACFrame);
 212
 213     // Skip the current frame.
 214     es_position += frame_size;
 215   }
 216
 217   // Discard all the bytes that have been processed.
 218   DiscardEs(es_position);
 219
 220   return true;
 221 }
 222
 223 void EsParserAdts::Flush() {
 224 }
 225
 226 void EsParserAdts::Reset() {
 227   es_byte_queue_.Reset();
 228   pts_list_.clear();
 229   last_audio_decoder_config_ = AudioDecoderConfig();
 230 }
 231
 232 bool EsParserAdts::UpdateAudioConfiguration(const uint8* adts_header) {
 233   int frequency_index = ExtractAdtsFrequencyIndex(adts_header);
 234   if (frequency_index > kMaxSupportedFrequencyIndex) {
 235     // Frequency index 13 & 14 are reserved
 236     // while 15 means that the frequency is explicitly written
 237     // (not supported).
 238     return false;
 239   }
 240
 241   int channel_configuration = ExtractAdtsChannelConfig(adts_header);
 242   if (channel_configuration == 0) {
 243     // TODO(damienv): Add support for inband channel configuration.
 244     return false;
 245   }
 246
 247   // TODO(damienv): support HE-AAC frequency doubling (SBR)
 248   // based on the incoming ADTS profile.
 249   int samples_per_second = adts_frequency_table[frequency_index];
 250   int adts_profile = (adts_header[2] >> 6) & 0x3;
 251
 252   // The following code is written according to ISO 14496 Part 3 Table 1.11 and
 253   // Table 1.22. (Table 1.11 refers to the capping to 48000, Table 1.22 refers
 254   // to SBR doubling the AAC sample rate.)
 255   // TODO(damienv) : Extend sample rate cap to 96kHz for Level 5 content.
 256   int extended_samples_per_second = sbr_in_mimetype_
 257       ? std::min(2 * samples_per_second, 48000)
 258       : samples_per_second;
 259
 260   AudioDecoderConfig audio_decoder_config(
 261       kCodecAAC,
 262       kSampleFormatS16,
 263       adts_channel_layout[channel_configuration],
 264       extended_samples_per_second,
 265       NULL, 0,
 266       false);
 267
 268   if (!audio_decoder_config.Matches(last_audio_decoder_config_)) {
 269     DVLOG(1) << "Sampling frequency: " << samples_per_second;
 270     DVLOG(1) << "Extended sampling frequency: " << extended_samples_per_second;
 271     DVLOG(1) << "Channel config: " << channel_configuration;
 272     DVLOG(1) << "Adts profile: " << adts_profile;
 273     // Reset the timestamp helper to use a new time scale.
 274     if (audio_timestamp_helper_) {
 275       base::TimeDelta base_timestamp = audio_timestamp_helper_->GetTimestamp();
 276       audio_timestamp_helper_.reset(
 277         new AudioTimestampHelper(samples_per_second));
 278       audio_timestamp_helper_->SetBaseTimestamp(base_timestamp);
 279     } else {
 280       audio_timestamp_helper_.reset(
 281           new AudioTimestampHelper(samples_per_second));
 282     }
 283     // Audio config notification.
 284     last_audio_decoder_config_ = audio_decoder_config;
 285     new_audio_config_cb_.Run(audio_decoder_config);
 286   }
 287
 288   return true;
 289 }
 290
 291 void EsParserAdts::DiscardEs(int nbytes) {
 292   DCHECK_GE(nbytes, 0);
 293   if (nbytes <= 0)
 294     return;
 295
 296   // Adjust the ES position of each PTS.
 297   for (EsPtsList::iterator it = pts_list_.begin(); it != pts_list_.end(); ++it)
 298     it->first -= nbytes;
 299
 300   // Discard |nbytes| of ES.
 301   es_byte_queue_.Pop(nbytes);
 302 }
 303
 304 }  // namespace mp2t
 305 }  // namespace media
 306