Fix MSE ADTS parsing on Android.

media/filters/audio_decoder_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 20 matching lines @@
 #include "media/filters/in_memory_url_protocol.h"
 #include "media/filters/opus_audio_decoder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/filters/android/media_codec_audio_decoder.h"
 
 #if defined(USE_PROPRIETARY_CODECS)
-#include "media/formats/mpeg/adts_header_parser.h"
+#include "media/formats/mpeg/adts_stream_parser.h"
 #endif
 
 // Helper macro to skip the test if MediaCodec is not available.
 #define SKIP_TEST_IF_NO_MEDIA_CODEC()                                \
   do {                                                               \
     if (GetParam().decoder_type == MEDIA_CODEC) {                    \
       if (!MediaCodecUtil::IsMediaCodecAvailable()) {                \
         VLOG(0) << "Could not run test - no MediaCodec on device.";  \
         return;                                                      \
       }                                                              \
@@ skipping 145 matching lines @@
 
     AudioDecoderConfig config;
     ASSERT_TRUE(AVCodecContextToAudioDecoderConfig(
         reader_->codec_context_for_testing(), Unencrypted(), &config));
 
 #if defined(OS_ANDROID) && defined(USE_PROPRIETARY_CODECS)
     // MEDIA_CODEC type requires config->extra_data() for AAC codec. For ADTS
     // streams we need to extract it with a separate procedure.
     if (GetParam().decoder_type == MEDIA_CODEC &&
         GetParam().codec == kCodecAAC && config.extra_data().empty()) {
-      size_t ignore_orig_sample_rate;
-      ASSERT_TRUE(ParseAdtsHeader(packet.data, false, &config,
-                                  &ignore_orig_sample_rate));
+      int sample_rate;
+      ChannelLayout channel_layout;
+      std::vector<uint8_t> extra_data;
+      ASSERT_GT(ADTSStreamParser().ParseFrameHeader(
+                    packet.data, packet.size, nullptr, &sample_rate,
+                    &channel_layout, nullptr, nullptr, &extra_data),
+                0);
+      config.Initialize(kCodecAAC, kSampleFormatS16, channel_layout,
+                        sample_rate, extra_data, Unencrypted(),
+                        base::TimeDelta(), 0);
       ASSERT_FALSE(config.extra_data().empty());
     }
 #endif
 
     av_packet_unref(&packet);
 
     EXPECT_EQ(GetParam().codec, config.codec());
     EXPECT_EQ(GetParam().samples_per_second, config.samples_per_second());
     EXPECT_EQ(GetParam().channel_layout, config.channel_layout());
 
@@ skipping 408 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderTest,
                         AudioDecoderTest,
                         testing::ValuesIn(kFFmpegTests));
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderBehavioralTest,
                         FFmpegAudioDecoderBehavioralTest,
                         testing::ValuesIn(kFFmpegBehavioralTest));
 
 }  // namespace media