Implement reading of media track info from WebM and MP4 containers

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>
 
@@ skipping 51 matching lines @@
             DecodeTimestamp::FromPresentationTime(base::TimeDelta::Max())) {
     std::set<int> audio_object_types;
     audio_object_types.insert(kISO_14496_3);
     parser_.reset(new MP4StreamParser(audio_object_types, false));
   }
 
  protected:
   scoped_refptr<StrictMock<MockMediaLog>> media_log_;
   scoped_ptr<MP4StreamParser> parser_;
   bool configs_received_;
+  scoped_ptr<MediaTracks> media_tracks_;
   AudioDecoderConfig audio_decoder_config_;
   VideoDecoderConfig video_decoder_config_;
   DecodeTimestamp lower_bound_;
 
   bool AppendData(const uint8_t* data, size_t length) {
     return parser_->Parse(data, length);
   }
 
   bool AppendDataInPieces(const uint8_t* data,
                           size_t length,
@@ skipping 13 matching lines @@
   void InitF(DemuxerStream::Liveness expected_liveness,
              const StreamParser::InitParameters& params) {
     DVLOG(1) << "InitF: dur=" << params.duration.InMilliseconds()
              << ", autoTimestampOffset=" << params.auto_update_timestamp_offset;
     EXPECT_EQ(expected_liveness, params.liveness);
   }
 
   bool NewConfigF(scoped_ptr<MediaTracks> tracks,
                   const StreamParser::TextTrackConfigMap& tc) {
     configs_received_ = true;
-    audio_decoder_config_ = tracks->getFirstAudioConfig();
-    video_decoder_config_ = tracks->getFirstVideoConfig();
-    DVLOG(1) << "NewConfigF: track count=" << tracks->tracks().size()
+    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()
              << " audio=" << audio_decoder_config_.IsValidConfig()
              << " video=" << video_decoder_config_.IsValidConfig();
     return true;
   }
 
   void DumpBuffers(const std::string& label,
                    const StreamParser::BufferQueue& buffers) {
     DVLOG(2) << "DumpBuffers: " << label << " size " << buffers.size();
     for (StreamParser::BufferQueue::const_iterator buf = buffers.begin();
          buf != buffers.end(); buf++) {
@@ skipping 278 matching lines @@
   // 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"));
+  ParseMP4File("bear-1280x720-av_frag.mp4", 4096);

[wolenetz, 2016/03/05 03:26:21]

nit: we probably need (for webm and mp4 across both src= and mp4 unit tests)
more test coverage / media for various language and label, at least. Can you
file a follow-up crbug to do this later please?

[servolk, 2016/03/07 23:45:01]

Opened crbug.com/592717 for tracking this.

[wolenetz, 2016/03/10 19:53:29]

Acknowledged.

+
+  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");
+}
+
 }  // namespace mp4
 }  // namespace media