Fix MSE ADTS parsing on Android.

media/formats/mp2t/es_parser_adts.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/formats/mp2t/es_parser_adts.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/bit_reader.h"
 #include "media/base/channel_layout.h"
+#include "media/base/media_util.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/timestamp_constants.h"
 #include "media/formats/common/offset_byte_queue.h"
 #include "media/formats/mp2t/mp2t_common.h"
 #include "media/formats/mpeg/adts_constants.h"
-#include "media/formats/mpeg/adts_header_parser.h"
 
 namespace media {
 
 static int ExtractAdtsFrameSize(const uint8_t* adts_header) {
   return ((static_cast<int>(adts_header[5]) >> 5) |
           (static_cast<int>(adts_header[4]) << 3) |
           ((static_cast<int>(adts_header[3]) & 0x3) << 11));
 }
 
 // Return true if buf corresponds to an ADTS syncword.
@@ skipping 84 matching lines @@
 
 EsParserAdts::~EsParserAdts() {
 }
 
 bool EsParserAdts::ParseFromEsQueue() {
   // Look for every ADTS frame in the ES buffer.
   AdtsFrame adts_frame;
   while (LookForAdtsFrame(&adts_frame)) {
     // Update the audio configuration if needed.
     DCHECK_GE(adts_frame.size, kADTSHeaderMinSize);
-    if (!UpdateAudioConfiguration(adts_frame.data))
+    if (!UpdateAudioConfiguration(adts_frame.data, adts_frame.size))
       return false;
 
     // Get the PTS & the duration of this access unit.
     TimingDesc current_timing_desc =
         GetTimingDescriptor(adts_frame.queue_offset);
     if (current_timing_desc.pts != kNoTimestamp)
       audio_timestamp_helper_->SetBaseTimestamp(current_timing_desc.pts);
 
     if (audio_timestamp_helper_->base_timestamp() == kNoTimestamp) {
       DVLOG(1) << "Skipping audio frame with unknown timestamp";
@@ skipping 29 matching lines @@
   return true;
 }
 
 void EsParserAdts::Flush() {
 }
 
 void EsParserAdts::ResetInternal() {
   last_audio_decoder_config_ = AudioDecoderConfig();
 }
 
-bool EsParserAdts::UpdateAudioConfiguration(const uint8_t* adts_header) {
-  AudioDecoderConfig audio_decoder_config;
-  size_t orig_sample_rate = 0;
-  if (!ParseAdtsHeader(adts_header, sbr_in_mimetype_, &audio_decoder_config,
-                       &orig_sample_rate))
+bool EsParserAdts::UpdateAudioConfiguration(const uint8_t* adts_header,
+                                            int size) {
+  int orig_sample_rate;
+  ChannelLayout channel_layout;
+  std::vector<uint8_t> extra_data;
+  if (adts_parser_.ParseFrameHeader(adts_header, size, nullptr,
+                                    &orig_sample_rate, &channel_layout, nullptr,
+                                    nullptr, &extra_data) <= 0) {
     return false;
+  }
+
+  // The following code is written according to ISO 14496 Part 3 Table 1.11 and
+  // Table 1.22. (Table 1.11 refers to the capping to 48000, Table 1.22 refers
+  // to SBR doubling the AAC sample rate.)
+  // TODO(damienv) : Extend sample rate cap to 96kHz for Level 5 content.
+  const int extended_samples_per_second =
+      sbr_in_mimetype_ ? std::min(2 * orig_sample_rate, 48000)
+                       : orig_sample_rate;
+
+  AudioDecoderConfig audio_decoder_config(
+      kCodecAAC, kSampleFormatS16, channel_layout, extended_samples_per_second,
+      extra_data, Unencrypted());
 
   if (!audio_decoder_config.Matches(last_audio_decoder_config_)) {
     DVLOG(1) << "Sampling frequency: "
              << audio_decoder_config.samples_per_second()
              << " SBR=" << sbr_in_mimetype_;
     DVLOG(1) << "Channel layout: "
              << ChannelLayoutToString(audio_decoder_config.channel_layout());
 
     // For AAC audio with SBR (Spectral Band Replication) the sampling rate is
-    // doubled in ParseAdtsHeader above, but AudioTimestampHelper should still
-    // use the original sample rate to compute audio timestamps and durations
-    // correctly.
+    // doubled above, but AudioTimestampHelper should still use the original
+    // sample rate to compute audio timestamps and durations correctly.
 
     // Reset the timestamp helper to use a new time scale.
     if (audio_timestamp_helper_ &&
         audio_timestamp_helper_->base_timestamp() != kNoTimestamp) {
       base::TimeDelta base_timestamp = audio_timestamp_helper_->GetTimestamp();
       audio_timestamp_helper_.reset(new AudioTimestampHelper(orig_sample_rate));
       audio_timestamp_helper_->SetBaseTimestamp(base_timestamp);
     } else {
       audio_timestamp_helper_.reset(new AudioTimestampHelper(orig_sample_rate));
     }
     // Audio config notification.
     last_audio_decoder_config_ = audio_decoder_config;
     new_audio_config_cb_.Run(audio_decoder_config);
   }
 
   return true;
 }
 
 }  // namespace mp2t
 }  // namespace media