ffmpeg_demuxer_unittest.cc 64 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768
  1. // Copyright (c) 2012 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. #include "media/filters/ffmpeg_demuxer.h"
  5. #include <stddef.h>
  6. #include <stdint.h>
  7. #include <algorithm>
  8. #include <memory>
  9. #include <string>
  10. #include <utility>
  11. #include "base/bind.h"
  12. #include "base/files/file_path.h"
  13. #include "base/location.h"
  14. #include "base/logging.h"
  15. #include "base/path_service.h"
  16. #include "base/run_loop.h"
  17. #include "base/task/single_thread_task_runner.h"
  18. #include "base/test/mock_callback.h"
  19. #include "base/test/task_environment.h"
  20. #include "base/threading/thread.h"
  21. #include "base/threading/thread_task_runner_handle.h"
  22. #include "base/time/time.h"
  23. #include "build/build_config.h"
  24. #include "build/chromeos_buildflags.h"
  25. #include "media/base/decrypt_config.h"
  26. #include "media/base/demuxer_stream.h"
  27. #include "media/base/media_client.h"
  28. #include "media/base/media_tracks.h"
  29. #include "media/base/media_util.h"
  30. #include "media/base/mock_demuxer_host.h"
  31. #include "media/base/mock_filters.h"
  32. #include "media/base/mock_media_log.h"
  33. #include "media/base/test_helpers.h"
  34. #include "media/base/timestamp_constants.h"
  35. #include "media/ffmpeg/ffmpeg_common.h"
  36. #include "media/filters/file_data_source.h"
  37. #include "media/formats/mp4/avc.h"
  38. #include "media/formats/mp4/bitstream_converter.h"
  39. #include "media/media_buildflags.h"
  40. #include "testing/gtest/include/gtest/gtest.h"
  41. #include "ui/gfx/color_space.h"
  42. using ::testing::_;
  43. using ::testing::AnyNumber;
  44. using ::testing::DoAll;
  45. using ::testing::Eq;
  46. using ::testing::Exactly;
  47. using ::testing::InSequence;
  48. using ::testing::Invoke;
  49. using ::testing::NotNull;
  50. using ::testing::Return;
  51. using ::testing::SaveArg;
  52. using ::testing::SetArgPointee;
  53. using ::testing::StrictMock;
  54. using ::testing::WithArgs;
  55. namespace media {
  56. MATCHER(IsEndOfStreamBuffer,
  57. std::string(negation ? "isn't" : "is") + " end of stream") {
  58. return arg->end_of_stream();
  59. }
  60. // This does not verify any of the codec parameters that may be included in the
  61. // log entry.
  62. MATCHER_P(SimpleCreatedFFmpegDemuxerStream, stream_type, "") {
  63. return CONTAINS_STRING(arg, "\"info\":\"FFmpegDemuxer: created " +
  64. std::string(stream_type) +
  65. " stream, config codec:");
  66. }
  67. MATCHER_P(FailedToCreateValidDecoderConfigFromStream, stream_type, "") {
  68. return CONTAINS_STRING(
  69. arg,
  70. "\"debug\":\"Warning, FFmpegDemuxer failed to create a "
  71. "valid/supported " +
  72. std::string(stream_type) +
  73. " decoder configuration from muxed stream");
  74. }
  75. MATCHER_P(SkippingUnsupportedStream, stream_type, "") {
  76. return CONTAINS_STRING(
  77. arg, "\"info\":\"FFmpegDemuxer: skipping invalid or unsupported " +
  78. std::string(stream_type) + " track");
  79. }
  80. const uint8_t kEncryptedMediaInitData[] = {
  81. 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  82. 0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
  83. };
  84. static void EosOnReadDone(bool* got_eos_buffer,
  85. DemuxerStream::Status status,
  86. scoped_refptr<DecoderBuffer> buffer) {
  87. base::ThreadTaskRunnerHandle::Get()->PostTask(
  88. FROM_HERE, base::RunLoop::QuitCurrentWhenIdleClosureDeprecated());
  89. EXPECT_EQ(status, DemuxerStream::kOk);
  90. if (buffer->end_of_stream()) {
  91. *got_eos_buffer = true;
  92. return;
  93. }
  94. EXPECT_TRUE(buffer->data());
  95. EXPECT_GT(buffer->data_size(), 0u);
  96. *got_eos_buffer = false;
  97. }
  98. // Fixture class to facilitate writing tests. Takes care of setting up the
  99. // FFmpeg, pipeline and filter host mocks.
  100. class FFmpegDemuxerTest : public testing::Test {
  101. public:
  102. FFmpegDemuxerTest(const FFmpegDemuxerTest&) = delete;
  103. FFmpegDemuxerTest& operator=(const FFmpegDemuxerTest&) = delete;
  104. protected:
  105. FFmpegDemuxerTest() = default;
  106. ~FFmpegDemuxerTest() override { Shutdown(); }
  107. void Shutdown() {
  108. if (demuxer_)
  109. demuxer_->Stop();
  110. demuxer_.reset();
  111. task_environment_.RunUntilIdle();
  112. data_source_.reset();
  113. }
  114. // TODO(wolenetz): Combine with CreateDemuxer() and expand coverage of all of
  115. // these tests to use strict media log. See https://crbug.com/749178.
  116. void CreateDemuxerWithStrictMediaLog(const std::string& name) {
  117. CreateDemuxerInternal(name, &media_log_);
  118. }
  119. void CreateDemuxer(const std::string& name) {
  120. CreateDemuxerInternal(name, &dummy_media_log_);
  121. }
  122. DemuxerStream* GetStream(DemuxerStream::Type type) {
  123. std::vector<DemuxerStream*> streams = demuxer_->GetAllStreams();
  124. for (auto* stream : streams) {
  125. if (stream->type() == type)
  126. return stream;
  127. }
  128. return nullptr;
  129. }
  130. MOCK_METHOD1(CheckPoint, void(int v));
  131. void InitializeDemuxerInternal(media::PipelineStatus expected_pipeline_status,
  132. base::Time timeline_offset) {
  133. if (expected_pipeline_status == PIPELINE_OK)
  134. EXPECT_CALL(host_, SetDuration(_)).Times(AnyNumber());
  135. WaitableMessageLoopEvent event;
  136. demuxer_->Initialize(&host_, event.GetPipelineStatusCB());
  137. demuxer_->timeline_offset_ = timeline_offset;
  138. event.RunAndWaitForStatus(expected_pipeline_status);
  139. }
  140. void InitializeDemuxer() {
  141. InitializeDemuxerInternal(PIPELINE_OK, base::Time());
  142. }
  143. void InitializeDemuxerWithTimelineOffset(base::Time timeline_offset) {
  144. InitializeDemuxerInternal(PIPELINE_OK, timeline_offset);
  145. }
  146. void InitializeDemuxerAndExpectPipelineStatus(
  147. media::PipelineStatus expected_pipeline_status) {
  148. InitializeDemuxerInternal(expected_pipeline_status, base::Time());
  149. }
  150. void SeekOnVideoTrackChangePassthrough(
  151. base::TimeDelta time,
  152. base::OnceCallback<void(DemuxerStream::Type,
  153. const std::vector<DemuxerStream*>&)> cb,
  154. DemuxerStream::Type type,
  155. const std::vector<DemuxerStream*>& streams) {
  156. // The tests can't access private methods directly because gtest uses
  157. // some magic macros that break the 'friend' declaration.
  158. demuxer_->SeekOnVideoTrackChange(time, std::move(cb), type, streams);
  159. }
  160. MOCK_METHOD2(OnReadDoneCalled, void(int, int64_t));
  161. struct ReadExpectation {
  162. ReadExpectation(size_t size,
  163. int64_t timestamp_us,
  164. base::TimeDelta discard_front_padding,
  165. bool is_key_frame,
  166. DemuxerStream::Status status)
  167. : size(size),
  168. timestamp_us(timestamp_us),
  169. discard_front_padding(discard_front_padding),
  170. is_key_frame(is_key_frame),
  171. status(status) {}
  172. size_t size;
  173. int64_t timestamp_us;
  174. base::TimeDelta discard_front_padding;
  175. bool is_key_frame;
  176. DemuxerStream::Status status;
  177. };
  178. // Verifies that |buffer| has a specific |size| and |timestamp|.
  179. // |location| simply indicates where the call to this function was made.
  180. // This makes it easier to track down where test failures occur.
  181. void OnReadDone(const base::Location& location,
  182. const ReadExpectation& read_expectation,
  183. base::OnceClosure quit_closure,
  184. DemuxerStream::Status status,
  185. scoped_refptr<DecoderBuffer> buffer) {
  186. std::string location_str = location.ToString();
  187. location_str += "\n";
  188. SCOPED_TRACE(location_str);
  189. EXPECT_EQ(read_expectation.status, status);
  190. if (status == DemuxerStream::kOk) {
  191. EXPECT_TRUE(buffer);
  192. EXPECT_EQ(read_expectation.size, buffer->data_size());
  193. EXPECT_EQ(read_expectation.timestamp_us,
  194. buffer->timestamp().InMicroseconds());
  195. EXPECT_EQ(read_expectation.discard_front_padding,
  196. buffer->discard_padding().first);
  197. EXPECT_EQ(read_expectation.is_key_frame, buffer->is_key_frame());
  198. }
  199. OnReadDoneCalled(read_expectation.size, read_expectation.timestamp_us);
  200. std::move(quit_closure).Run();
  201. }
  202. DemuxerStream::ReadCB NewReadCBWithCheckedDiscard(
  203. const base::Location& location,
  204. int size,
  205. int64_t timestamp_us,
  206. base::TimeDelta discard_front_padding,
  207. bool is_key_frame,
  208. DemuxerStream::Status status,
  209. base::OnceClosure quit_closure) {
  210. EXPECT_CALL(*this, OnReadDoneCalled(size, timestamp_us));
  211. struct ReadExpectation read_expectation(
  212. size, timestamp_us, discard_front_padding, is_key_frame, status);
  213. return base::BindOnce(&FFmpegDemuxerTest::OnReadDone,
  214. base::Unretained(this), location, read_expectation,
  215. std::move(quit_closure));
  216. }
  217. void Read(DemuxerStream* stream,
  218. const base::Location& location,
  219. int size,
  220. int64_t timestamp_us,
  221. bool is_key_frame,
  222. DemuxerStream::Status status = DemuxerStream::Status::kOk,
  223. base::TimeDelta discard_front_padding = base::TimeDelta()) {
  224. base::RunLoop run_loop;
  225. stream->Read(NewReadCBWithCheckedDiscard(
  226. location, size, timestamp_us, discard_front_padding, is_key_frame,
  227. status, run_loop.QuitClosure()));
  228. run_loop.Run();
  229. // Ensure tasks posted after the ReadCB is satisfied run. These are always
  230. // tasks posted to FFmpegDemuxer's internal |blocking_task_runner_|, which
  231. // the RunLoop above won't pump.
  232. task_environment_.RunUntilIdle();
  233. }
  234. MOCK_METHOD2(OnEncryptedMediaInitData,
  235. void(EmeInitDataType init_data_type,
  236. const std::vector<uint8_t>& init_data));
  237. void OnMediaTracksUpdated(std::unique_ptr<MediaTracks> tracks) {
  238. CHECK(tracks.get());
  239. media_tracks_ = std::move(tracks);
  240. }
  241. // Accessor to demuxer internals.
  242. void SetDurationKnown(bool duration_known) {
  243. demuxer_->duration_known_ = duration_known;
  244. if (!duration_known)
  245. demuxer_->duration_ = kInfiniteDuration;
  246. }
  247. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  248. bool HasBitstreamConverter(DemuxerStream* stream) const {
  249. return !!reinterpret_cast<FFmpegDemuxerStream*>(stream)
  250. ->bitstream_converter_;
  251. }
  252. #endif
  253. // Fixture members.
  254. base::test::TaskEnvironment task_environment_;
  255. // TODO(wolenetz): Consider expanding MediaLog verification coverage here
  256. // using StrictMock<MockMediaLog> for all FFmpegDemuxerTests. See
  257. // https://crbug.com/749178.
  258. StrictMock<MockMediaLog> media_log_;
  259. NullMediaLog dummy_media_log_;
  260. std::unique_ptr<FileDataSource> data_source_;
  261. std::unique_ptr<FFmpegDemuxer> demuxer_;
  262. StrictMock<MockDemuxerHost> host_;
  263. std::unique_ptr<MediaTracks> media_tracks_;
  264. AVFormatContext* format_context() {
  265. return demuxer_->glue_->format_context();
  266. }
  267. DemuxerStream* preferred_seeking_stream(base::TimeDelta seek_time) const {
  268. return demuxer_->FindPreferredStreamForSeeking(seek_time);
  269. }
  270. void ReadUntilEndOfStream(DemuxerStream* stream) {
  271. bool got_eos_buffer = false;
  272. const int kMaxBuffers = 170;
  273. for (int i = 0; !got_eos_buffer && i < kMaxBuffers; i++) {
  274. stream->Read(base::BindOnce(&EosOnReadDone, &got_eos_buffer));
  275. base::RunLoop().Run();
  276. }
  277. EXPECT_TRUE(got_eos_buffer);
  278. }
  279. void Seek(base::TimeDelta seek_target) {
  280. WaitableMessageLoopEvent event;
  281. demuxer_->Seek(seek_target, event.GetPipelineStatusCB());
  282. event.RunAndWaitForStatus(PIPELINE_OK);
  283. }
  284. private:
  285. void CreateDemuxerInternal(const std::string& name, MediaLog* media_log) {
  286. CHECK(!demuxer_);
  287. EXPECT_CALL(host_, OnBufferedTimeRangesChanged(_)).Times(AnyNumber());
  288. CreateDataSource(name);
  289. Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb =
  290. base::BindRepeating(&FFmpegDemuxerTest::OnEncryptedMediaInitData,
  291. base::Unretained(this));
  292. Demuxer::MediaTracksUpdatedCB tracks_updated_cb = base::BindRepeating(
  293. &FFmpegDemuxerTest::OnMediaTracksUpdated, base::Unretained(this));
  294. demuxer_ = std::make_unique<FFmpegDemuxer>(
  295. base::ThreadTaskRunnerHandle::Get(), data_source_.get(),
  296. encrypted_media_init_data_cb, tracks_updated_cb, media_log, false);
  297. }
  298. void CreateDataSource(const std::string& name) {
  299. CHECK(!data_source_);
  300. base::FilePath file_path;
  301. EXPECT_TRUE(base::PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
  302. file_path = file_path.Append(FILE_PATH_LITERAL("media"))
  303. .Append(FILE_PATH_LITERAL("test"))
  304. .Append(FILE_PATH_LITERAL("data"))
  305. .AppendASCII(name);
  306. data_source_ = std::make_unique<FileDataSource>();
  307. EXPECT_TRUE(data_source_->Initialize(file_path));
  308. }
  309. };
  310. TEST_F(FFmpegDemuxerTest, Initialize_OpenFails) {
  311. // Simulate avformat_open_input() failing.
  312. CreateDemuxer("ten_byte_file");
  313. WaitableMessageLoopEvent event;
  314. demuxer_->Initialize(&host_, event.GetPipelineStatusCB());
  315. event.RunAndWaitForStatus(DEMUXER_ERROR_COULD_NOT_OPEN);
  316. }
  317. TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
  318. // Open a file with no streams whatsoever.
  319. CreateDemuxer("no_streams.webm");
  320. WaitableMessageLoopEvent event;
  321. demuxer_->Initialize(&host_, event.GetPipelineStatusCB());
  322. event.RunAndWaitForStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
  323. }
  324. TEST_F(FFmpegDemuxerTest, Initialize_NoAudioVideo) {
  325. // Open a file containing streams but none of which are audio/video streams.
  326. CreateDemuxer("no_audio_video.webm");
  327. WaitableMessageLoopEvent event;
  328. demuxer_->Initialize(&host_, event.GetPipelineStatusCB());
  329. event.RunAndWaitForStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
  330. }
  331. TEST_F(FFmpegDemuxerTest, Initialize_Successful) {
  332. CreateDemuxer("bear-320x240.webm");
  333. InitializeDemuxer();
  334. // Video stream should be present.
  335. DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
  336. ASSERT_TRUE(stream);
  337. EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
  338. const VideoDecoderConfig& video_config = stream->video_decoder_config();
  339. EXPECT_EQ(VideoCodec::kVP8, video_config.codec());
  340. EXPECT_EQ(VideoDecoderConfig::AlphaMode::kIsOpaque,
  341. video_config.alpha_mode());
  342. EXPECT_EQ(320, video_config.coded_size().width());
  343. EXPECT_EQ(240, video_config.coded_size().height());
  344. EXPECT_EQ(0, video_config.visible_rect().x());
  345. EXPECT_EQ(0, video_config.visible_rect().y());
  346. EXPECT_EQ(320, video_config.visible_rect().width());
  347. EXPECT_EQ(240, video_config.visible_rect().height());
  348. EXPECT_EQ(320, video_config.natural_size().width());
  349. EXPECT_EQ(240, video_config.natural_size().height());
  350. EXPECT_TRUE(video_config.extra_data().empty());
  351. // Audio stream should be present.
  352. stream = GetStream(DemuxerStream::AUDIO);
  353. ASSERT_TRUE(stream);
  354. EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
  355. const AudioDecoderConfig& audio_config = stream->audio_decoder_config();
  356. EXPECT_EQ(AudioCodec::kVorbis, audio_config.codec());
  357. EXPECT_EQ(32, audio_config.bits_per_channel());
  358. EXPECT_EQ(CHANNEL_LAYOUT_STEREO, audio_config.channel_layout());
  359. EXPECT_EQ(44100, audio_config.samples_per_second());
  360. EXPECT_EQ(kSampleFormatPlanarF32, audio_config.sample_format());
  361. EXPECT_FALSE(audio_config.extra_data().empty());
  362. // Unknown stream should never be present.
  363. EXPECT_EQ(2u, demuxer_->GetAllStreams().size());
  364. }
  365. // Android has no Theora support, so this test doesn't work.
  366. #if !BUILDFLAG(IS_ANDROID)
  367. TEST_F(FFmpegDemuxerTest, Initialize_Multitrack) {
  368. // Open a file containing the following streams:
  369. // Stream #0: Video (VP8)
  370. // Stream #1: Audio (Vorbis)
  371. // Stream #2: Subtitles (SRT)
  372. // Stream #3: Video (Theora)
  373. // Stream #4: Audio (16-bit signed little endian PCM)
  374. CreateDemuxer("bear-320x240-multitrack.webm");
  375. InitializeDemuxer();
  376. std::vector<DemuxerStream*> streams = demuxer_->GetAllStreams();
  377. EXPECT_EQ(4u, streams.size());
  378. // Stream #0 should be VP8 video.
  379. DemuxerStream* stream = streams[0];
  380. ASSERT_TRUE(stream);
  381. EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
  382. EXPECT_EQ(VideoCodec::kVP8, stream->video_decoder_config().codec());
  383. // Stream #1 should be Vorbis audio.
  384. stream = streams[1];
  385. ASSERT_TRUE(stream);
  386. EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
  387. EXPECT_EQ(AudioCodec::kVorbis, stream->audio_decoder_config().codec());
  388. // The subtitles stream is skipped.
  389. // Stream #2 should be Theora video.
  390. stream = streams[2];
  391. ASSERT_TRUE(stream);
  392. EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
  393. EXPECT_EQ(VideoCodec::kTheora, stream->video_decoder_config().codec());
  394. // Stream #3 should be PCM audio.
  395. stream = streams[3];
  396. ASSERT_TRUE(stream);
  397. EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
  398. EXPECT_EQ(AudioCodec::kPCM, stream->audio_decoder_config().codec());
  399. }
  400. #endif
  401. TEST_F(FFmpegDemuxerTest, Initialize_Encrypted) {
  402. EXPECT_CALL(*this,
  403. OnEncryptedMediaInitData(
  404. EmeInitDataType::WEBM,
  405. std::vector<uint8_t>(kEncryptedMediaInitData,
  406. kEncryptedMediaInitData +
  407. std::size(kEncryptedMediaInitData))))
  408. .Times(Exactly(2));
  409. CreateDemuxer("bear-320x240-av_enc-av.webm");
  410. InitializeDemuxer();
  411. }
  412. TEST_F(FFmpegDemuxerTest, Initialize_NoConfigChangeSupport) {
  413. // Will create one audio, one video, and one text stream.
  414. CreateDemuxer("bear-vp8-webvtt.webm");
  415. InitializeDemuxer();
  416. for (auto* stream : demuxer_->GetAllStreams())
  417. EXPECT_FALSE(stream->SupportsConfigChanges());
  418. }
  419. TEST_F(FFmpegDemuxerTest, AbortPendingReads) {
  420. // We test that on a successful audio packet read.
  421. CreateDemuxer("bear-320x240.webm");
  422. InitializeDemuxer();
  423. // Attempt a read from the audio stream and run the message loop until done.
  424. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  425. // Depending on where in the reading process ffmpeg is, an error may cause the
  426. // stream to be marked as EOF. Simulate this here to ensure it is properly
  427. // cleared by the AbortPendingReads() call.
  428. format_context()->pb->eof_reached = 1;
  429. {
  430. base::RunLoop run_loop;
  431. audio->Read(NewReadCBWithCheckedDiscard(FROM_HERE, 29, 0, base::TimeDelta(),
  432. true, DemuxerStream::kAborted,
  433. run_loop.QuitClosure()));
  434. demuxer_->AbortPendingReads();
  435. run_loop.Run();
  436. task_environment_.RunUntilIdle();
  437. }
  438. // Additional reads should also be aborted (until a Seek()).
  439. Read(audio, FROM_HERE, 29, 0, true, DemuxerStream::kAborted);
  440. // Ensure blocking thread has completed outstanding work.
  441. demuxer_->Stop();
  442. EXPECT_EQ(format_context()->pb->eof_reached, 0);
  443. // Calling abort after stop should not crash.
  444. demuxer_->AbortPendingReads();
  445. demuxer_.reset();
  446. }
  447. TEST_F(FFmpegDemuxerTest, Read_Audio) {
  448. // We test that on a successful audio packet read.
  449. CreateDemuxer("bear-320x240.webm");
  450. InitializeDemuxer();
  451. // Attempt a read from the audio stream and run the message loop until done.
  452. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  453. Read(audio, FROM_HERE, 29, 0, true);
  454. Read(audio, FROM_HERE, 27, 3000, true);
  455. EXPECT_EQ(166866, demuxer_->GetMemoryUsage());
  456. }
  457. TEST_F(FFmpegDemuxerTest, Read_Video) {
  458. // We test that on a successful video packet read.
  459. CreateDemuxer("bear-320x240.webm");
  460. InitializeDemuxer();
  461. // Attempt a read from the video stream and run the message loop until done.
  462. DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
  463. Read(video, FROM_HERE, 22084, 0, true);
  464. Read(video, FROM_HERE, 1057, 33000, false);
  465. EXPECT_EQ(148778, demuxer_->GetMemoryUsage());
  466. }
  467. TEST_F(FFmpegDemuxerTest, SeekInitialized_NoVideoStartTime) {
  468. CreateDemuxer("audio-start-time-only.webm");
  469. InitializeDemuxer();
  470. // Video would normally be preferred, but not if it's a zero packet
  471. // stream.
  472. DemuxerStream* expected_stream = GetStream(DemuxerStream::AUDIO);
  473. EXPECT_EQ(expected_stream, preferred_seeking_stream(base::TimeDelta()));
  474. }
  475. TEST_F(FFmpegDemuxerTest, Seeking_PreferredStreamSelection) {
  476. const int64_t kTimelineOffsetMs = 1352550896000LL;
  477. // Test the start time is the first timestamp of the video and audio stream.
  478. CreateDemuxer("nonzero-start-time.webm");
  479. InitializeDemuxerWithTimelineOffset(
  480. base::Time::FromJsTime(kTimelineOffsetMs));
  481. FFmpegDemuxerStream* video =
  482. static_cast<FFmpegDemuxerStream*>(GetStream(DemuxerStream::VIDEO));
  483. FFmpegDemuxerStream* audio =
  484. static_cast<FFmpegDemuxerStream*>(GetStream(DemuxerStream::AUDIO));
  485. const base::TimeDelta video_start_time = base::Microseconds(400000);
  486. const base::TimeDelta audio_start_time = base::Microseconds(396000);
  487. // Seeking to a position lower than the start time of either stream should
  488. // prefer video stream for seeking.
  489. EXPECT_EQ(video, preferred_seeking_stream(base::TimeDelta()));
  490. // Seeking to a position that has audio data, but not video, should prefer
  491. // the audio stream for seeking.
  492. EXPECT_EQ(audio, preferred_seeking_stream(audio_start_time));
  493. // Seeking to a position where both audio and video streams have data should
  494. // prefer the video stream for seeking.
  495. EXPECT_EQ(video, preferred_seeking_stream(video_start_time));
  496. // A disabled stream should be preferred only when there's no other viable
  497. // option among enabled streams.
  498. audio->SetEnabled(false, base::TimeDelta());
  499. EXPECT_EQ(video, preferred_seeking_stream(video_start_time));
  500. // Audio stream is preferred, even though it is disabled, since video stream
  501. // start time is higher than the seek target == audio_start_time in this case.
  502. EXPECT_EQ(audio, preferred_seeking_stream(audio_start_time));
  503. audio->SetEnabled(true, base::TimeDelta());
  504. video->SetEnabled(false, base::TimeDelta());
  505. EXPECT_EQ(audio, preferred_seeking_stream(audio_start_time));
  506. EXPECT_EQ(audio, preferred_seeking_stream(video_start_time));
  507. // When both audio and video streams are disabled and there's no enabled
  508. // streams, then audio is preferred since it has lower start time.
  509. audio->SetEnabled(false, base::TimeDelta());
  510. EXPECT_EQ(audio, preferred_seeking_stream(audio_start_time));
  511. EXPECT_EQ(audio, preferred_seeking_stream(video_start_time));
  512. }
  513. TEST_F(FFmpegDemuxerTest, Read_VideoPositiveStartTime) {
  514. const int64_t kTimelineOffsetMs = 1352550896000LL;
  515. // Test the start time is the first timestamp of the video and audio stream.
  516. CreateDemuxer("nonzero-start-time.webm");
  517. InitializeDemuxerWithTimelineOffset(
  518. base::Time::FromJsTime(kTimelineOffsetMs));
  519. // Attempt a read from the video stream and run the message loop until done.
  520. DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
  521. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  522. const base::TimeDelta video_start_time = base::Microseconds(400000);
  523. const base::TimeDelta audio_start_time = base::Microseconds(396000);
  524. // Run the test twice with a seek in between.
  525. for (int i = 0; i < 2; ++i) {
  526. Read(video, FROM_HERE, 5636, video_start_time.InMicroseconds(), true);
  527. Read(audio, FROM_HERE, 165, audio_start_time.InMicroseconds(), true);
  528. // Verify that the start time is equal to the lowest timestamp (ie the
  529. // audio).
  530. EXPECT_EQ(audio_start_time, demuxer_->start_time());
  531. // Verify that the timeline offset has not been adjusted by the start time.
  532. EXPECT_EQ(kTimelineOffsetMs, demuxer_->GetTimelineOffset().ToJavaTime());
  533. // Seek back to the beginning and repeat the test.
  534. WaitableMessageLoopEvent event;
  535. demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
  536. event.RunAndWaitForStatus(PIPELINE_OK);
  537. }
  538. }
  539. TEST_F(FFmpegDemuxerTest, Read_AudioNoStartTime) {
  540. // FFmpeg does not set timestamps when demuxing wave files. Ensure that the
  541. // demuxer sets a start time of zero in this case.
  542. CreateDemuxer("sfx_s24le.wav");
  543. InitializeDemuxer();
  544. // Run the test twice with a seek in between.
  545. for (int i = 0; i < 2; ++i) {
  546. Read(GetStream(DemuxerStream::AUDIO), FROM_HERE, 4095, 0, true);
  547. EXPECT_EQ(base::TimeDelta(), demuxer_->start_time());
  548. // Seek back to the beginning and repeat the test.
  549. WaitableMessageLoopEvent event;
  550. demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
  551. event.RunAndWaitForStatus(PIPELINE_OK);
  552. }
  553. }
  554. // Android has no Theora support, so these tests doesn't work.
  555. #if !BUILDFLAG(IS_ANDROID)
  556. TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOggDiscard_Bear) {
  557. // Many ogg files have negative starting timestamps, so ensure demuxing and
  558. // seeking work correctly with a negative start time.
  559. CreateDemuxer("bear.ogv");
  560. InitializeDemuxer();
  561. // Attempt a read from the video stream and run the message loop until done.
  562. DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
  563. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  564. // Run the test once (should be twice..., see note) with a seek in between.
  565. //
  566. // TODO(dalecurtis): We only run the test once since FFmpeg does not currently
  567. // guarantee the order of demuxed packets in OGG containers. See
  568. // http://crbug.com/387996.
  569. for (int i = 0; i < 1; ++i) {
  570. Read(audio, FROM_HERE, 40, 0, true, DemuxerStream::Status::kOk,
  571. kInfiniteDuration);
  572. Read(audio, FROM_HERE, 41, 2903, true, DemuxerStream::Status::kOk,
  573. kInfiniteDuration);
  574. Read(audio, FROM_HERE, 173, 5805, true, DemuxerStream::Status::kOk,
  575. base::Microseconds(10159));
  576. Read(audio, FROM_HERE, 148, 18866, true);
  577. EXPECT_EQ(base::Microseconds(-15964), demuxer_->start_time());
  578. Read(video, FROM_HERE, 5751, 0, true);
  579. Read(video, FROM_HERE, 846, 33367, false);
  580. Read(video, FROM_HERE, 1255, 66733, false);
  581. // Seek back to the beginning and repeat the test.
  582. WaitableMessageLoopEvent event;
  583. demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
  584. event.RunAndWaitForStatus(PIPELINE_OK);
  585. }
  586. }
  587. // Same test above, but using sync2.ogv which has video stream muxed before the
  588. // audio stream, so seeking based only on start time will fail since ffmpeg is
  589. // essentially just seeking based on file position.
  590. TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOggDiscard_Sync) {
  591. // Many ogg files have negative starting timestamps, so ensure demuxing and
  592. // seeking work correctly with a negative start time.
  593. CreateDemuxer("sync2.ogv");
  594. InitializeDemuxer();
  595. // Attempt a read from the video stream and run the message loop until done.
  596. DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
  597. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  598. // Run the test twice with a seek in between.
  599. for (int i = 0; i < 2; ++i) {
  600. Read(audio, FROM_HERE, 1, 0, true, DemuxerStream::Status::kOk,
  601. base::Microseconds(2902));
  602. Read(audio, FROM_HERE, 1, 2902, true);
  603. EXPECT_EQ(base::Microseconds(-2902), demuxer_->start_time());
  604. // Though the internal start time may be below zero, the exposed media time
  605. // must always be >= zero.
  606. EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
  607. Read(video, FROM_HERE, 9997, 0, true);
  608. Read(video, FROM_HERE, 16, 33241, false);
  609. Read(video, FROM_HERE, 631, 66482, false);
  610. // Seek back to the beginning and repeat the test.
  611. WaitableMessageLoopEvent event;
  612. demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
  613. event.RunAndWaitForStatus(PIPELINE_OK);
  614. }
  615. }
  616. #endif // !BUILDFLAG(IS_ANDROID)
  617. // Similar to the test above, but using an opus clip with a large amount of
  618. // pre-skip, which ffmpeg encodes as negative timestamps.
  619. TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOpusDiscard_Sync) {
  620. CreateDemuxer("opus-trimming-video-test.webm");
  621. InitializeDemuxer();
  622. // Attempt a read from the video stream and run the message loop until done.
  623. DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
  624. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  625. EXPECT_EQ(audio->audio_decoder_config().codec_delay(), 65535);
  626. // Packet size to timestamp (in microseconds) mapping for the first N packets
  627. // which should be fully discarded.
  628. static const int kTestExpectations[][2] = {
  629. {635, 0}, {594, 120000}, {597, 240000}, {591, 360000},
  630. {582, 480000}, {583, 600000}, {592, 720000}, {567, 840000},
  631. {579, 960000}, {572, 1080000}, {583, 1200000}};
  632. // Run the test twice with a seek in between.
  633. for (int i = 0; i < 2; ++i) {
  634. for (size_t j = 0; j < std::size(kTestExpectations); ++j) {
  635. Read(audio, FROM_HERE, kTestExpectations[j][0], kTestExpectations[j][1],
  636. true);
  637. }
  638. // Though the internal start time may be below zero, the exposed media time
  639. // must always be >= zero.
  640. EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
  641. Read(video, FROM_HERE, 16009, 0, true);
  642. Read(video, FROM_HERE, 2715, 1000, false);
  643. Read(video, FROM_HERE, 427, 33000, false);
  644. // Seek back to the beginning and repeat the test.
  645. WaitableMessageLoopEvent event;
  646. demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
  647. event.RunAndWaitForStatus(PIPELINE_OK);
  648. }
  649. }
  650. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  651. #if BUILDFLAG(IS_CHROMEOS_ASH)
  652. TEST_F(FFmpegDemuxerTest, TestAudioNegativeTimestamps) {
  653. // Note: This test will _crash_ the browser if negative timestamp
  654. // values are skipped, since this file is heavily truncated to avoid
  655. // copyright issue. If the negative timestamp packets are dropped, the
  656. // demuxer will continue to read off the end of the stream.
  657. CreateDemuxer("negative-audio-timestamps.avi");
  658. InitializeDemuxer();
  659. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  660. Read(audio, FROM_HERE, 104, 0, true);
  661. Read(audio, FROM_HERE, 104, 25873, true);
  662. Read(audio, FROM_HERE, 104, 51746, true);
  663. Read(audio, FROM_HERE, 104, 77619, true);
  664. Read(audio, FROM_HERE, 104, 103492, true);
  665. }
  666. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  667. // Similar to the test above, but using an opus clip plus h264 b-frames to
  668. // ensure we don't apply chained ogg workarounds to other content.
  669. TEST_F(FFmpegDemuxerTest,
  670. Read_AudioNegativeStartTimeAndOpusDiscardH264Mp4_Sync) {
  671. CreateDemuxer("tos-h264-opus.mp4");
  672. InitializeDemuxer();
  673. // Attempt a read from the video stream and run the message loop until done.
  674. DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
  675. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  676. EXPECT_EQ(audio->audio_decoder_config().codec_delay(), 312);
  677. // Packet size to timestamp (in microseconds) mapping for the first N packets
  678. // which should be fully discarded.
  679. static const int kTestExpectations[][2] = {
  680. {234, 20000}, {228, 40000}, {340, 60000}};
  681. // Run the test twice with a seek in between.
  682. for (int i = 0; i < 2; ++i) {
  683. Read(audio, FROM_HERE, 408, 0, true, DemuxerStream::Status::kOk,
  684. base::Microseconds(6500));
  685. for (size_t j = 0; j < std::size(kTestExpectations); ++j) {
  686. Read(audio, FROM_HERE, kTestExpectations[j][0], kTestExpectations[j][1],
  687. true);
  688. }
  689. // Though the internal start time may be below zero, the exposed media time
  690. // must always be >= zero.
  691. EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
  692. Read(video, FROM_HERE, 185105, 0, true);
  693. Read(video, FROM_HERE, 35941, 125000, false);
  694. // If things aren't working correctly, this expectation will fail because
  695. // the chained ogg workaround breaks out of order timestamps.
  696. Read(video, FROM_HERE, 8129, 84000, false);
  697. // Seek back to the beginning and repeat the test.
  698. WaitableMessageLoopEvent event;
  699. demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
  700. event.RunAndWaitForStatus(PIPELINE_OK);
  701. }
  702. }
  703. #endif // BUILDFLAG(USE_PROPRIETARY_CODECS)
  704. // Similar to the test above, but using sfx-opus.ogg, which has a much smaller
  705. // amount of discard padding and no |start_time| set on the AVStream.
  706. TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOpusSfxDiscard_Sync) {
  707. CreateDemuxer("sfx-opus.ogg");
  708. InitializeDemuxer();
  709. // Attempt a read from the video stream and run the message loop until done.
  710. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  711. EXPECT_EQ(audio->audio_decoder_config().codec_delay(), 312);
  712. // Run the test twice with a seek in between.
  713. for (int i = 0; i < 2; ++i) {
  714. // TODO(sandersd): Read_AudioNegativeStartTimeAndOpusDiscardH264Mp4_Sync
  715. // has the same sequence, but doesn't have a different discard padding
  716. // after seeking to the start. Why is this test different?
  717. Read(audio, FROM_HERE, 314, 0, true, DemuxerStream::Status::kOk,
  718. i == 0 ? base::Microseconds(6500) : base::TimeDelta());
  719. Read(audio, FROM_HERE, 244, 20000, true);
  720. // Though the internal start time may be below zero, the exposed media time
  721. // must always be >= zero.
  722. EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
  723. // Seek back to the beginning and repeat the test.
  724. WaitableMessageLoopEvent event;
  725. demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
  726. event.RunAndWaitForStatus(PIPELINE_OK);
  727. }
  728. }
  729. TEST_F(FFmpegDemuxerTest, Read_DiscardDisabledVideoStream) {
  730. // Verify that disabling the video stream properly marks it as AVDISCARD_ALL
  731. // in FFmpegDemuxer. The AVDISCARD_ALL flag allows FFmpeg to ignore key frame
  732. // requirements for the disabled stream and thus allows to select the seek
  733. // position closer to the |seek_target|, resulting in less data being read
  734. // from the data source.
  735. // The input file bear-vp8-webvtt.webm has key video frames at 1.602s and at
  736. // 2.002s. If we want to seek to 2.0s position while the video stream is
  737. // enabled, then FFmpeg is forced to start reading from 1.602s, which is the
  738. // earliest position guaranteed to give us key frames for all enabled streams.
  739. // But when the video stream is disabled, FFmpeg can start reading from 1.987s
  740. // which is earliest audio key frame before the 2.0s |seek_target|.
  741. const base::TimeDelta seek_target = base::Milliseconds(2000);
  742. CreateDemuxer("bear-vp8-webvtt.webm");
  743. InitializeDemuxer();
  744. Seek(seek_target);
  745. Read(GetStream(DemuxerStream::AUDIO), FROM_HERE, 163, 1612000, true);
  746. auto bytes_read_with_video_enabled = data_source_->bytes_read_for_testing();
  747. static_cast<FFmpegDemuxerStream*>(GetStream(DemuxerStream::VIDEO))
  748. ->SetEnabled(false, base::TimeDelta());
  749. data_source_->reset_bytes_read_for_testing();
  750. Seek(seek_target);
  751. Read(GetStream(DemuxerStream::AUDIO), FROM_HERE, 156, 1987000, true);
  752. auto bytes_read_with_video_disabled = data_source_->bytes_read_for_testing();
  753. EXPECT_LT(bytes_read_with_video_disabled, bytes_read_with_video_enabled);
  754. }
  755. TEST_F(FFmpegDemuxerTest, Read_EndOfStream) {
  756. // Verify that end of stream buffers are created.
  757. CreateDemuxer("bear-320x240.webm");
  758. InitializeDemuxer();
  759. ReadUntilEndOfStream(GetStream(DemuxerStream::AUDIO));
  760. }
  761. TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration) {
  762. // Verify that end of stream buffers are created.
  763. CreateDemuxer("bear-320x240.webm");
  764. InitializeDemuxer();
  765. SetDurationKnown(false);
  766. EXPECT_CALL(host_, SetDuration(base::Milliseconds(2744)));
  767. ReadUntilEndOfStream(GetStream(DemuxerStream::AUDIO));
  768. ReadUntilEndOfStream(GetStream(DemuxerStream::VIDEO));
  769. }
  770. TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_VideoOnly) {
  771. // Verify that end of stream buffers are created.
  772. CreateDemuxer("bear-320x240-video-only.webm");
  773. InitializeDemuxer();
  774. SetDurationKnown(false);
  775. EXPECT_CALL(host_, SetDuration(base::Milliseconds(2703)));
  776. ReadUntilEndOfStream(GetStream(DemuxerStream::VIDEO));
  777. }
  778. TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_AudioOnly) {
  779. // Verify that end of stream buffers are created.
  780. CreateDemuxer("bear-320x240-audio-only.webm");
  781. InitializeDemuxer();
  782. SetDurationKnown(false);
  783. EXPECT_CALL(host_, SetDuration(base::Milliseconds(2744)));
  784. ReadUntilEndOfStream(GetStream(DemuxerStream::AUDIO));
  785. }
  786. TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_UnsupportedStream) {
  787. // Verify that end of stream buffers are created and we don't crash
  788. // if there are streams in the file that we don't support.
  789. CreateDemuxer("vorbis_audio_wmv_video.mkv");
  790. InitializeDemuxer();
  791. SetDurationKnown(false);
  792. EXPECT_CALL(host_, SetDuration(base::Milliseconds(991)));
  793. ReadUntilEndOfStream(GetStream(DemuxerStream::AUDIO));
  794. }
  795. TEST_F(FFmpegDemuxerTest, Seek) {
  796. // We're testing that the demuxer frees all queued packets when it receives
  797. // a Seek().
  798. CreateDemuxer("bear-320x240.webm");
  799. InitializeDemuxer();
  800. // Get our streams.
  801. DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
  802. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  803. ASSERT_TRUE(video);
  804. ASSERT_TRUE(audio);
  805. // Read a video packet and release it.
  806. Read(video, FROM_HERE, 22084, 0, true);
  807. // Issue a simple forward seek, which should discard queued packets.
  808. WaitableMessageLoopEvent event;
  809. demuxer_->Seek(base::Microseconds(1000000), event.GetPipelineStatusCB());
  810. event.RunAndWaitForStatus(PIPELINE_OK);
  811. // Audio read #1.
  812. Read(audio, FROM_HERE, 145, 803000, true);
  813. // Audio read #2.
  814. Read(audio, FROM_HERE, 148, 826000, true);
  815. // Video read #1.
  816. Read(video, FROM_HERE, 5425, 801000, true);
  817. // Video read #2.
  818. Read(video, FROM_HERE, 1906, 834000, false);
  819. }
  820. TEST_F(FFmpegDemuxerTest, CancelledSeek) {
  821. CreateDemuxer("bear-320x240.webm");
  822. InitializeDemuxer();
  823. // Get our streams.
  824. DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
  825. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  826. ASSERT_TRUE(video);
  827. ASSERT_TRUE(audio);
  828. // Read a video packet and release it.
  829. Read(video, FROM_HERE, 22084, 0, true);
  830. // Issue a simple forward seek, which should discard queued packets.
  831. WaitableMessageLoopEvent event;
  832. demuxer_->Seek(base::Microseconds(1000000), event.GetPipelineStatusCB());
  833. // FFmpegDemuxer does not care what the previous seek time was when canceling.
  834. demuxer_->CancelPendingSeek(base::Seconds(12345));
  835. event.RunAndWaitForStatus(PIPELINE_OK);
  836. }
  837. TEST_F(FFmpegDemuxerTest, Stop) {
  838. // Tests that calling Read() on a stopped demuxer stream immediately deletes
  839. // the callback.
  840. CreateDemuxer("bear-320x240.webm");
  841. InitializeDemuxer();
  842. // Get our stream.
  843. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  844. ASSERT_TRUE(audio);
  845. demuxer_->Stop();
  846. // Reads after being stopped are all EOS buffers.
  847. StrictMock<base::MockCallback<DemuxerStream::ReadCB>> callback;
  848. EXPECT_CALL(callback, Run(DemuxerStream::kOk, IsEndOfStreamBuffer()));
  849. // Attempt the read...
  850. audio->Read(callback.Get());
  851. task_environment_.RunUntilIdle();
  852. // Don't let the test call Stop() again.
  853. demuxer_.reset();
  854. }
  855. // Verify that seek works properly when the WebM cues data is at the start of
  856. // the file instead of at the end.
  857. TEST_F(FFmpegDemuxerTest, SeekWithCuesBeforeFirstCluster) {
  858. CreateDemuxer("bear-320x240-cues-in-front.webm");
  859. InitializeDemuxer();
  860. // Get our streams.
  861. DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
  862. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  863. ASSERT_TRUE(video);
  864. ASSERT_TRUE(audio);
  865. // Read a video packet and release it.
  866. Read(video, FROM_HERE, 22084, 0, true);
  867. // Issue a simple forward seek, which should discard queued packets.
  868. WaitableMessageLoopEvent event;
  869. demuxer_->Seek(base::Microseconds(2500000), event.GetPipelineStatusCB());
  870. event.RunAndWaitForStatus(PIPELINE_OK);
  871. // Audio read #1.
  872. Read(audio, FROM_HERE, 40, 2403000, true);
  873. // Audio read #2.
  874. Read(audio, FROM_HERE, 42, 2406000, true);
  875. // Video read #1.
  876. Read(video, FROM_HERE, 5276, 2402000, true);
  877. // Video read #2.
  878. Read(video, FROM_HERE, 1740, 2436000, false);
  879. }
  880. // Ensure ID3v1 tag reading is disabled. id3_test.mp3 has an ID3v1 tag with the
  881. // field "title" set to "sample for id3 test".
  882. TEST_F(FFmpegDemuxerTest, NoID3TagData) {
  883. CreateDemuxer("id3_test.mp3");
  884. InitializeDemuxer();
  885. EXPECT_FALSE(av_dict_get(format_context()->metadata, "title", nullptr, 0));
  886. }
  887. // Ensure MP3 files with large image/video based ID3 tags demux okay. FFmpeg
  888. // will hand us a video stream to the data which will likely be in a format we
  889. // don't accept as video; e.g. PNG.
  890. TEST_F(FFmpegDemuxerTest, Mp3WithVideoStreamID3TagData) {
  891. CreateDemuxerWithStrictMediaLog("id3_png_test.mp3");
  892. EXPECT_MEDIA_LOG_PROPERTY(kBitrate, 1421305);
  893. EXPECT_MEDIA_LOG_PROPERTY(kStartTime, 0.0f);
  894. EXPECT_MEDIA_LOG_PROPERTY(kVideoTracks, std::vector<VideoDecoderConfig>{});
  895. EXPECT_MEDIA_LOG_PROPERTY_ANY_VALUE(kMaxDuration);
  896. EXPECT_MEDIA_LOG_PROPERTY_ANY_VALUE(kAudioTracks);
  897. EXPECT_MEDIA_LOG(SimpleCreatedFFmpegDemuxerStream("audio"));
  898. EXPECT_MEDIA_LOG(FailedToCreateValidDecoderConfigFromStream("video"));
  899. // TODO(wolenetz): Use a matcher that verifies more of the event parameters
  900. // than FoundStream. See https://crbug.com/749178.
  901. EXPECT_MEDIA_LOG(SkippingUnsupportedStream("video"));
  902. InitializeDemuxer();
  903. // Ensure the expected streams are present.
  904. EXPECT_FALSE(GetStream(DemuxerStream::VIDEO));
  905. EXPECT_TRUE(GetStream(DemuxerStream::AUDIO));
  906. }
  907. // Ensure a video with an unsupported audio track still results in the video
  908. // stream being demuxed. Because we disable the speex parser for ogg, the audio
  909. // track won't even show up to the demuxer.
  910. //
  911. // Android has no Theora support, so this test doesn't work.
  912. #if !BUILDFLAG(IS_ANDROID)
  913. TEST_F(FFmpegDemuxerTest, UnsupportedAudioSupportedVideoDemux) {
  914. CreateDemuxerWithStrictMediaLog("speex_audio_vorbis_video.ogv");
  915. EXPECT_MEDIA_LOG_PROPERTY(kBitrate, 398289);
  916. EXPECT_MEDIA_LOG_PROPERTY(kStartTime, 0.0f);
  917. EXPECT_MEDIA_LOG_PROPERTY(kAudioTracks, std::vector<AudioDecoderConfig>{});
  918. EXPECT_MEDIA_LOG_PROPERTY_ANY_VALUE(kVideoTracks);
  919. EXPECT_MEDIA_LOG_PROPERTY_ANY_VALUE(kMaxDuration);
  920. EXPECT_MEDIA_LOG(SimpleCreatedFFmpegDemuxerStream("video"));
  921. // TODO(wolenetz): Use a matcher that verifies more of the event parameters
  922. // than FoundStream. See https://crbug.com/749178.
  923. InitializeDemuxer();
  924. // Ensure the expected streams are present.
  925. EXPECT_TRUE(GetStream(DemuxerStream::VIDEO));
  926. EXPECT_FALSE(GetStream(DemuxerStream::AUDIO));
  927. }
  928. #endif
  929. // Ensure a video with an unsupported video track still results in the audio
  930. // stream being demuxed.
  931. TEST_F(FFmpegDemuxerTest, UnsupportedVideoSupportedAudioDemux) {
  932. CreateDemuxer("vorbis_audio_wmv_video.mkv");
  933. InitializeDemuxer();
  934. // Ensure the expected streams are present.
  935. EXPECT_FALSE(GetStream(DemuxerStream::VIDEO));
  936. EXPECT_TRUE(GetStream(DemuxerStream::AUDIO));
  937. }
  938. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  939. // FFmpeg returns null data pointers when samples have zero size, leading to
  940. // mistakenly creating end of stream buffers http://crbug.com/169133
  941. TEST_F(FFmpegDemuxerTest, MP4_ZeroStszEntry) {
  942. CreateDemuxer("bear-1280x720-zero-stsz-entry.mp4");
  943. InitializeDemuxer();
  944. ReadUntilEndOfStream(GetStream(DemuxerStream::AUDIO));
  945. }
  946. #endif // BUILDFLAG(USE_PROPRIETARY_CODECS)
  947. class Mp3SeekFFmpegDemuxerTest
  948. : public FFmpegDemuxerTest,
  949. public testing::WithParamInterface<const char*> {};
  950. TEST_P(Mp3SeekFFmpegDemuxerTest, TestFastSeek) {
  951. // Init demxuer with given MP3 file parameter.
  952. CreateDemuxer(GetParam());
  953. InitializeDemuxer();
  954. // We read a bunch of bytes when we first open the file. Reset the count
  955. // here to just track the bytes read for the upcoming seek. This allows us
  956. // to use a more narrow threshold for passing the test.
  957. data_source_->reset_bytes_read_for_testing();
  958. FFmpegDemuxerStream* audio =
  959. static_cast<FFmpegDemuxerStream*>(GetStream(DemuxerStream::AUDIO));
  960. ASSERT_TRUE(audio);
  961. // Seek to near the end of the file
  962. WaitableMessageLoopEvent event;
  963. demuxer_->Seek(.9 * audio->duration(), event.GetPipelineStatusCB());
  964. event.RunAndWaitForStatus(PIPELINE_OK);
  965. // Verify that seeking to the end read only a small portion of the file.
  966. // Slow seeks that read sequentially up to the seek point will read too many
  967. // bytes and fail this check.
  968. int64_t file_size = 0;
  969. ASSERT_TRUE(data_source_->GetSize(&file_size));
  970. EXPECT_LT(data_source_->bytes_read_for_testing(), (file_size * .25));
  971. }
  972. // MP3s should seek quickly without sequentially reading up to the seek point.
  973. // VBR vs CBR and the presence/absence of TOC influence the seeking algorithm.
  974. // See http://crbug.com/530043 and FFmpeg flag AVFMT_FLAG_FAST_SEEK.
  975. INSTANTIATE_TEST_SUITE_P(All,
  976. Mp3SeekFFmpegDemuxerTest,
  977. ::testing::Values("bear-audio-10s-CBR-has-TOC.mp3",
  978. "bear-audio-10s-CBR-no-TOC.mp3",
  979. "bear-audio-10s-VBR-has-TOC.mp3",
  980. "bear-audio-10s-VBR-no-TOC.mp3"));
  981. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  982. static void ValidateAnnexB(DemuxerStream* stream,
  983. DemuxerStream::Status status,
  984. scoped_refptr<DecoderBuffer> buffer) {
  985. EXPECT_EQ(status, DemuxerStream::kOk);
  986. if (buffer->end_of_stream()) {
  987. base::ThreadTaskRunnerHandle::Get()->PostTask(
  988. FROM_HERE, base::RunLoop::QuitCurrentWhenIdleClosureDeprecated());
  989. return;
  990. }
  991. std::vector<SubsampleEntry> subsamples;
  992. if (buffer->decrypt_config())
  993. subsamples = buffer->decrypt_config()->subsamples();
  994. bool is_valid =
  995. mp4::AVC::AnalyzeAnnexB(buffer->data(), buffer->data_size(), subsamples)
  996. .is_conformant.value_or(false);
  997. EXPECT_TRUE(is_valid);
  998. if (!is_valid) {
  999. LOG(ERROR) << "Buffer contains invalid Annex B data.";
  1000. base::ThreadTaskRunnerHandle::Get()->PostTask(
  1001. FROM_HERE, base::RunLoop::QuitCurrentWhenIdleClosureDeprecated());
  1002. return;
  1003. }
  1004. stream->Read(base::BindOnce(&ValidateAnnexB, stream));
  1005. }
  1006. TEST_F(FFmpegDemuxerTest, IsValidAnnexB) {
  1007. const char* files[] = {"bear-1280x720-av_frag.mp4",
  1008. "bear-1280x720-av_with-aud-nalus_frag.mp4"};
  1009. for (size_t i = 0; i < std::size(files); ++i) {
  1010. DVLOG(1) << "Testing " << files[i];
  1011. CreateDemuxer(files[i]);
  1012. InitializeDemuxer();
  1013. // Ensure the expected streams are present.
  1014. DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
  1015. ASSERT_TRUE(stream);
  1016. stream->EnableBitstreamConverter();
  1017. stream->Read(base::BindOnce(&ValidateAnnexB, stream));
  1018. base::RunLoop().Run();
  1019. demuxer_->Stop();
  1020. demuxer_.reset();
  1021. data_source_.reset();
  1022. }
  1023. }
  1024. TEST_F(FFmpegDemuxerTest, Rotate_Metadata_0) {
  1025. CreateDemuxer("bear_rotate_0.mp4");
  1026. InitializeDemuxer();
  1027. DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
  1028. ASSERT_TRUE(stream);
  1029. const VideoDecoderConfig& video_config = stream->video_decoder_config();
  1030. ASSERT_EQ(VIDEO_ROTATION_0, video_config.video_transformation().rotation);
  1031. }
  1032. TEST_F(FFmpegDemuxerTest, Rotate_Metadata_90) {
  1033. CreateDemuxer("bear_rotate_90.mp4");
  1034. InitializeDemuxer();
  1035. DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
  1036. ASSERT_TRUE(stream);
  1037. const VideoDecoderConfig& video_config = stream->video_decoder_config();
  1038. ASSERT_EQ(VIDEO_ROTATION_90, video_config.video_transformation().rotation);
  1039. }
  1040. TEST_F(FFmpegDemuxerTest, Rotate_Metadata_180) {
  1041. CreateDemuxer("bear_rotate_180.mp4");
  1042. InitializeDemuxer();
  1043. DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
  1044. ASSERT_TRUE(stream);
  1045. const VideoDecoderConfig& video_config = stream->video_decoder_config();
  1046. ASSERT_EQ(VIDEO_ROTATION_180, video_config.video_transformation().rotation);
  1047. }
  1048. TEST_F(FFmpegDemuxerTest, Rotate_Metadata_270) {
  1049. CreateDemuxer("bear_rotate_270.mp4");
  1050. InitializeDemuxer();
  1051. DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
  1052. ASSERT_TRUE(stream);
  1053. const VideoDecoderConfig& video_config = stream->video_decoder_config();
  1054. ASSERT_EQ(VIDEO_ROTATION_270, video_config.video_transformation().rotation);
  1055. }
  1056. TEST_F(FFmpegDemuxerTest, NaturalSizeWithoutPASP) {
  1057. CreateDemuxer("bear-640x360-non_square_pixel-without_pasp.mp4");
  1058. InitializeDemuxer();
  1059. DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
  1060. ASSERT_TRUE(stream);
  1061. const VideoDecoderConfig& video_config = stream->video_decoder_config();
  1062. EXPECT_EQ(gfx::Size(639, 360), video_config.natural_size());
  1063. }
  1064. TEST_F(FFmpegDemuxerTest, NaturalSizeWithPASP) {
  1065. CreateDemuxer("bear-640x360-non_square_pixel-with_pasp.mp4");
  1066. InitializeDemuxer();
  1067. DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
  1068. ASSERT_TRUE(stream);
  1069. const VideoDecoderConfig& video_config = stream->video_decoder_config();
  1070. EXPECT_EQ(gfx::Size(639, 360), video_config.natural_size());
  1071. }
  1072. TEST_F(FFmpegDemuxerTest, HEVC_in_MP4_container) {
  1073. CreateDemuxer("bear-hevc-frag.mp4");
  1074. #if BUILDFLAG(ENABLE_PLATFORM_HEVC)
  1075. // HEVC is not supported by default media platform. Embedders who add support
  1076. // must declare it via MediaClient.
  1077. MockMediaClient media_client;
  1078. SetMediaClient(&media_client);
  1079. VideoColorSpace color_space(VideoColorSpace::PrimaryID::SMPTE170M,
  1080. VideoColorSpace::TransferID::SMPTE170M,
  1081. VideoColorSpace::MatrixID::SMPTE170M,
  1082. gfx::ColorSpace::RangeID::LIMITED);
  1083. VideoType hevc_type = {VideoCodec::kHEVC, VideoCodecProfile::HEVCPROFILE_MAIN,
  1084. 10, color_space};
  1085. EXPECT_CALL(media_client, IsSupportedVideoType(Eq(hevc_type)))
  1086. .WillRepeatedly(Return(true));
  1087. InitializeDemuxer();
  1088. DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
  1089. ASSERT_TRUE(video);
  1090. Read(video, FROM_HERE, 3569, 66733, true);
  1091. Read(video, FROM_HERE, 1042, 200200, false);
  1092. SetMediaClient(nullptr);
  1093. #else
  1094. InitializeDemuxerAndExpectPipelineStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
  1095. #endif
  1096. }
  1097. TEST_F(FFmpegDemuxerTest, Read_AC3_Audio) {
  1098. CreateDemuxer("bear-ac3-only-frag.mp4");
  1099. #if BUILDFLAG(ENABLE_PLATFORM_AC3_EAC3_AUDIO)
  1100. // AC3 is not supported by default media platform. Embedders who add support
  1101. // must declare it via MediaClient.
  1102. MockMediaClient media_client;
  1103. SetMediaClient(&media_client);
  1104. AudioType ac3_type = {AudioCodec::kAC3};
  1105. EXPECT_CALL(media_client, IsSupportedAudioType(Eq(ac3_type)))
  1106. .WillRepeatedly(Return(true));
  1107. InitializeDemuxer();
  1108. // Attempt a read from the audio stream and run the message loop until done.
  1109. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  1110. // Read the first two frames and check that we are getting expected data
  1111. Read(audio, FROM_HERE, 834, 0, true);
  1112. Read(audio, FROM_HERE, 836, 34830, true);
  1113. SetMediaClient(nullptr);
  1114. #else
  1115. InitializeDemuxerAndExpectPipelineStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
  1116. #endif
  1117. }
  1118. TEST_F(FFmpegDemuxerTest, Read_EAC3_Audio) {
  1119. CreateDemuxer("bear-eac3-only-frag.mp4");
  1120. #if BUILDFLAG(ENABLE_PLATFORM_AC3_EAC3_AUDIO)
  1121. // EAC3 is not supported by default media platform. Embedders who add support
  1122. // must declare it via MediaClient.
  1123. MockMediaClient media_client;
  1124. SetMediaClient(&media_client);
  1125. AudioType eac3_type = {AudioCodec::kEAC3};
  1126. EXPECT_CALL(media_client, IsSupportedAudioType(Eq(eac3_type)))
  1127. .WillRepeatedly(Return(true));
  1128. InitializeDemuxer();
  1129. // Attempt a read from the audio stream and run the message loop until done.
  1130. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  1131. // Read the first two frames and check that we are getting expected data
  1132. Read(audio, FROM_HERE, 870, 0, true);
  1133. Read(audio, FROM_HERE, 872, 34830, true);
  1134. SetMediaClient(nullptr);
  1135. #else
  1136. InitializeDemuxerAndExpectPipelineStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
  1137. #endif
  1138. }
  1139. TEST_F(FFmpegDemuxerTest, Read_Mp4_Media_Track_Info) {
  1140. CreateDemuxer("bear.mp4");
  1141. InitializeDemuxer();
  1142. EXPECT_EQ(media_tracks_->tracks().size(), 2u);
  1143. const MediaTrack& audio_track = *(media_tracks_->tracks()[1]);
  1144. EXPECT_EQ(audio_track.type(), MediaTrack::Audio);
  1145. EXPECT_EQ(audio_track.bytestream_track_id(), 2);
  1146. EXPECT_EQ(audio_track.kind().value(), "main");
  1147. EXPECT_EQ(audio_track.label().value(), "SoundHandler");
  1148. EXPECT_EQ(audio_track.language().value(), "und");
  1149. const MediaTrack& video_track = *(media_tracks_->tracks()[0]);
  1150. EXPECT_EQ(video_track.type(), MediaTrack::Video);
  1151. EXPECT_EQ(video_track.bytestream_track_id(), 1);
  1152. EXPECT_EQ(video_track.kind().value(), "main");
  1153. EXPECT_EQ(video_track.label().value(), "VideoHandler");
  1154. EXPECT_EQ(video_track.language().value(), "und");
  1155. }
  1156. TEST_F(FFmpegDemuxerTest, Read_Mp4_Multiple_Tracks) {
  1157. CreateDemuxer("bbb-320x240-2video-2audio.mp4");
  1158. InitializeDemuxer();
  1159. EXPECT_EQ(media_tracks_->tracks().size(), 4u);
  1160. const MediaTrack& video_track = *(media_tracks_->tracks()[0]);
  1161. EXPECT_EQ(video_track.type(), MediaTrack::Video);
  1162. EXPECT_EQ(video_track.bytestream_track_id(), 1);
  1163. EXPECT_EQ(video_track.kind().value(), "main");
  1164. EXPECT_EQ(video_track.label().value(), "VideoHandler");
  1165. EXPECT_EQ(video_track.language().value(), "und");
  1166. const MediaTrack& audio_track = *(media_tracks_->tracks()[1]);
  1167. EXPECT_EQ(audio_track.type(), MediaTrack::Audio);
  1168. EXPECT_EQ(audio_track.bytestream_track_id(), 2);
  1169. EXPECT_EQ(audio_track.kind().value(), "main");
  1170. EXPECT_EQ(audio_track.label().value(), "SoundHandler");
  1171. EXPECT_EQ(audio_track.language().value(), "und");
  1172. const MediaTrack& video_track2 = *(media_tracks_->tracks()[2]);
  1173. EXPECT_EQ(video_track2.type(), MediaTrack::Video);
  1174. EXPECT_EQ(video_track2.bytestream_track_id(), 3);
  1175. EXPECT_EQ(video_track2.kind().value(), "main");
  1176. EXPECT_EQ(video_track2.label().value(), "VideoHandler");
  1177. EXPECT_EQ(video_track2.language().value(), "und");
  1178. const MediaTrack& audio_track2 = *(media_tracks_->tracks()[3]);
  1179. EXPECT_EQ(audio_track2.type(), MediaTrack::Audio);
  1180. EXPECT_EQ(audio_track2.bytestream_track_id(), 4);
  1181. EXPECT_EQ(audio_track2.kind().value(), "main");
  1182. EXPECT_EQ(audio_track2.label().value(), "SoundHandler");
  1183. EXPECT_EQ(audio_track2.language().value(), "und");
  1184. }
  1185. TEST_F(FFmpegDemuxerTest, Read_Mp4_Crbug657437) {
  1186. CreateDemuxer("crbug657437.mp4");
  1187. InitializeDemuxer();
  1188. }
  1189. TEST_F(FFmpegDemuxerTest, XHE_AAC) {
  1190. CreateDemuxer("noise-xhe-aac.mp4");
  1191. InitializeDemuxer();
  1192. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  1193. ASSERT_TRUE(audio);
  1194. EXPECT_EQ(audio->audio_decoder_config().profile(),
  1195. AudioCodecProfile::kXHE_AAC);
  1196. // ADTS bitstream conversion shouldn't be enabled for xHE-AAC since it can't
  1197. // be represented with only two bits for the profile.
  1198. audio->EnableBitstreamConverter();
  1199. EXPECT_FALSE(HasBitstreamConverter(audio));
  1200. // Even though FFmpeg can't decode xHE-AAC content, it should be demuxing it
  1201. // just fine.
  1202. Read(audio, FROM_HERE, 1796, 0, true);
  1203. }
  1204. #endif // BUILDFLAG(USE_PROPRIETARY_CODECS)
  1205. TEST_F(FFmpegDemuxerTest, Read_Webm_Multiple_Tracks) {
  1206. CreateDemuxer("multitrack-3video-2audio.webm");
  1207. InitializeDemuxer();
  1208. EXPECT_EQ(media_tracks_->tracks().size(), 5u);
  1209. const MediaTrack& video_track1 = *(media_tracks_->tracks()[0]);
  1210. EXPECT_EQ(video_track1.type(), MediaTrack::Video);
  1211. EXPECT_EQ(video_track1.bytestream_track_id(), 1);
  1212. const MediaTrack& video_track2 = *(media_tracks_->tracks()[1]);
  1213. EXPECT_EQ(video_track2.type(), MediaTrack::Video);
  1214. EXPECT_EQ(video_track2.bytestream_track_id(), 2);
  1215. const MediaTrack& video_track3 = *(media_tracks_->tracks()[2]);
  1216. EXPECT_EQ(video_track3.type(), MediaTrack::Video);
  1217. EXPECT_EQ(video_track3.bytestream_track_id(), 3);
  1218. const MediaTrack& audio_track1 = *(media_tracks_->tracks()[3]);
  1219. EXPECT_EQ(audio_track1.type(), MediaTrack::Audio);
  1220. EXPECT_EQ(audio_track1.bytestream_track_id(), 4);
  1221. const MediaTrack& audio_track2 = *(media_tracks_->tracks()[4]);
  1222. EXPECT_EQ(audio_track2.type(), MediaTrack::Audio);
  1223. EXPECT_EQ(audio_track2.bytestream_track_id(), 5);
  1224. }
  1225. TEST_F(FFmpegDemuxerTest, Read_Webm_Media_Track_Info) {
  1226. CreateDemuxer("bear.webm");
  1227. InitializeDemuxer();
  1228. EXPECT_EQ(media_tracks_->tracks().size(), 2u);
  1229. const MediaTrack& video_track = *(media_tracks_->tracks()[0]);
  1230. EXPECT_EQ(video_track.type(), MediaTrack::Video);
  1231. EXPECT_EQ(video_track.bytestream_track_id(), 1);
  1232. EXPECT_EQ(video_track.kind().value(), "main");
  1233. EXPECT_EQ(video_track.label().value(), "");
  1234. EXPECT_EQ(video_track.language().value(), "");
  1235. const MediaTrack& audio_track = *(media_tracks_->tracks()[1]);
  1236. EXPECT_EQ(audio_track.type(), MediaTrack::Audio);
  1237. EXPECT_EQ(audio_track.bytestream_track_id(), 2);
  1238. EXPECT_EQ(audio_track.kind().value(), "main");
  1239. EXPECT_EQ(audio_track.label().value(), "");
  1240. EXPECT_EQ(audio_track.language().value(), "");
  1241. }
  1242. // UTCDateToTime_* tests here assume FFmpegDemuxer's ExtractTimelineOffset
  1243. // helper uses base::Time::FromUTCString() for conversion.
  1244. TEST_F(FFmpegDemuxerTest, UTCDateToTime_Valid) {
  1245. base::Time result;
  1246. EXPECT_TRUE(
  1247. base::Time::FromUTCString("2012-11-10T12:34:56.987654Z", &result));
  1248. base::Time::Exploded exploded;
  1249. result.UTCExplode(&exploded);
  1250. EXPECT_TRUE(exploded.HasValidValues());
  1251. EXPECT_EQ(2012, exploded.year);
  1252. EXPECT_EQ(11, exploded.month);
  1253. EXPECT_EQ(6, exploded.day_of_week);
  1254. EXPECT_EQ(10, exploded.day_of_month);
  1255. EXPECT_EQ(12, exploded.hour);
  1256. EXPECT_EQ(34, exploded.minute);
  1257. EXPECT_EQ(56, exploded.second);
  1258. EXPECT_EQ(987, exploded.millisecond);
  1259. // base::Time exploding operations round fractional milliseconds down, so
  1260. // verify fractional milliseconds using a base::TimeDelta.
  1261. base::Time without_fractional_ms;
  1262. EXPECT_TRUE(base::Time::FromUTCExploded(exploded, &without_fractional_ms));
  1263. base::TimeDelta delta = result - without_fractional_ms;
  1264. EXPECT_EQ(654, delta.InMicroseconds());
  1265. }
  1266. TEST_F(FFmpegDemuxerTest, UTCDateToTime_Invalid) {
  1267. const char* invalid_date_strings[] = {
  1268. "",
  1269. "12:34:56",
  1270. "-- ::",
  1271. "2012-11- 12:34:56",
  1272. "2012--10 12:34:56",
  1273. "-11-10 12:34:56",
  1274. "2012-11 12:34:56",
  1275. "ABCD-11-10 12:34:56",
  1276. "2012-EF-10 12:34:56",
  1277. "2012-11-GH 12:34:56",
  1278. "2012-11-1012:34:56",
  1279. };
  1280. for (size_t i = 0; i < std::size(invalid_date_strings); ++i) {
  1281. const char* date_string = invalid_date_strings[i];
  1282. base::Time result;
  1283. EXPECT_FALSE(base::Time::FromUTCString(date_string, &result))
  1284. << "date_string '" << date_string << "'";
  1285. }
  1286. }
  1287. static void VerifyFlacStream(DemuxerStream* stream,
  1288. int expected_bits_per_channel,
  1289. ChannelLayout expected_channel_layout,
  1290. int expected_samples_per_second,
  1291. SampleFormat expected_sample_format) {
  1292. ASSERT_TRUE(stream);
  1293. EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
  1294. const AudioDecoderConfig& audio_config = stream->audio_decoder_config();
  1295. EXPECT_EQ(AudioCodec::kFLAC, audio_config.codec());
  1296. EXPECT_EQ(expected_bits_per_channel, audio_config.bits_per_channel());
  1297. EXPECT_EQ(expected_channel_layout, audio_config.channel_layout());
  1298. EXPECT_EQ(expected_samples_per_second, audio_config.samples_per_second());
  1299. EXPECT_EQ(expected_sample_format, audio_config.sample_format());
  1300. }
  1301. TEST_F(FFmpegDemuxerTest, Read_Flac) {
  1302. CreateDemuxer("sfx.flac");
  1303. InitializeDemuxer();
  1304. // Video stream should not be present.
  1305. EXPECT_EQ(nullptr, GetStream(DemuxerStream::VIDEO));
  1306. VerifyFlacStream(GetStream(DemuxerStream::AUDIO), 32, CHANNEL_LAYOUT_MONO,
  1307. 44100, kSampleFormatS32);
  1308. }
  1309. TEST_F(FFmpegDemuxerTest, Read_Flac_Mp4) {
  1310. CreateDemuxer("bear-flac.mp4");
  1311. InitializeDemuxer();
  1312. // Video stream should not be present.
  1313. EXPECT_EQ(nullptr, GetStream(DemuxerStream::VIDEO));
  1314. VerifyFlacStream(GetStream(DemuxerStream::AUDIO), 32, CHANNEL_LAYOUT_STEREO,
  1315. 44100, kSampleFormatS32);
  1316. }
  1317. TEST_F(FFmpegDemuxerTest, Read_Flac_192kHz_Mp4) {
  1318. CreateDemuxer("bear-flac-192kHz.mp4");
  1319. InitializeDemuxer();
  1320. // Video stream should not be present.
  1321. EXPECT_EQ(nullptr, GetStream(DemuxerStream::VIDEO));
  1322. VerifyFlacStream(GetStream(DemuxerStream::AUDIO), 32, CHANNEL_LAYOUT_STEREO,
  1323. 192000, kSampleFormatS32);
  1324. }
  1325. // Verify that FFmpeg demuxer falls back to choosing disabled streams for
  1326. // seeking if there's no suitable enabled stream found.
  1327. TEST_F(FFmpegDemuxerTest, Seek_FallbackToDisabledVideoStream) {
  1328. // Input has only video stream, no audio.
  1329. CreateDemuxer("bear-320x240-video-only.webm");
  1330. InitializeDemuxer();
  1331. EXPECT_EQ(nullptr, GetStream(DemuxerStream::AUDIO));
  1332. FFmpegDemuxerStream* vstream =
  1333. static_cast<FFmpegDemuxerStream*>(GetStream(DemuxerStream::VIDEO));
  1334. EXPECT_NE(nullptr, vstream);
  1335. EXPECT_EQ(vstream, preferred_seeking_stream(base::TimeDelta()));
  1336. // Now pretend that video stream got disabled, e.g. due to current tab going
  1337. // into background.
  1338. vstream->SetEnabled(false, base::TimeDelta());
  1339. // Since there's no other enabled streams, the preferred seeking stream should
  1340. // still be the video stream.
  1341. EXPECT_EQ(vstream, preferred_seeking_stream(base::TimeDelta()));
  1342. }
  1343. TEST_F(FFmpegDemuxerTest, Seek_FallbackToDisabledAudioStream) {
  1344. CreateDemuxer("bear-320x240-audio-only.webm");
  1345. InitializeDemuxer();
  1346. FFmpegDemuxerStream* astream =
  1347. static_cast<FFmpegDemuxerStream*>(GetStream(DemuxerStream::AUDIO));
  1348. EXPECT_NE(nullptr, astream);
  1349. EXPECT_EQ(nullptr, GetStream(DemuxerStream::VIDEO));
  1350. EXPECT_EQ(astream, preferred_seeking_stream(base::TimeDelta()));
  1351. // Now pretend that audio stream got disabled.
  1352. astream->SetEnabled(false, base::TimeDelta());
  1353. // Since there's no other enabled streams, the preferred seeking stream should
  1354. // still be the audio stream.
  1355. EXPECT_EQ(astream, preferred_seeking_stream(base::TimeDelta()));
  1356. }
  1357. namespace {
  1358. void QuitLoop(base::OnceClosure quit_closure,
  1359. DemuxerStream::Type type,
  1360. const std::vector<DemuxerStream*>& streams) {
  1361. std::move(quit_closure).Run();
  1362. }
  1363. void DisableAndEnableDemuxerTracks(
  1364. FFmpegDemuxer* demuxer,
  1365. base::test::TaskEnvironment* task_environment) {
  1366. base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
  1367. base::WaitableEvent::InitialState::NOT_SIGNALED);
  1368. std::vector<MediaTrack::Id> audio_tracks;
  1369. std::vector<MediaTrack::Id> video_tracks;
  1370. base::RunLoop disable_video;
  1371. demuxer->OnSelectedVideoTrackChanged(
  1372. video_tracks, base::TimeDelta(),
  1373. base::BindOnce(QuitLoop, disable_video.QuitClosure()));
  1374. disable_video.Run();
  1375. base::RunLoop disable_audio;
  1376. demuxer->OnEnabledAudioTracksChanged(
  1377. audio_tracks, base::TimeDelta(),
  1378. base::BindOnce(QuitLoop, disable_audio.QuitClosure()));
  1379. disable_audio.Run();
  1380. base::RunLoop enable_video;
  1381. video_tracks.push_back(MediaTrack::Id("1"));
  1382. demuxer->OnSelectedVideoTrackChanged(
  1383. video_tracks, base::TimeDelta(),
  1384. base::BindOnce(QuitLoop, enable_video.QuitClosure()));
  1385. enable_video.Run();
  1386. base::RunLoop enable_audio;
  1387. audio_tracks.push_back(MediaTrack::Id("2"));
  1388. demuxer->OnEnabledAudioTracksChanged(
  1389. audio_tracks, base::TimeDelta(),
  1390. base::BindOnce(QuitLoop, enable_audio.QuitClosure()));
  1391. enable_audio.Run();
  1392. task_environment->RunUntilIdle();
  1393. }
  1394. void OnReadDoneExpectEos(DemuxerStream::Status status,
  1395. const scoped_refptr<DecoderBuffer> buffer) {
  1396. EXPECT_EQ(status, DemuxerStream::kOk);
  1397. EXPECT_TRUE(buffer->end_of_stream());
  1398. }
  1399. } // namespace
  1400. TEST_F(FFmpegDemuxerTest, StreamStatusNotifications) {
  1401. CreateDemuxer("bear-320x240.webm");
  1402. InitializeDemuxer();
  1403. FFmpegDemuxerStream* audio_stream =
  1404. static_cast<FFmpegDemuxerStream*>(GetStream(DemuxerStream::AUDIO));
  1405. EXPECT_NE(nullptr, audio_stream);
  1406. FFmpegDemuxerStream* video_stream =
  1407. static_cast<FFmpegDemuxerStream*>(GetStream(DemuxerStream::VIDEO));
  1408. EXPECT_NE(nullptr, video_stream);
  1409. // Verify stream status notifications delivery without pending read first.
  1410. DisableAndEnableDemuxerTracks(demuxer_.get(), &task_environment_);
  1411. // Verify that stream notifications are delivered properly when stream status
  1412. // changes with a pending read. Call FlushBuffers before reading, to ensure
  1413. // there is no buffers ready to be returned by the Read right away, thus
  1414. // ensuring that status changes occur while an async read is pending.
  1415. audio_stream->FlushBuffers(true);
  1416. video_stream->FlushBuffers(true);
  1417. audio_stream->Read(base::BindOnce(&OnReadDoneExpectEos));
  1418. video_stream->Read(base::BindOnce(&OnReadDoneExpectEos));
  1419. DisableAndEnableDemuxerTracks(demuxer_.get(), &task_environment_);
  1420. }
  1421. TEST_F(FFmpegDemuxerTest, MultitrackMemoryUsage) {
  1422. CreateDemuxer("multitrack-3video-2audio.webm");
  1423. InitializeDemuxer();
  1424. DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
  1425. // Read from the audio stream to make sure FFmpegDemuxer buffers data for all
  1426. // streams with available capacity, i.e all enabled streams. By default only
  1427. // the first audio and the first video stream are enabled, so the memory usage
  1428. // shouldn't be too high.
  1429. Read(audio, FROM_HERE, 304, 0, true);
  1430. EXPECT_EQ(22134, demuxer_->GetMemoryUsage());
  1431. // Now enable all demuxer streams in the file and perform another read, this
  1432. // will buffer the data for additional streams and memory usage will increase.
  1433. std::vector<DemuxerStream*> streams = demuxer_->GetAllStreams();
  1434. for (auto* stream : streams) {
  1435. static_cast<FFmpegDemuxerStream*>(stream)->SetEnabled(true,
  1436. base::TimeDelta());
  1437. }
  1438. Read(audio, FROM_HERE, 166, 21000, true);
  1439. // With newly enabled demuxer streams the amount of memory used by the demuxer
  1440. // is much higher.
  1441. EXPECT_EQ(156011, demuxer_->GetMemoryUsage());
  1442. }
  1443. TEST_F(FFmpegDemuxerTest, SeekOnVideoTrackChangeWontSeekIfEmpty) {
  1444. // We only care about video tracks.
  1445. CreateDemuxer("bear-320x240-video-only.webm");
  1446. InitializeDemuxer();
  1447. std::vector<DemuxerStream*> streams;
  1448. base::RunLoop loop;
  1449. SeekOnVideoTrackChangePassthrough(
  1450. base::TimeDelta(), base::BindOnce(QuitLoop, loop.QuitClosure()),
  1451. DemuxerStream::VIDEO, streams);
  1452. loop.Run();
  1453. }
  1454. } // namespace media