OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "media/mojo/services/gpu_mojo_media_client.h" |
| 6 |
| 7 #include "media/base/audio_decoder.h" |
| 8 #include "media/base/cdm_factory.h" |
| 9 #include "media/base/video_decoder.h" |
| 10 |
| 11 #if defined(OS_ANDROID) |
| 12 #include "base/memory/ptr_util.h" |
| 13 #include "media/base/android/android_cdm_factory.h" |
| 14 #include "media/filters/android/media_codec_audio_decoder.h" |
| 15 #include "media/mojo/interfaces/provision_fetcher.mojom.h" |
| 16 #include "media/mojo/services/mojo_provision_fetcher.h" |
| 17 #include "services/service_manager/public/cpp/connect.h" |
| 18 #endif // defined(OS_ANDROID) |
| 19 |
| 20 #include "gpu/ipc/service/gpu_channel.h" |
| 21 #include "gpu/ipc/service/gpu_command_buffer_stub.h" |
| 22 #include "media/gpu/ipc/service/media_gpu_channel_manager.h" |
| 23 |
| 24 namespace media { |
| 25 |
| 26 namespace { |
| 27 |
| 28 #if defined(OS_ANDROID) |
| 29 std::unique_ptr<ProvisionFetcher> CreateProvisionFetcher( |
| 30 service_manager::mojom::InterfaceProvider* interface_provider) { |
| 31 mojom::ProvisionFetcherPtr provision_fetcher_ptr; |
| 32 service_manager::GetInterface(interface_provider, &provision_fetcher_ptr); |
| 33 return base::MakeUnique<MojoProvisionFetcher>( |
| 34 std::move(provision_fetcher_ptr)); |
| 35 } |
| 36 #endif // defined(OS_ANDROID) |
| 37 |
| 38 class TestVideoDecoder : public VideoDecoder { |
| 39 public: |
| 40 TestVideoDecoder( |
| 41 scoped_refptr<base::SingleThreadTaskRunner> task_runner, |
| 42 scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner, |
| 43 base::WeakPtr<MediaGpuChannelManager> media_gpu_channel_manager, |
| 44 mojom::CommandBufferIdPtr command_buffer_id) |
| 45 : weak_factory_(this) { |
| 46 CHECK(command_buffer_id); |
| 47 weak_this_ = weak_factory_.GetWeakPtr(); |
| 48 gpu_task_runner->PostTask(FROM_HERE, base::Bind( |
| 49 &TestVideoDecoder::InitializeOnGpuThread, weak_this_, |
| 50 media_gpu_channel_manager, command_buffer_id->channel_token, |
| 51 command_buffer_id->route_id)); |
| 52 } |
| 53 |
| 54 void InitializeOnGpuThread( |
| 55 base::WeakPtr<MediaGpuChannelManager> media_gpu_channel_manager, |
| 56 base::UnguessableToken channel_token, |
| 57 int32_t route_id) { |
| 58 CHECK(media_gpu_channel_manager); |
| 59 gpu::GpuChannel* channel = media_gpu_channel_manager->LookupChannel( |
| 60 channel_token); |
| 61 CHECK(channel); |
| 62 gpu::GpuCommandBufferStub* stub = channel->LookupCommandBuffer(route_id); |
| 63 CHECK(stub); |
| 64 LOG(ERROR) << "route_id: " << stub->route_id(); |
| 65 LOG(ERROR) << "stream_id: " << stub->stream_id(); |
| 66 } |
| 67 |
| 68 std::string GetDisplayName() const override { |
| 69 return "TestVideoDecoder"; |
| 70 } |
| 71 |
| 72 void Initialize(const VideoDecoderConfig& config, |
| 73 bool low_delay, |
| 74 CdmContext* cdm_context, |
| 75 const InitCB& init_cb, |
| 76 const OutputCB& output_cb) override { |
| 77 } |
| 78 |
| 79 void Decode(const scoped_refptr<DecoderBuffer>& buffer, |
| 80 const DecodeCB& decode_cb) override { |
| 81 } |
| 82 |
| 83 void Reset(const base::Closure& closure) override { |
| 84 } |
| 85 |
| 86 private: |
| 87 base::WeakPtr<TestVideoDecoder> weak_this_; |
| 88 base::WeakPtrFactory<TestVideoDecoder> weak_factory_; |
| 89 }; |
| 90 |
| 91 } // namespace |
| 92 |
| 93 GpuMojoMediaClient::GpuMojoMediaClient( |
| 94 scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner, |
| 95 base::WeakPtr<MediaGpuChannelManager> media_gpu_channel_manager) |
| 96 : gpu_task_runner_(std::move(gpu_task_runner)), |
| 97 media_gpu_channel_manager_(std::move(media_gpu_channel_manager)) {} |
| 98 |
| 99 GpuMojoMediaClient::~GpuMojoMediaClient() {} |
| 100 |
| 101 std::unique_ptr<AudioDecoder> GpuMojoMediaClient::CreateAudioDecoder( |
| 102 scoped_refptr<base::SingleThreadTaskRunner> task_runner) { |
| 103 #if defined(OS_ANDROID) |
| 104 return base::MakeUnique<MediaCodecAudioDecoder>(task_runner); |
| 105 #else |
| 106 return nullptr; |
| 107 #endif // defined(OS_ANDROID) |
| 108 } |
| 109 |
| 110 std::unique_ptr<VideoDecoder> GpuMojoMediaClient::CreateVideoDecoder( |
| 111 scoped_refptr<base::SingleThreadTaskRunner> task_runner, |
| 112 mojom::CommandBufferIdPtr command_buffer_id) { |
| 113 return base::MakeUnique<TestVideoDecoder>( |
| 114 std::move(task_runner), gpu_task_runner_, media_gpu_channel_manager_, |
| 115 std::move(command_buffer_id)); |
| 116 } |
| 117 |
| 118 std::unique_ptr<CdmFactory> GpuMojoMediaClient::CreateCdmFactory( |
| 119 service_manager::mojom::InterfaceProvider* interface_provider) { |
| 120 #if defined(OS_ANDROID) |
| 121 return base::MakeUnique<AndroidCdmFactory>( |
| 122 base::Bind(&CreateProvisionFetcher, interface_provider)); |
| 123 #else |
| 124 return nullptr; |
| 125 #endif // defined(OS_ANDROID) |
| 126 } |
| 127 |
| 128 } // namespace media |
OLD | NEW |