media/filters/hls_codec_detector_unittest.cc

   1 // Copyright 2023 The Chromium Authors
   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 <memory>
   6 #include <string>
   7 #include <vector>
   8
   9 #include "base/files/file_util.h"
  10 #include "base/memory/scoped_refptr.h"
  11 #include "base/run_loop.h"
  12 #include "base/test/gmock_callback_support.h"
  13 #include "base/test/task_environment.h"
  14 #include "media/base/mock_media_log.h"
  15 #include "media/base/pipeline_status.h"
  16 #include "media/filters/hls_codec_detector.h"
  17 #include "media/filters/hls_data_source_provider.h"
  18 #include "media/filters/hls_test_helpers.h"
  19 #include "testing/gmock/include/gmock/gmock.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 namespace media {
  23
  24 using ::base::test::RunOnceCallback;
  25 using testing::_;
  26 using testing::AtLeast;
  27 using testing::DoAll;
  28 using testing::Eq;
  29 using testing::Invoke;
  30 using testing::NiceMock;
  31 using testing::NotNull;
  32 using testing::Ref;
  33 using testing::Return;
  34 using testing::SaveArg;
  35 using testing::SetArgPointee;
  36
  37 class HlsCodecDetectorTest : public testing::Test {
  38  public:
  39   HlsCodecDetectorTest()
  40       : media_log_(std::make_unique<NiceMock<media::MockMediaLog>>()),
  41         mock_hrh_(std::make_unique<media::MockHlsRenditionHost>()),
  42         detector_(std::make_unique<HlsCodecDetectorImpl>(media_log_.get(),
  43                                                          mock_hrh_.get())) {}
  44
  45   ~HlsCodecDetectorTest() override { task_environment_.RunUntilIdle(); }
  46
  47  protected:
  48   MOCK_METHOD(void, CodecsOk, (std::string codecs), ());
  49   MOCK_METHOD(void, ContainerOk, (std::string codecs), ());
  50   MOCK_METHOD(void, DetectionFailed, (HlsDemuxerStatus codecs), ());
  51
  52   void OnDetection(
  53       HlsDemuxerStatus::Or<HlsCodecDetector::ContainerAndCodecs> result) {
  54     if (result.has_value()) {
  55       auto cnc = std::move(result).value();
  56       ContainerOk(cnc.container);
  57       CodecsOk(cnc.codecs);
  58     } else {
  59       return DetectionFailed(std::move(result).error());
  60     }
  61   }
  62
  63   void CheckCodecs(std::unique_ptr<HlsDataSourceStream> stream) {
  64     EXPECT_CALL(*mock_hrh_, ReadStream(_, _))
  65         .WillOnce([](std::unique_ptr<HlsDataSourceStream> stream,
  66                      HlsDataSourceProvider::ReadCb cb) {
  67           std::move(cb).Run(std::move(stream));
  68         });
  69
  70     detector_->DetermineContainerAndCodec(
  71         std::move(stream), base::BindOnce(&HlsCodecDetectorTest::OnDetection,
  72                                           base::Unretained(this)));
  73   }
  74
  75   void CheckContainer(std::unique_ptr<HlsDataSourceStream> stream) {
  76     EXPECT_CALL(*mock_hrh_, ReadStream(_, _))
  77         .WillOnce([](std::unique_ptr<HlsDataSourceStream> stream,
  78                      HlsDataSourceProvider::ReadCb cb) {
  79           std::move(cb).Run(std::move(stream));
  80         });
  81     detector_->DetermineContainerOnly(
  82         std::move(stream), base::BindOnce(&HlsCodecDetectorTest::OnDetection,
  83                                           base::Unretained(this)));
  84   }
  85
  86   base::test::TaskEnvironment task_environment_;
  87   std::unique_ptr<MediaLog> media_log_;
  88   std::unique_ptr<MockHlsRenditionHost> mock_hrh_;
  89   std::unique_ptr<HlsCodecDetector> detector_;
  90 };
  91
  92 TEST_F(HlsCodecDetectorTest, TestTS) {
  93   auto stream =
  94       FileHlsDataSourceStreamFactory::CreateStream("bear-1280x720-hls.ts");
  95   EXPECT_CALL(*this, CodecsOk("avc1.420000, mp4a.40.05"));
  96   EXPECT_CALL(*this, ContainerOk("video/mp2t"));
  97   CheckCodecs(std::move(stream));
  98   task_environment_.RunUntilIdle();
  99
 100   stream = FileHlsDataSourceStreamFactory::CreateStream("bear-1280x720-hls.ts");
 101   EXPECT_CALL(*this, CodecsOk(""));
 102   EXPECT_CALL(*this, ContainerOk("video/mp2t"));
 103   CheckContainer(std::move(stream));
 104   task_environment_.RunUntilIdle();
 105 }
 106
 107 TEST_F(HlsCodecDetectorTest, TestFmp4) {
 108   auto stream = FileHlsDataSourceStreamFactory::CreateStream(
 109       "bear-1280x720-avt_subt_frag.mp4");
 110   EXPECT_CALL(*this, DetectionFailed(_));
 111   CheckCodecs(std::move(stream));
 112   task_environment_.RunUntilIdle();
 113 }
 114
 115 }  // namespace media