MSE: Record counts of detected MSE audio, video and text tracks

media/formats/mp4/mp4_stream_parser_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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_track.h"
 #include "media/base/media_tracks.h"
 #include "media/base/mock_media_log.h"
+#include "media/base/stream_parser.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/base/text_track_config.h"
 #include "media/base/video_decoder_config.h"
 #include "media/formats/mp4/es_descriptor.h"
 #include "media/formats/mp4/fourccs.h"
 #include "media/formats/mp4/mp4_stream_parser.h"
 #include "media/media_features.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 55 matching lines @@
     while (start < end) {
       size_t append_size = std::min(piece_size,
                                     static_cast<size_t>(end - start));
       if (!AppendData(start, append_size))
         return false;
       start += append_size;
     }
     return true;
   }
 
-  void InitF(DemuxerStream::Liveness expected_liveness,
+  void InitF(const StreamParser::InitParameters& expected_params,
              const StreamParser::InitParameters& params) {
-    DVLOG(1) << "InitF: dur=" << params.duration.InMilliseconds()
+    DVLOG(1) << "InitF: dur=" << params.duration.InMicroseconds()
              << ", autoTimestampOffset=" << params.auto_update_timestamp_offset;
-    EXPECT_EQ(expected_liveness, params.liveness);
+    EXPECT_EQ(expected_params.duration, params.duration);
+    EXPECT_EQ(expected_params.timeline_offset, params.timeline_offset);
+    EXPECT_EQ(expected_params.auto_update_timestamp_offset,
+              params.auto_update_timestamp_offset);
+    EXPECT_EQ(expected_params.liveness, params.liveness);
+    EXPECT_EQ(expected_params.detected_audio_track_count,
+              params.detected_audio_track_count);
+    EXPECT_EQ(expected_params.detected_video_track_count,
+              params.detected_video_track_count);
+    EXPECT_EQ(expected_params.detected_text_track_count,
+              params.detected_text_track_count);
   }
 
   bool NewConfigF(scoped_ptr<MediaTracks> tracks,
                   const StreamParser::TextTrackConfigMap& tc) {
     configs_received_ = true;
     CHECK(tracks.get());
     media_tracks_ = std::move(tracks);
     audio_decoder_config_ = media_tracks_->getFirstAudioConfig();
     video_decoder_config_ = media_tracks_->getFirstVideoConfig();
     DVLOG(1) << "NewConfigF: track count=" << media_tracks_->tracks().size()
@@ skipping 55 matching lines @@
     DVLOG(1) << "NewSegmentF";
     lower_bound_ = kNoDecodeTimestamp();
   }
 
   void EndOfSegmentF() {
     DVLOG(1) << "EndOfSegmentF()";
     lower_bound_ =
         DecodeTimestamp::FromPresentationTime(base::TimeDelta::Max());
   }
 
-  void InitializeParserAndExpectLiveness(
-      DemuxerStream::Liveness expected_liveness) {
+  void InitializeParserWithInitParametersExpectations(
+      StreamParser::InitParameters params) {
     parser_->Init(
-        base::Bind(&MP4StreamParserTest::InitF, base::Unretained(this),
-                   expected_liveness),
+        base::Bind(&MP4StreamParserTest::InitF, base::Unretained(this), params),
         base::Bind(&MP4StreamParserTest::NewConfigF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::NewBuffersF, base::Unretained(this)),
         true,
         base::Bind(&MP4StreamParserTest::KeyNeededF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::NewSegmentF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::EndOfSegmentF, base::Unretained(this)),
         media_log_);
   }
 
-  void InitializeParser() {
+  StreamParser::InitParameters GetDefaultInitParametersExpectations() {
     // Most unencrypted test mp4 files have zero duration and are treated as
     // live streams.
-    InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_LIVE);
+    StreamParser::InitParameters params(kInfiniteDuration());
+    params.liveness = DemuxerStream::LIVENESS_LIVE;
+    params.detected_audio_track_count = 1;
+    params.detected_video_track_count = 1;
+    params.detected_text_track_count = 0;
+    return params;
+  }
+
+  void InitializeParserAndExpectLiveness(DemuxerStream::Liveness liveness) {
+    auto params = GetDefaultInitParametersExpectations();
+    params.liveness = liveness;
+    InitializeParserWithInitParametersExpectations(params);
+  }
+
+  void InitializeParser() {
+    InitializeParserWithInitParametersExpectations(
+        GetDefaultInitParametersExpectations());
   }
 
   bool ParseMP4File(const std::string& filename, int append_bytes) {
-    InitializeParser();
-
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
     EXPECT_TRUE(AppendDataInPieces(buffer->data(),
                                    buffer->data_size(),
                                    append_bytes));
     return true;
   }
 };
 
 TEST_F(MP4StreamParserTest, UnalignedAppend) {
   // Test small, non-segment-aligned appends (small enough to exercise
   // incremental append system)
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
+  InitializeParser();
   ParseMP4File("bear-1280x720-av_frag.mp4", 512);
 }
 
 TEST_F(MP4StreamParserTest, BytewiseAppend) {
   // Ensure no incremental errors occur when parsing
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
+  InitializeParser();
   ParseMP4File("bear-1280x720-av_frag.mp4", 1);
 }
 
 TEST_F(MP4StreamParserTest, MultiFragmentAppend) {
   // Large size ensures multiple fragments are appended in one call (size is
   // larger than this particular test file)
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
+  InitializeParser();
   ParseMP4File("bear-1280x720-av_frag.mp4", 768432);
 }
 
 TEST_F(MP4StreamParserTest, Flush) {
   // Flush while reading sample data, then start a new stream.
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F")).Times(2);
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2")).Times(2);
   InitializeParser();
 
   scoped_refptr<DecoderBuffer> buffer =
@@ skipping 20 matching lines @@
                                  512));
 }
 
 TEST_F(MP4StreamParserTest, MPEG2_AAC_LC) {
   InSequence s;
   std::set<int> audio_object_types;
   audio_object_types.insert(kISO_13818_7_AAC_LC);
   parser_.reset(new MP4StreamParser(audio_object_types, false));
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.67"));
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
+  auto params = GetDefaultInitParametersExpectations();
+  params.detected_video_track_count = 0;
+  InitializeParserWithInitParametersExpectations(params);
   ParseMP4File("bear-mpeg2-aac-only_frag.mp4", 512);
 }
 
 // Test that a moov box is not always required after Flush() is called.
 TEST_F(MP4StreamParserTest, NoMoovAfterFlush) {
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
   InitializeParser();
 
   scoped_refptr<DecoderBuffer> buffer =
@@ skipping 11 matching lines @@
 
 // Test an invalid file where there are encrypted samples, but
 // SampleEncryptionBox (senc) and SampleAuxiliaryInformation{Sizes|Offsets}Box
 // (saiz|saio) are missing.
 // The parser should fail instead of crash. See http://crbug.com/361347
 TEST_F(MP4StreamParserTest, MissingSampleEncryptionInfo) {
   InSequence s;
 
   // Encrypted test mp4 files have non-zero duration and are treated as
   // recorded streams.
-  InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
+  auto params = GetDefaultInitParametersExpectations();
+  params.duration = base::TimeDelta::FromMicroseconds(23219);
+  params.liveness = DemuxerStream::LIVENESS_RECORDED;
+  params.detected_video_track_count = 0;
+  InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-a_frag-cenc_missing-saiz-saio.mp4");
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2")).Times(2);
   EXPECT_MEDIA_LOG(SampleEncryptionInfoUnavailableLog());
   EXPECT_FALSE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 // Test a file where all video samples start with an Access Unit
 // Delimiter (AUD) NALU.
 TEST_F(MP4StreamParserTest, VideoSamplesStartWithAUDs) {
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.4D4028"));
+  auto params = GetDefaultInitParametersExpectations();
+  params.detected_audio_track_count = 0;
+  InitializeParserWithInitParametersExpectations(params);
   ParseMP4File("bear-1280x720-av_with-aud-nalus_frag.mp4", 512);
 }
 
 TEST_F(MP4StreamParserTest, HEVC_in_MP4_container) {
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   bool expect_success = true;
   EXPECT_MEDIA_LOG(VideoCodecLog("hevc"));
 #else
   bool expect_success = false;
   EXPECT_MEDIA_LOG(ErrorLog("Parse unsupported video format hev1"));
 #endif
-  InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
+  auto params = GetDefaultInitParametersExpectations();
+  params.duration = base::TimeDelta::FromMicroseconds(1002000);
+  params.liveness = DemuxerStream::LIVENESS_RECORDED;
+  params.detected_audio_track_count = 0;
+  InitializeParserWithInitParametersExpectations(params);
+
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("bear-hevc-frag.mp4");
   EXPECT_EQ(expect_success,
             AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 // Sample encryption information is stored as CencSampleAuxiliaryDataFormat
 // (ISO/IEC 23001-7:2015 8) inside 'mdat' box. No SampleEncryption ('senc') box.
 TEST_F(MP4StreamParserTest, CencWithEncryptionInfoStoredAsAuxDataInMdat) {
   // Encrypted test mp4 files have non-zero duration and are treated as
   // recorded streams.
-  InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
+  auto params = GetDefaultInitParametersExpectations();
+  params.duration = base::TimeDelta::FromMicroseconds(2736066);
+  params.liveness = DemuxerStream::LIVENESS_RECORDED;
+  params.detected_audio_track_count = 0;
+  InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 TEST_F(MP4StreamParserTest, CencWithSampleEncryptionBox) {
   // Encrypted test mp4 files have non-zero duration and are treated as
   // recorded streams.
-  InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
+  auto params = GetDefaultInitParametersExpectations();
+  params.duration = base::TimeDelta::FromMicroseconds(2736066);
+  params.liveness = DemuxerStream::LIVENESS_RECORDED;
+  params.detected_audio_track_count = 0;
+  InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-640x360-v_frag-cenc-senc.mp4");
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001E"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 TEST_F(MP4StreamParserTest, NaturalSizeWithoutPASP) {
-  InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
+  auto params = GetDefaultInitParametersExpectations();
+  params.duration = base::TimeDelta::FromMicroseconds(1000966);
+  params.liveness = DemuxerStream::LIVENESS_RECORDED;
+  params.detected_audio_track_count = 0;
+  InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-640x360-non_square_pixel-without_pasp.mp4");
 
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001E"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
   EXPECT_EQ(gfx::Size(639, 360), video_decoder_config_.natural_size());
 }
 
 TEST_F(MP4StreamParserTest, NaturalSizeWithPASP) {
-  InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
+  auto params = GetDefaultInitParametersExpectations();
+  params.duration = base::TimeDelta::FromMicroseconds(1000966);
+  params.liveness = DemuxerStream::LIVENESS_RECORDED;
+  params.detected_audio_track_count = 0;
+  InitializeParserWithInitParametersExpectations(params);
 
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-640x360-non_square_pixel-with_pasp.mp4");
 
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001E"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
   EXPECT_EQ(gfx::Size(639, 360), video_decoder_config_.natural_size());
 }
 
 TEST_F(MP4StreamParserTest, DemuxingAC3) {
   std::set<int> audio_object_types;
   audio_object_types.insert(kAC3);
   parser_.reset(new MP4StreamParser(audio_object_types, false));
 
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
   bool expect_success = true;
 #else
   bool expect_success = false;
   EXPECT_MEDIA_LOG(ErrorLog("Unsupported audio format 0x61632d33 in stsd box"));
 #endif
 
-  InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
+  auto params = GetDefaultInitParametersExpectations();
+  params.duration = base::TimeDelta::FromMicroseconds(1045000);
+  params.liveness = DemuxerStream::LIVENESS_RECORDED;
+  params.detected_video_track_count = 0;
+  InitializeParserWithInitParametersExpectations(params);
+
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-ac3-only-frag.mp4");
   EXPECT_EQ(expect_success,
             AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 TEST_F(MP4StreamParserTest, DemuxingEAC3) {
   std::set<int> audio_object_types;
   audio_object_types.insert(kEAC3);
   parser_.reset(new MP4StreamParser(audio_object_types, false));
 
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
   bool expect_success = true;
 #else
   bool expect_success = false;
   EXPECT_MEDIA_LOG(ErrorLog("Unsupported audio format 0x65632d33 in stsd box"));
 #endif
 
-  InitializeParserAndExpectLiveness(DemuxerStream::LIVENESS_RECORDED);
+  auto params = GetDefaultInitParametersExpectations();
+  params.duration = base::TimeDelta::FromMicroseconds(1045000);
+  params.liveness = DemuxerStream::LIVENESS_RECORDED;
+  params.detected_video_track_count = 0;
+  InitializeParserWithInitParametersExpectations(params);
+
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-eac3-only-frag.mp4");
   EXPECT_EQ(expect_success,
             AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 TEST_F(MP4StreamParserTest, FourCCToString) {
   // A real FOURCC should print.
   EXPECT_EQ("mvex", FourCCToString(FOURCC_MVEX));
 
   // Invalid FOURCC should also print whenever ASCII values are printable.
   EXPECT_EQ("fake", FourCCToString(static_cast<FourCC>(0x66616b65)));
 
   // Invalid FORCC with non-printable values should not give error message.
   EXPECT_EQ("0x66616b00", FourCCToString(static_cast<FourCC>(0x66616b00)));
 }
 
 TEST_F(MP4StreamParserTest, MediaTrackInfoSourcing) {
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
+  InitializeParser();
   ParseMP4File("bear-1280x720-av_frag.mp4", 4096);
 
   EXPECT_EQ(media_tracks_->tracks().size(), 2u);
   const MediaTrack& video_track = *(media_tracks_->tracks()[0]);
   EXPECT_EQ(video_track.type(), MediaTrack::Video);
   EXPECT_EQ(video_track.id(), "1");
   EXPECT_EQ(video_track.kind(), "main");
   EXPECT_EQ(video_track.label(), "VideoHandler");
   EXPECT_EQ(video_track.language(), "und");
 
   const MediaTrack& audio_track = *(media_tracks_->tracks()[1]);
   EXPECT_EQ(audio_track.type(), MediaTrack::Audio);
   EXPECT_EQ(audio_track.id(), "2");
   EXPECT_EQ(audio_track.kind(), "main");
   EXPECT_EQ(audio_track.label(), "SoundHandler");
   EXPECT_EQ(audio_track.language(), "und");
 }
 
+TEST_F(MP4StreamParserTest, TextTrackDetection) {
+  auto params = GetDefaultInitParametersExpectations();
+  params.detected_text_track_count = 1;
+  InitializeParserWithInitParametersExpectations(params);
+
+  scoped_refptr<DecoderBuffer> buffer =
+      ReadTestDataFile("bear-1280x720-avt_subt_frag.mp4");
+
+  EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
+  EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
+  EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
+}
+
 }  // namespace mp4
 }  // namespace media