media/mojo/services/mojo_demuxer_stream_adapter.cc

   1 // Copyright 2014 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/mojo/services/mojo_demuxer_stream_adapter.h"
   6
   7 #include <stdint.h>
   8
   9 #include <memory>
  10 #include <utility>
  11
  12 #include "base/functional/bind.h"
  13 #include "base/functional/callback_helpers.h"
  14 #include "base/numerics/safe_conversions.h"
  15 #include "media/base/decoder_buffer.h"
  16 #include "media/mojo/common/media_type_converters.h"
  17 #include "media/mojo/common/mojo_decoder_buffer_converter.h"
  18 #include "mojo/public/cpp/system/data_pipe.h"
  19
  20 namespace media {
  21
  22 MojoDemuxerStreamAdapter::MojoDemuxerStreamAdapter(
  23     mojo::PendingRemote<mojom::DemuxerStream> demuxer_stream,
  24     base::OnceClosure stream_ready_cb)
  25     : demuxer_stream_(std::move(demuxer_stream)),
  26       stream_ready_cb_(std::move(stream_ready_cb)) {
  27   DVLOG(1) << __func__;
  28   demuxer_stream_->Initialize(base::BindOnce(
  29       &MojoDemuxerStreamAdapter::OnStreamReady, weak_factory_.GetWeakPtr()));
  30 }
  31
  32 MojoDemuxerStreamAdapter::~MojoDemuxerStreamAdapter() {
  33   DVLOG(1) << __func__;
  34 }
  35
  36 void MojoDemuxerStreamAdapter::Read(uint32_t count, ReadCB read_cb) {
  37   DVLOG(3) << __func__;
  38   // We shouldn't be holding on to a previous callback if a new Read() came in.
  39   DCHECK(!read_cb_);
  40
  41   read_cb_ = std::move(read_cb);
  42   demuxer_stream_->Read(count,
  43                         base::BindOnce(&MojoDemuxerStreamAdapter::OnBufferReady,
  44                                        weak_factory_.GetWeakPtr()));
  45 }
  46
  47 AudioDecoderConfig MojoDemuxerStreamAdapter::audio_decoder_config() {
  48   DCHECK_EQ(type_, AUDIO);
  49   return audio_config_;
  50 }
  51
  52 VideoDecoderConfig MojoDemuxerStreamAdapter::video_decoder_config() {
  53   DCHECK_EQ(type_, VIDEO);
  54   return video_config_;
  55 }
  56
  57 DemuxerStream::Type MojoDemuxerStreamAdapter::type() const {
  58   return type_;
  59 }
  60
  61 void MojoDemuxerStreamAdapter::EnableBitstreamConverter() {
  62   demuxer_stream_->EnableBitstreamConverter();
  63 }
  64
  65 bool MojoDemuxerStreamAdapter::SupportsConfigChanges() {
  66   return true;
  67 }
  68
  69 // TODO(xhwang): Pass liveness here.
  70 void MojoDemuxerStreamAdapter::OnStreamReady(
  71     Type type,
  72     mojo::ScopedDataPipeConsumerHandle consumer_handle,
  73     const absl::optional<AudioDecoderConfig>& audio_config,
  74     const absl::optional<VideoDecoderConfig>& video_config) {
  75   DVLOG(1) << __func__;
  76   DCHECK_EQ(UNKNOWN, type_);
  77   DCHECK(consumer_handle.is_valid());
  78
  79   type_ = type;
  80
  81   mojo_decoder_buffer_reader_ =
  82       std::make_unique<MojoDecoderBufferReader>(std::move(consumer_handle));
  83
  84   UpdateConfig(std::move(audio_config), std::move(video_config));
  85
  86   std::move(stream_ready_cb_).Run();
  87 }
  88
  89 void MojoDemuxerStreamAdapter::OnBufferReady(
  90     Status status,
  91     std::vector<mojom::DecoderBufferPtr> batch_buffers,
  92     const absl::optional<AudioDecoderConfig>& audio_config,
  93     const absl::optional<VideoDecoderConfig>& video_config) {
  94   DVLOG(3) << __func__ << ": status=" << status
  95            << ", batch_buffers.size=" << batch_buffers.size();
  96   DCHECK(read_cb_);
  97   DCHECK_NE(type_, UNKNOWN);
  98
  99 #if defined(TIZEN_MULTIMEDIA)
 100   if (!read_cb_) {
 101     LOG(INFO) << __func__ << " (" << DemuxerStream::GetTypeName(type_)
 102               << ") ignoring as cb is null!!";
 103     return;
 104   }
 105 #endif
 106
 107   if (status == kConfigChanged) {
 108     UpdateConfig(std::move(audio_config), std::move(video_config));
 109     std::move(read_cb_).Run(kConfigChanged, {});
 110     return;
 111   }
 112
 113   if (status == kAborted) {
 114     std::move(read_cb_).Run(kAborted, {});
 115     return;
 116   }
 117
 118 #if defined(TIZEN_MULTIMEDIA)
 119   if (status == kNeedBuffer) {
 120     std::move(read_cb_).Run(kNeedBuffer, {});
 121     return;
 122   }
 123 #endif
 124
 125   DCHECK_EQ(status, kOk);
 126   status_ = status;
 127   actual_read_count_ = batch_buffers.size();
 128   for (mojom::DecoderBufferPtr& buffer : batch_buffers) {
 129     mojo_decoder_buffer_reader_->ReadDecoderBuffer(
 130         std::move(buffer),
 131         base::BindOnce(&MojoDemuxerStreamAdapter::OnBufferRead,
 132                        weak_factory_.GetWeakPtr()));
 133   }
 134 }
 135
 136 void MojoDemuxerStreamAdapter::OnBufferRead(
 137     scoped_refptr<DecoderBuffer> buffer) {
 138   if (!buffer) {
 139     std::move(read_cb_).Run(kAborted, {});
 140     buffer_queue_.clear();
 141     return;
 142   }
 143
 144   buffer_queue_.push_back(buffer);
 145   if (buffer_queue_.size() == actual_read_count_) {
 146     std::move(read_cb_).Run(status_, buffer_queue_);
 147     actual_read_count_ = 0;
 148     buffer_queue_.clear();
 149   }
 150 }
 151
 152 void MojoDemuxerStreamAdapter::UpdateConfig(
 153     const absl::optional<AudioDecoderConfig>& audio_config,
 154     const absl::optional<VideoDecoderConfig>& video_config) {
 155   DCHECK_NE(type_, Type::UNKNOWN);
 156   std::string old_decoder_config_str;
 157
 158   switch(type_) {
 159     case AUDIO:
 160       DCHECK(audio_config && !video_config);
 161       old_decoder_config_str = audio_config_.AsHumanReadableString();
 162       audio_config_ = audio_config.value();
 163       TRACE_EVENT_INSTANT2(
 164           "media", "MojoDemuxerStreamAdapter.UpdateConfig.Audio",
 165           TRACE_EVENT_SCOPE_THREAD, "CurrentConfig", old_decoder_config_str,
 166           "NewConfig", audio_config_.AsHumanReadableString());
 167       break;
 168     case VIDEO:
 169       DCHECK(video_config && !audio_config);
 170       old_decoder_config_str = video_config_.AsHumanReadableString();
 171       video_config_ = video_config.value();
 172       TRACE_EVENT_INSTANT2(
 173           "media", "MojoDemuxerStreamAdapter.UpdateConfig.Video",
 174           TRACE_EVENT_SCOPE_THREAD, "CurrentConfig", old_decoder_config_str,
 175           "NewConfig", video_config_.AsHumanReadableString());
 176       break;
 177     default:
 178       NOTREACHED();
 179   }
 180 }
 181
 182 }  // namespace media