media/remoting/fake_media_resource.cc

   1 // Copyright 2016 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 "media/remoting/fake_media_resource.h"
   6
   7 #include <vector>
   8
   9 #include "base/functional/callback_helpers.h"
  10 #include "media/base/decoder_buffer.h"
  11 #include "media/base/media_util.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using testing::_;
  15 using testing::Invoke;
  16 using testing::Return;
  17
  18 namespace media {
  19 namespace remoting {
  20
  21 FakeDemuxerStream::FakeDemuxerStream(bool is_audio) {
  22   type_ = is_audio ? DemuxerStream::AUDIO : DemuxerStream::VIDEO;
  23   if (is_audio) {
  24     audio_config_.Initialize(
  25         AudioCodec::kAAC, kSampleFormatS16, CHANNEL_LAYOUT_STEREO, 38400,
  26         std::vector<uint8_t>(), EncryptionScheme::kUnencrypted,
  27         base::TimeDelta(), 0);
  28   } else {
  29     gfx::Size size(640, 480);
  30     gfx::Rect rect(0, 0, 640, 480);
  31     video_config_.Initialize(VideoCodec::kH264, H264PROFILE_BASELINE,
  32                              VideoDecoderConfig::AlphaMode::kIsOpaque,
  33                              VideoColorSpace::REC601(), kNoTransformation, size,
  34                              rect, size, std::vector<uint8_t>(),
  35                              EncryptionScheme::kUnencrypted);
  36   }
  37   ON_CALL(*this, Read)
  38       .WillByDefault(Invoke(this, &FakeDemuxerStream::FakeRead));
  39 }
  40
  41 FakeDemuxerStream::~FakeDemuxerStream() = default;
  42
  43 // Only return one buffer at a time so we ignore the count.
  44 void FakeDemuxerStream::FakeRead(uint32_t /*count*/, ReadCB read_cb) {
  45   if (buffer_queue_.empty()) {
  46     // Silent return to simulate waiting for buffer available.
  47     pending_read_cb_ = std::move(read_cb);
  48     return;
  49   }
  50   scoped_refptr<DecoderBuffer> buffer = buffer_queue_.front();
  51   buffer_queue_.pop_front();
  52   std::move(read_cb).Run(kOk, {std::move(buffer)});
  53 }
  54
  55 AudioDecoderConfig FakeDemuxerStream::audio_decoder_config() {
  56   return audio_config_;
  57 }
  58
  59 VideoDecoderConfig FakeDemuxerStream::video_decoder_config() {
  60   return video_config_;
  61 }
  62
  63 DemuxerStream::Type FakeDemuxerStream::type() const {
  64   return type_;
  65 }
  66
  67 StreamLiveness FakeDemuxerStream::liveness() const {
  68   return StreamLiveness::kUnknown;
  69 }
  70
  71 bool FakeDemuxerStream::SupportsConfigChanges() {
  72   return false;
  73 }
  74
  75 void FakeDemuxerStream::CreateFakeFrame(size_t size,
  76                                         bool key_frame,
  77                                         int pts_ms) {
  78   std::vector<uint8_t> buffer(size);
  79   // Assign each byte in the buffer its index mod 256.
  80   for (size_t i = 0; i < size; ++i) {
  81     buffer[i] = static_cast<uint8_t>(i & 0xFF);
  82   }
  83   base::TimeDelta pts = base::Milliseconds(pts_ms);
  84
  85   // To DecoderBuffer
  86   scoped_refptr<DecoderBuffer> input_buffer =
  87       DecoderBuffer::CopyFrom(buffer.data(), size);
  88   input_buffer->set_timestamp(pts);
  89   input_buffer->set_is_key_frame(key_frame);
  90
  91   // Sends frame out if there is pending read callback. Otherwise, stores it
  92   // in the buffer queue.
  93   if (!pending_read_cb_) {
  94     buffer_queue_.push_back(input_buffer);
  95   } else {
  96     std::move(pending_read_cb_).Run(kOk, {std::move(input_buffer)});
  97   }
  98 }
  99
 100 FakeMediaResource::FakeMediaResource()
 101     : audio_stream_(new FakeDemuxerStream(true)),
 102       video_stream_(new FakeDemuxerStream(false)) {}
 103
 104 FakeMediaResource::~FakeMediaResource() = default;
 105
 106 std::vector<DemuxerStream*> FakeMediaResource::GetAllStreams() {
 107   std::vector<DemuxerStream*> streams;
 108   streams.push_back(audio_stream_.get());
 109   streams.push_back(video_stream_.get());
 110   return streams;
 111 }
 112
 113 }  // namespace remoting
 114 }  // namespace media