src/cobalt/media/formats/mp2t/mp2t_stream_parser_unittest.cc - cobalt - Git at Google

 // 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/mp2t_stream_parser.h"

 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>

 #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_log.h"
 #include "media/base/media_track.h"
 #include "media/base/media_tracks.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 "starboard/types.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace cobalt {
 namespace media {
 namespace mp2t {

 namespace {

 bool IsMonotonic(const StreamParser::BufferQueue& buffers) {
   if (buffers.empty()) return true;

   StreamParser::BufferQueue::const_iterator it1 = buffers.begin();
   StreamParser::BufferQueue::const_iterator it2 = ++it1;
   for (; it2 != buffers.end(); ++it1, ++it2) {
     if ((*it2)->GetDecodeTimestamp() < (*it1)->GetDecodeTimestamp())
       return false;
   }
   return true;
 }

 bool IsAlmostEqual(DecodeTimestamp t0, DecodeTimestamp t1) {
   base::TimeDelta kMaxDeviation = base::TimeDelta::FromMilliseconds(5);
   base::TimeDelta diff = t1 - t0;
   return (diff >= -kMaxDeviation && diff <= kMaxDeviation);
 }

 }  // namespace

 class Mp2tStreamParserTest : public testing::Test {
  public:
   Mp2tStreamParserTest()
       : segment_count_(0),
         config_count_(0),
         audio_frame_count_(0),
         video_frame_count_(0),
         has_video_(true),
         audio_min_dts_(kNoDecodeTimestamp()),
         audio_max_dts_(kNoDecodeTimestamp()),
         video_min_dts_(kNoDecodeTimestamp()),
         video_max_dts_(kNoDecodeTimestamp()) {
     bool has_sbr = false;
     parser_.reset(new Mp2tStreamParser(has_sbr));
   }

  protected:
   std::unique_ptr<Mp2tStreamParser> parser_;
   int segment_count_;
   int config_count_;
   int audio_frame_count_;
   int video_frame_count_;
   bool has_video_;
   DecodeTimestamp audio_min_dts_;
   DecodeTimestamp audio_max_dts_;
   DecodeTimestamp video_min_dts_;
   DecodeTimestamp video_max_dts_;
   StreamParser::TrackId audio_track_id_;
   StreamParser::TrackId video_track_id_;

   void ResetStats() {
     segment_count_ = 0;
     config_count_ = 0;
     audio_frame_count_ = 0;
     video_frame_count_ = 0;
     audio_min_dts_ = kNoDecodeTimestamp();
     audio_max_dts_ = kNoDecodeTimestamp();
     video_min_dts_ = kNoDecodeTimestamp();
     video_max_dts_ = kNoDecodeTimestamp();
   }

   bool AppendData(const uint8_t* data, size_t length) {
     return parser_->Parse(data, length);
   }

   bool AppendDataInPieces(const uint8_t* data, size_t length,
                           size_t piece_size) {
     const uint8_t* start = data;
     const uint8_t* end = data + length;
     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 OnInit(const StreamParser::InitParameters& params) {
     DVLOG(1) << "OnInit: dur=" << params.duration.InMilliseconds()
              << ", autoTimestampOffset=" << params.auto_update_timestamp_offset;
   }

   bool OnNewConfig(std::unique_ptr<MediaTracks> tracks,
                    const StreamParser::TextTrackConfigMap& tc) {
     DVLOG(1) << "OnNewConfig: got " << tracks->tracks().size() << " tracks";
     bool found_audio_track = false;
     bool found_video_track = false;
     for (const auto& track : tracks->tracks()) {
       const auto& track_id = track->bytestream_track_id();
       if (track->type() == MediaTrack::Audio) {
         audio_track_id_ = track_id;
         found_audio_track = true;
         EXPECT_TRUE(tracks->getAudioConfig(track_id).IsValidConfig());
       } else if (track->type() == MediaTrack::Video) {
         video_track_id_ = track_id;
         found_video_track = true;
         EXPECT_TRUE(tracks->getVideoConfig(track_id).IsValidConfig());
       } else {
         // Unexpected track type.
         LOG(ERROR) << "Unexpected track type " << track->type();
         EXPECT_TRUE(false);
       }
     }
     EXPECT_TRUE(found_audio_track);
     EXPECT_EQ(has_video_, found_video_track);
     config_count_++;
     return true;
   }

   bool OnNewBuffers(const StreamParser::BufferQueueMap& buffer_queue_map) {
     EXPECT_GT(config_count_, 0);
     // Ensure that track ids are properly assigned on all emitted buffers.
     for (const auto& it : buffer_queue_map) {
       DVLOG(3) << "Buffers for track_id=" << it.first;
       for (const auto& buf : it.second) {
         DVLOG(3) << "  track_id=" << buf->track_id()
                  << ", size=" << buf->data_size()
                  << ", pts=" << buf->timestamp().InSecondsF()
                  << ", dts=" << buf->GetDecodeTimestamp().InSecondsF()
                  << ", dur=" << buf->duration().InSecondsF();
         EXPECT_EQ(it.first, buf->track_id());
       }
     }

     const StreamParser::BufferQueue empty_buffers;
     const auto& itr_audio = buffer_queue_map.find(audio_track_id_);
     const StreamParser::BufferQueue& audio_buffers =
         (itr_audio == buffer_queue_map.end()) ? empty_buffers
                                               : itr_audio->second;

     const auto& itr_video = buffer_queue_map.find(video_track_id_);
     const StreamParser::BufferQueue& video_buffers =
         (itr_video == buffer_queue_map.end()) ? empty_buffers
                                               : itr_video->second;

     // Verify monotonicity.
     if (!IsMonotonic(video_buffers)) return false;
     if (!IsMonotonic(audio_buffers)) return false;

     if (!video_buffers.empty()) {
       DecodeTimestamp first_dts = video_buffers.front()->GetDecodeTimestamp();
       DecodeTimestamp last_dts = video_buffers.back()->GetDecodeTimestamp();
       if (video_max_dts_ != kNoDecodeTimestamp() && first_dts < video_max_dts_)
         return false;
       if (video_min_dts_ == kNoDecodeTimestamp()) video_min_dts_ = first_dts;
       video_max_dts_ = last_dts;
     }
     if (!audio_buffers.empty()) {
       DecodeTimestamp first_dts = audio_buffers.front()->GetDecodeTimestamp();
       DecodeTimestamp last_dts = audio_buffers.back()->GetDecodeTimestamp();
       if (audio_max_dts_ != kNoDecodeTimestamp() && first_dts < audio_max_dts_)
         return false;
       if (audio_min_dts_ == kNoDecodeTimestamp()) audio_min_dts_ = first_dts;
       audio_max_dts_ = last_dts;
     }

     audio_frame_count_ += audio_buffers.size();
     video_frame_count_ += video_buffers.size();
     return true;
   }

   void OnKeyNeeded(EmeInitDataType type,
                    const std::vector<uint8_t>& init_data) {
     LOG(ERROR) << "OnKeyNeeded not expected in the Mpeg2 TS parser";
     EXPECT_TRUE(false);
   }

   void OnNewSegment() {
     DVLOG(1) << "OnNewSegment";
     segment_count_++;
   }

   void OnEndOfSegment() {
     LOG(ERROR) << "OnEndOfSegment not expected in the Mpeg2 TS parser";
     EXPECT_TRUE(false);
   }

   void InitializeParser() {
     parser_->Init(
         base::Bind(&Mp2tStreamParserTest::OnInit, base::Unretained(this)),
         base::Bind(&Mp2tStreamParserTest::OnNewConfig, base::Unretained(this)),
         base::Bind(&Mp2tStreamParserTest::OnNewBuffers, base::Unretained(this)),
         true,
         base::Bind(&Mp2tStreamParserTest::OnKeyNeeded, base::Unretained(this)),
         base::Bind(&Mp2tStreamParserTest::OnNewSegment, base::Unretained(this)),
         base::Bind(&Mp2tStreamParserTest::OnEndOfSegment,
                    base::Unretained(this)),
         new MediaLog());
   }

   bool ParseMpeg2TsFile(const std::string& filename, int append_bytes) {
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
     EXPECT_TRUE(
         AppendDataInPieces(buffer->data(), buffer->data_size(), append_bytes));
     return true;
   }
 };

 TEST_F(Mp2tStreamParserTest, UnalignedAppend17) {
   // Test small, non-segment-aligned appends.
   InitializeParser();
   ParseMpeg2TsFile("bear-1280x720.ts", 17);
   parser_->Flush();
   EXPECT_EQ(video_frame_count_, 82);
   // This stream has no mid-stream configuration change.
   EXPECT_EQ(config_count_, 1);
   EXPECT_EQ(segment_count_, 1);
 }

 TEST_F(Mp2tStreamParserTest, UnalignedAppend512) {
   // Test small, non-segment-aligned appends.
   InitializeParser();
   ParseMpeg2TsFile("bear-1280x720.ts", 512);
   parser_->Flush();
   EXPECT_EQ(video_frame_count_, 82);
   // This stream has no mid-stream configuration change.
   EXPECT_EQ(config_count_, 1);
   EXPECT_EQ(segment_count_, 1);
 }

 TEST_F(Mp2tStreamParserTest, AppendAfterFlush512) {
   InitializeParser();
   ParseMpeg2TsFile("bear-1280x720.ts", 512);
   parser_->Flush();
   EXPECT_EQ(video_frame_count_, 82);
   EXPECT_EQ(config_count_, 1);
   EXPECT_EQ(segment_count_, 1);

   ResetStats();
   ParseMpeg2TsFile("bear-1280x720.ts", 512);
   parser_->Flush();
   EXPECT_EQ(video_frame_count_, 82);
   EXPECT_EQ(config_count_, 1);
   EXPECT_EQ(segment_count_, 1);
 }

 TEST_F(Mp2tStreamParserTest, TimestampWrapAround) {
   // "bear-1280x720_ptswraparound.ts" has been transcoded
   // from bear-1280x720.mp4 by applying a time offset of 95442s
   // (close to 2^33 / 90000) which results in timestamps wrap around
   // in the Mpeg2 TS stream.
   InitializeParser();
   ParseMpeg2TsFile("bear-1280x720_ptswraparound.ts", 512);
   parser_->Flush();
   EXPECT_EQ(video_frame_count_, 82);

   EXPECT_TRUE(
       IsAlmostEqual(video_min_dts_, DecodeTimestamp::FromSecondsD(95443.376)));
   EXPECT_TRUE(
       IsAlmostEqual(video_max_dts_, DecodeTimestamp::FromSecondsD(95446.079)));

   // Note: for audio, AdtsStreamParser considers only the PTS (which is then
   // used as the DTS).
   // TODO(damienv): most of the time, audio streams just have PTS. Here, only
   // the first PES packet has a DTS, all the other PES packets have PTS only.
   // Reconsider the expected value for |audio_min_dts_| if DTS are used as part
   // of the ADTS stream parser.
   //
   // Note: the last pts for audio is 95445.931 but this PES packet includes
   // 9 ADTS frames with 1 AAC frame in each ADTS frame.
   // So the PTS of the last AAC frame is:
   // 95445.931 + 8 * (1024 / 44100) = 95446.117
   EXPECT_TRUE(
       IsAlmostEqual(audio_min_dts_, DecodeTimestamp::FromSecondsD(95443.400)));
   EXPECT_TRUE(
       IsAlmostEqual(audio_max_dts_, DecodeTimestamp::FromSecondsD(95446.117)));
 }

 TEST_F(Mp2tStreamParserTest, AudioInPrivateStream1) {
   // Test small, non-segment-aligned appends.
   InitializeParser();
   has_video_ = false;
   ParseMpeg2TsFile("bear_adts_in_private_stream_1.ts", 512);
   parser_->Flush();
   EXPECT_EQ(audio_frame_count_, 40);
   EXPECT_EQ(video_frame_count_, 0);
   // This stream has no mid-stream configuration change.
   EXPECT_EQ(config_count_, 1);
   EXPECT_EQ(segment_count_, 1);
 }

 }  // namespace mp2t
 }  // namespace media
 }  // namespace cobalt
	// 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/mp2t_stream_parser.h"

	#include <algorithm>
	#include <memory>
	#include <string>
	#include <vector>

	#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_log.h"
	#include "media/base/media_track.h"
	#include "media/base/media_tracks.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 "starboard/types.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace cobalt {
	namespace media {
	namespace mp2t {

	namespace {

	bool IsMonotonic(const StreamParser::BufferQueue& buffers) {
	if (buffers.empty()) return true;

	StreamParser::BufferQueue::const_iterator it1 = buffers.begin();
	StreamParser::BufferQueue::const_iterator it2 = ++it1;
	for (; it2 != buffers.end(); ++it1, ++it2) {
	if ((it2)->GetDecodeTimestamp() < (it1)->GetDecodeTimestamp())
	return false;
	}
	return true;
	}

	bool IsAlmostEqual(DecodeTimestamp t0, DecodeTimestamp t1) {
	base::TimeDelta kMaxDeviation = base::TimeDelta::FromMilliseconds(5);
	base::TimeDelta diff = t1 - t0;
	return (diff >= -kMaxDeviation && diff <= kMaxDeviation);
	}

	} // namespace

	class Mp2tStreamParserTest : public testing::Test {
	public:
	Mp2tStreamParserTest()
	: segment_count_(0),
	config_count_(0),
	audio_frame_count_(0),
	video_frame_count_(0),
	has_video_(true),
	audio_min_dts_(kNoDecodeTimestamp()),
	audio_max_dts_(kNoDecodeTimestamp()),
	video_min_dts_(kNoDecodeTimestamp()),
	video_max_dts_(kNoDecodeTimestamp()) {
	bool has_sbr = false;
	parser_.reset(new Mp2tStreamParser(has_sbr));
	}

	protected:
	std::unique_ptr<Mp2tStreamParser> parser_;
	int segment_count_;
	int config_count_;
	int audio_frame_count_;
	int video_frame_count_;
	bool has_video_;
	DecodeTimestamp audio_min_dts_;
	DecodeTimestamp audio_max_dts_;
	DecodeTimestamp video_min_dts_;
	DecodeTimestamp video_max_dts_;
	StreamParser::TrackId audio_track_id_;
	StreamParser::TrackId video_track_id_;

	void ResetStats() {
	segment_count_ = 0;
	config_count_ = 0;
	audio_frame_count_ = 0;
	video_frame_count_ = 0;
	audio_min_dts_ = kNoDecodeTimestamp();
	audio_max_dts_ = kNoDecodeTimestamp();
	video_min_dts_ = kNoDecodeTimestamp();
	video_max_dts_ = kNoDecodeTimestamp();
	}

	bool AppendData(const uint8_t* data, size_t length) {
	return parser_->Parse(data, length);
	}

	bool AppendDataInPieces(const uint8_t* data, size_t length,
	size_t piece_size) {
	const uint8_t* start = data;
	const uint8_t* end = data + length;
	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 OnInit(const StreamParser::InitParameters& params) {
	DVLOG(1) << "OnInit: dur=" << params.duration.InMilliseconds()
	<< ", autoTimestampOffset=" << params.auto_update_timestamp_offset;
	}

	bool OnNewConfig(std::unique_ptr<MediaTracks> tracks,
	const StreamParser::TextTrackConfigMap& tc) {
	DVLOG(1) << "OnNewConfig: got " << tracks->tracks().size() << " tracks";
	bool found_audio_track = false;
	bool found_video_track = false;
	for (const auto& track : tracks->tracks()) {
	const auto& track_id = track->bytestream_track_id();
	if (track->type() == MediaTrack::Audio) {
	audio_track_id_ = track_id;
	found_audio_track = true;
	EXPECT_TRUE(tracks->getAudioConfig(track_id).IsValidConfig());
	} else if (track->type() == MediaTrack::Video) {
	video_track_id_ = track_id;
	found_video_track = true;
	EXPECT_TRUE(tracks->getVideoConfig(track_id).IsValidConfig());
	} else {
	// Unexpected track type.
	LOG(ERROR) << "Unexpected track type " << track->type();
	EXPECT_TRUE(false);
	}
	}
	EXPECT_TRUE(found_audio_track);
	EXPECT_EQ(has_video_, found_video_track);
	config_count_++;
	return true;
	}

	bool OnNewBuffers(const StreamParser::BufferQueueMap& buffer_queue_map) {
	EXPECT_GT(config_count_, 0);
	// Ensure that track ids are properly assigned on all emitted buffers.
	for (const auto& it : buffer_queue_map) {
	DVLOG(3) << "Buffers for track_id=" << it.first;
	for (const auto& buf : it.second) {
	DVLOG(3) << " track_id=" << buf->track_id()
	<< ", size=" << buf->data_size()
	<< ", pts=" << buf->timestamp().InSecondsF()
	<< ", dts=" << buf->GetDecodeTimestamp().InSecondsF()
	<< ", dur=" << buf->duration().InSecondsF();
	EXPECT_EQ(it.first, buf->track_id());
	}
	}

	const StreamParser::BufferQueue empty_buffers;
	const auto& itr_audio = buffer_queue_map.find(audio_track_id_);
	const StreamParser::BufferQueue& audio_buffers =
	(itr_audio == buffer_queue_map.end()) ? empty_buffers
	: itr_audio->second;

	const auto& itr_video = buffer_queue_map.find(video_track_id_);
	const StreamParser::BufferQueue& video_buffers =
	(itr_video == buffer_queue_map.end()) ? empty_buffers
	: itr_video->second;

	// Verify monotonicity.
	if (!IsMonotonic(video_buffers)) return false;
	if (!IsMonotonic(audio_buffers)) return false;

	if (!video_buffers.empty()) {
	DecodeTimestamp first_dts = video_buffers.front()->GetDecodeTimestamp();
	DecodeTimestamp last_dts = video_buffers.back()->GetDecodeTimestamp();
	if (video_max_dts_ != kNoDecodeTimestamp() && first_dts < video_max_dts_)
	return false;
	if (video_min_dts_ == kNoDecodeTimestamp()) video_min_dts_ = first_dts;
	video_max_dts_ = last_dts;
	}
	if (!audio_buffers.empty()) {
	DecodeTimestamp first_dts = audio_buffers.front()->GetDecodeTimestamp();
	DecodeTimestamp last_dts = audio_buffers.back()->GetDecodeTimestamp();
	if (audio_max_dts_ != kNoDecodeTimestamp() && first_dts < audio_max_dts_)
	return false;
	if (audio_min_dts_ == kNoDecodeTimestamp()) audio_min_dts_ = first_dts;
	audio_max_dts_ = last_dts;
	}

	audio_frame_count_ += audio_buffers.size();
	video_frame_count_ += video_buffers.size();
	return true;
	}

	void OnKeyNeeded(EmeInitDataType type,
	const std::vector<uint8_t>& init_data) {
	LOG(ERROR) << "OnKeyNeeded not expected in the Mpeg2 TS parser";
	EXPECT_TRUE(false);
	}

	void OnNewSegment() {
	DVLOG(1) << "OnNewSegment";
	segment_count_++;
	}

	void OnEndOfSegment() {
	LOG(ERROR) << "OnEndOfSegment not expected in the Mpeg2 TS parser";
	EXPECT_TRUE(false);
	}

	void InitializeParser() {
	parser_->Init(
	base::Bind(&Mp2tStreamParserTest::OnInit, base::Unretained(this)),
	base::Bind(&Mp2tStreamParserTest::OnNewConfig, base::Unretained(this)),
	base::Bind(&Mp2tStreamParserTest::OnNewBuffers, base::Unretained(this)),
	true,
	base::Bind(&Mp2tStreamParserTest::OnKeyNeeded, base::Unretained(this)),
	base::Bind(&Mp2tStreamParserTest::OnNewSegment, base::Unretained(this)),
	base::Bind(&Mp2tStreamParserTest::OnEndOfSegment,
	base::Unretained(this)),
	new MediaLog());
	}

	bool ParseMpeg2TsFile(const std::string& filename, int append_bytes) {
	scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
	EXPECT_TRUE(
	AppendDataInPieces(buffer->data(), buffer->data_size(), append_bytes));
	return true;
	}
	};

	TEST_F(Mp2tStreamParserTest, UnalignedAppend17) {
	// Test small, non-segment-aligned appends.
	InitializeParser();
	ParseMpeg2TsFile("bear-1280x720.ts", 17);
	parser_->Flush();
	EXPECT_EQ(video_frame_count_, 82);
	// This stream has no mid-stream configuration change.
	EXPECT_EQ(config_count_, 1);
	EXPECT_EQ(segment_count_, 1);
	}

	TEST_F(Mp2tStreamParserTest, UnalignedAppend512) {
	// Test small, non-segment-aligned appends.
	InitializeParser();
	ParseMpeg2TsFile("bear-1280x720.ts", 512);
	parser_->Flush();
	EXPECT_EQ(video_frame_count_, 82);
	// This stream has no mid-stream configuration change.
	EXPECT_EQ(config_count_, 1);
	EXPECT_EQ(segment_count_, 1);
	}

	TEST_F(Mp2tStreamParserTest, AppendAfterFlush512) {
	InitializeParser();
	ParseMpeg2TsFile("bear-1280x720.ts", 512);
	parser_->Flush();
	EXPECT_EQ(video_frame_count_, 82);
	EXPECT_EQ(config_count_, 1);
	EXPECT_EQ(segment_count_, 1);

	ResetStats();
	ParseMpeg2TsFile("bear-1280x720.ts", 512);
	parser_->Flush();
	EXPECT_EQ(video_frame_count_, 82);
	EXPECT_EQ(config_count_, 1);
	EXPECT_EQ(segment_count_, 1);
	}

	TEST_F(Mp2tStreamParserTest, TimestampWrapAround) {
	// "bear-1280x720_ptswraparound.ts" has been transcoded
	// from bear-1280x720.mp4 by applying a time offset of 95442s
	// (close to 2^33 / 90000) which results in timestamps wrap around
	// in the Mpeg2 TS stream.
	InitializeParser();
	ParseMpeg2TsFile("bear-1280x720_ptswraparound.ts", 512);
	parser_->Flush();
	EXPECT_EQ(video_frame_count_, 82);

	EXPECT_TRUE(
	IsAlmostEqual(video_min_dts_, DecodeTimestamp::FromSecondsD(95443.376)));
	EXPECT_TRUE(
	IsAlmostEqual(video_max_dts_, DecodeTimestamp::FromSecondsD(95446.079)));

	// Note: for audio, AdtsStreamParser considers only the PTS (which is then
	// used as the DTS).
	// TODO(damienv): most of the time, audio streams just have PTS. Here, only
	// the first PES packet has a DTS, all the other PES packets have PTS only.
	// Reconsider the expected value for \|audio_min_dts_\| if DTS are used as part
	// of the ADTS stream parser.
	//
	// Note: the last pts for audio is 95445.931 but this PES packet includes
	// 9 ADTS frames with 1 AAC frame in each ADTS frame.
	// So the PTS of the last AAC frame is:
	// 95445.931 + 8 * (1024 / 44100) = 95446.117
	EXPECT_TRUE(
	IsAlmostEqual(audio_min_dts_, DecodeTimestamp::FromSecondsD(95443.400)));
	EXPECT_TRUE(
	IsAlmostEqual(audio_max_dts_, DecodeTimestamp::FromSecondsD(95446.117)));
	}

	TEST_F(Mp2tStreamParserTest, AudioInPrivateStream1) {
	// Test small, non-segment-aligned appends.
	InitializeParser();
	has_video_ = false;
	ParseMpeg2TsFile("bear_adts_in_private_stream_1.ts", 512);
	parser_->Flush();
	EXPECT_EQ(audio_frame_count_, 40);
	EXPECT_EQ(video_frame_count_, 0);
	// This stream has no mid-stream configuration change.
	EXPECT_EQ(config_count_, 1);
	EXPECT_EQ(segment_count_, 1);
	}

	} // namespace mp2t
	} // namespace media
	} // namespace cobalt