1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/at_exit.h"
6 #include "base/bind.h"
7 #include "base/message_loop/message_loop.h"
8 #include "base/strings/string_number_conversions.h"
9 #include "base/time/time.h"
10 #include "media/base/media.h"
11 #include "media/base/media_log.h"
12 #include "media/base/test_data_util.h"
13 #include "media/filters/ffmpeg_demuxer.h"
14 #include "media/filters/file_data_source.h"
15 #include "testing/gtest/include/gtest/gtest.h"
16 #include "testing/perf/perf_test.h"
17
18 namespace media {
19
20 static const int kBenchmarkIterations = 100;
21
22 class DemuxerHostImpl : public media::DemuxerHost {
23 public:
DemuxerHostImpl()24 DemuxerHostImpl() {}
~DemuxerHostImpl()25 virtual ~DemuxerHostImpl() {}
26
27 // DemuxerHost implementation.
AddBufferedTimeRange(base::TimeDelta start,base::TimeDelta end)28 virtual void AddBufferedTimeRange(base::TimeDelta start,
29 base::TimeDelta end) OVERRIDE {}
SetDuration(base::TimeDelta duration)30 virtual void SetDuration(base::TimeDelta duration) OVERRIDE {}
OnDemuxerError(media::PipelineStatus error)31 virtual void OnDemuxerError(media::PipelineStatus error) OVERRIDE {}
AddTextStream(media::DemuxerStream * text_stream,const media::TextTrackConfig & config)32 virtual void AddTextStream(media::DemuxerStream* text_stream,
33 const media::TextTrackConfig& config) OVERRIDE {}
RemoveTextStream(media::DemuxerStream * text_stream)34 virtual void RemoveTextStream(media::DemuxerStream* text_stream) OVERRIDE {}
35
36 private:
37 DISALLOW_COPY_AND_ASSIGN(DemuxerHostImpl);
38 };
39
QuitLoopWithStatus(base::MessageLoop * message_loop,media::PipelineStatus status)40 static void QuitLoopWithStatus(base::MessageLoop* message_loop,
41 media::PipelineStatus status) {
42 CHECK_EQ(status, media::PIPELINE_OK);
43 message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
44 }
45
NeedKey(const std::string & type,const std::vector<uint8> & init_data)46 static void NeedKey(const std::string& type,
47 const std::vector<uint8>& init_data) {
48 VLOG(0) << "File is encrypted.";
49 }
50
51 typedef std::vector<media::DemuxerStream* > Streams;
52
53 // Simulates playback reading requirements by reading from each stream
54 // present in |demuxer| in as-close-to-monotonically-increasing timestamp order.
55 class StreamReader {
56 public:
57 StreamReader(media::Demuxer* demuxer, bool enable_bitstream_converter);
58 ~StreamReader();
59
60 // Performs a single step read.
61 void Read();
62
63 // Returns true when all streams have reached end of stream.
64 bool IsDone();
65
number_of_streams()66 int number_of_streams() { return static_cast<int>(streams_.size()); }
streams()67 const Streams& streams() { return streams_; }
counts()68 const std::vector<int>& counts() { return counts_; }
69
70 private:
71 void OnReadDone(base::MessageLoop* message_loop,
72 bool* end_of_stream,
73 base::TimeDelta* timestamp,
74 media::DemuxerStream::Status status,
75 const scoped_refptr<media::DecoderBuffer>& buffer);
76 int GetNextStreamIndexToRead();
77
78 Streams streams_;
79 std::vector<bool> end_of_stream_;
80 std::vector<base::TimeDelta> last_read_timestamp_;
81 std::vector<int> counts_;
82
83 DISALLOW_COPY_AND_ASSIGN(StreamReader);
84 };
85
StreamReader(media::Demuxer * demuxer,bool enable_bitstream_converter)86 StreamReader::StreamReader(media::Demuxer* demuxer,
87 bool enable_bitstream_converter) {
88 media::DemuxerStream* stream =
89 demuxer->GetStream(media::DemuxerStream::AUDIO);
90 if (stream) {
91 streams_.push_back(stream);
92 end_of_stream_.push_back(false);
93 last_read_timestamp_.push_back(media::kNoTimestamp());
94 counts_.push_back(0);
95 }
96
97 stream = demuxer->GetStream(media::DemuxerStream::VIDEO);
98 if (stream) {
99 streams_.push_back(stream);
100 end_of_stream_.push_back(false);
101 last_read_timestamp_.push_back(media::kNoTimestamp());
102 counts_.push_back(0);
103
104 if (enable_bitstream_converter)
105 stream->EnableBitstreamConverter();
106 }
107 }
108
~StreamReader()109 StreamReader::~StreamReader() {}
110
Read()111 void StreamReader::Read() {
112 int index = GetNextStreamIndexToRead();
113 bool end_of_stream = false;
114 base::TimeDelta timestamp;
115
116 streams_[index]->Read(base::Bind(
117 &StreamReader::OnReadDone, base::Unretained(this),
118 base::MessageLoop::current(), &end_of_stream, ×tamp));
119 base::MessageLoop::current()->Run();
120
121 CHECK(end_of_stream || timestamp != media::kNoTimestamp());
122 end_of_stream_[index] = end_of_stream;
123 last_read_timestamp_[index] = timestamp;
124 counts_[index]++;
125 }
126
IsDone()127 bool StreamReader::IsDone() {
128 for (size_t i = 0; i < end_of_stream_.size(); ++i) {
129 if (!end_of_stream_[i])
130 return false;
131 }
132 return true;
133 }
134
OnReadDone(base::MessageLoop * message_loop,bool * end_of_stream,base::TimeDelta * timestamp,media::DemuxerStream::Status status,const scoped_refptr<media::DecoderBuffer> & buffer)135 void StreamReader::OnReadDone(
136 base::MessageLoop* message_loop,
137 bool* end_of_stream,
138 base::TimeDelta* timestamp,
139 media::DemuxerStream::Status status,
140 const scoped_refptr<media::DecoderBuffer>& buffer) {
141 CHECK_EQ(status, media::DemuxerStream::kOk);
142 CHECK(buffer.get());
143 *end_of_stream = buffer->end_of_stream();
144 *timestamp = *end_of_stream ? media::kNoTimestamp() : buffer->timestamp();
145 message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
146 }
147
GetNextStreamIndexToRead()148 int StreamReader::GetNextStreamIndexToRead() {
149 int index = -1;
150 for (int i = 0; i < number_of_streams(); ++i) {
151 // Ignore streams at EOS.
152 if (end_of_stream_[i])
153 continue;
154
155 // Use a stream if it hasn't been read from yet.
156 if (last_read_timestamp_[i] == media::kNoTimestamp())
157 return i;
158
159 if (index < 0 ||
160 last_read_timestamp_[i] < last_read_timestamp_[index]) {
161 index = i;
162 }
163 }
164 CHECK_GE(index, 0) << "Couldn't find a stream to read";
165 return index;
166 }
167
RunDemuxerBenchmark(const std::string & filename)168 static void RunDemuxerBenchmark(const std::string& filename) {
169 base::FilePath file_path(GetTestDataFilePath(filename));
170 double total_time = 0.0;
171 for (int i = 0; i < kBenchmarkIterations; ++i) {
172 // Setup.
173 base::MessageLoop message_loop;
174 DemuxerHostImpl demuxer_host;
175 FileDataSource data_source;
176 ASSERT_TRUE(data_source.Initialize(file_path));
177
178 Demuxer::NeedKeyCB need_key_cb = base::Bind(&NeedKey);
179 FFmpegDemuxer demuxer(message_loop.message_loop_proxy(),
180 &data_source,
181 need_key_cb,
182 new MediaLog());
183
184 demuxer.Initialize(&demuxer_host,
185 base::Bind(&QuitLoopWithStatus, &message_loop),
186 false);
187 message_loop.Run();
188 StreamReader stream_reader(&demuxer, false);
189
190 // Benchmark.
191 base::TimeTicks start = base::TimeTicks::HighResNow();
192 while (!stream_reader.IsDone()) {
193 stream_reader.Read();
194 }
195 base::TimeTicks end = base::TimeTicks::HighResNow();
196 total_time += (end - start).InSecondsF();
197 demuxer.Stop();
198 QuitLoopWithStatus(&message_loop, PIPELINE_OK);
199 message_loop.Run();
200 }
201
202 perf_test::PrintResult("demuxer_bench",
203 "",
204 filename,
205 kBenchmarkIterations / total_time,
206 "runs/s",
207 true);
208 }
209
210 #if defined(OS_WIN)
211 // http://crbug.com/399002
212 #define MAYBE_Demuxer DISABLED_Demuxer
213 #else
214 #define MAYBE_Demuxer Demuxer
215 #endif
TEST(DemuxerPerfTest,MAYBE_Demuxer)216 TEST(DemuxerPerfTest, MAYBE_Demuxer) {
217 RunDemuxerBenchmark("bear.ogv");
218 RunDemuxerBenchmark("bear-640x360.webm");
219 RunDemuxerBenchmark("sfx_s16le.wav");
220 #if defined(USE_PROPRIETARY_CODECS)
221 RunDemuxerBenchmark("bear-1280x720.mp4");
222 RunDemuxerBenchmark("sfx.mp3");
223 #endif
224 #if defined(OS_CHROMEOS)
225 RunDemuxerBenchmark("bear.flac");
226 #endif
227 #if defined(USE_PROPRIETARY_CODECS) && defined(OS_CHROMEOS)
228 RunDemuxerBenchmark("bear.avi");
229 #endif
230 }
231
232 } // namespace media
233