1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
media / mojo / services / stable_video_decoder_factory_service.cc [blame]
// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/mojo/services/stable_video_decoder_factory_service.h"
#include "base/task/single_thread_task_runner.h"
#include "base/task/thread_pool.h"
#include "components/viz/common/switches.h"
#include "gpu/config/gpu_driver_bug_workarounds.h"
#include "gpu/config/gpu_preferences.h"
#include "media/base/media_log.h"
#include "media/base/media_util.h"
#include "media/gpu/buildflags.h"
#include "media/gpu/chromeos/frame_registry.h"
#include "media/gpu/chromeos/platform_video_frame_pool.h"
#include "media/gpu/chromeos/registered_frame_converter.h"
#include "media/gpu/chromeos/video_decoder_pipeline.h"
#include "media/gpu/gpu_video_accelerator_util.h"
#include "media/gpu/gpu_video_decode_accelerator_helpers.h"
#include "media/mojo/services/mojo_media_client.h"
#include "media/mojo/services/mojo_video_decoder_service.h"
#include "media/mojo/services/stable_video_decoder_service.h"
#include "media/video/video_decode_accelerator.h"
#include "mojo/public/cpp/bindings/self_owned_receiver.h"
namespace media {
namespace {
// This is a lighter alternative to using a GpuMojoMediaClient. While we could
// use a GpuMojoMediaClient, that would be abusing the abstraction a bit since
// that class is too semantically coupled with the GPU process through things
// like its |gpu_task_runner_| and |media_gpu_channel_manager_| members.
class MojoMediaClientImpl : public MojoMediaClient {
public:
MojoMediaClientImpl(const gpu::GpuFeatureInfo& gpu_feature_info,
scoped_refptr<FrameRegistry> frame_registry)
: gpu_driver_bug_workarounds_(
gpu_feature_info.enabled_gpu_driver_bug_workarounds),
frame_registry_(std::move(frame_registry)) {}
MojoMediaClientImpl(const MojoMediaClientImpl&) = delete;
MojoMediaClientImpl& operator=(const MojoMediaClientImpl&) = delete;
~MojoMediaClientImpl() override = default;
// MojoMediaClient implementation.
std::vector<SupportedVideoDecoderConfig> GetSupportedVideoDecoderConfigs()
final {
std::optional<std::vector<SupportedVideoDecoderConfig>> configs;
switch (GetDecoderImplementationType()) {
case VideoDecoderType::kVaapi:
case VideoDecoderType::kV4L2:
configs = VideoDecoderPipeline::GetSupportedConfigs(
GetDecoderImplementationType(), gpu_driver_bug_workarounds_);
break;
default:
NOTREACHED();
}
return configs.value_or(std::vector<SupportedVideoDecoderConfig>{});
}
VideoDecoderType GetDecoderImplementationType() final {
// TODO(b/195769334): how can we keep this in sync with
// VideoDecoderPipeline::GetDecoderType()?
#if BUILDFLAG(USE_VAAPI)
return VideoDecoderType::kVaapi;
#elif BUILDFLAG(USE_V4L2_CODEC)
return VideoDecoderType::kV4L2;
#else
#error StableVideoDecoderFactoryService should only be built on platforms that
#error support video decode acceleration through either VA-API or V4L2.
#endif
}
std::unique_ptr<VideoDecoder> CreateVideoDecoder(
scoped_refptr<base::SequencedTaskRunner> task_runner,
MediaLog* media_log,
mojom::CommandBufferIdPtr command_buffer_id,
RequestOverlayInfoCB request_overlay_info_cb,
const gfx::ColorSpace& target_color_space,
mojo::PendingRemote<stable::mojom::StableVideoDecoder> oop_video_decoder)
final {
// For out-of-process video decoding, |command_buffer_id| is not used and
// should not be supplied.
DCHECK(!command_buffer_id);
DCHECK(!oop_video_decoder);
std::unique_ptr<MediaLog> log =
media_log ? media_log->Clone()
: std::make_unique<media::NullMediaLog>();
CHECK_NE(GetDecoderImplementationType(), VideoDecoderType::kVda);
return VideoDecoderPipeline::Create(
gpu_driver_bug_workarounds_,
/*client_task_runner=*/std::move(task_runner),
std::make_unique<PlatformVideoFramePool>(),
RegisteredFrameConverter::Create(frame_registry_),
VideoDecoderPipeline::DefaultPreferredRenderableFourccs(),
std::move(log),
/*oop_video_decoder=*/{},
/*in_video_decoder_process=*/true);
}
private:
const gpu::GpuDriverBugWorkarounds gpu_driver_bug_workarounds_;
const scoped_refptr<FrameRegistry> frame_registry_;
};
} // namespace
StableVideoDecoderFactoryService::StableVideoDecoderFactoryService(
const gpu::GpuFeatureInfo& gpu_feature_info)
: receiver_(this),
frame_registry_(base::MakeRefCounted<FrameRegistry>()),
mojo_media_client_(
std::make_unique<MojoMediaClientImpl>(gpu_feature_info,
frame_registry_)) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
mojo_media_client_->Initialize();
}
StableVideoDecoderFactoryService::~StableVideoDecoderFactoryService() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}
void StableVideoDecoderFactoryService::BindReceiver(
mojo::PendingReceiver<stable::mojom::StableVideoDecoderFactory> receiver,
base::OnceClosure disconnect_cb) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// The browser process should guarantee that BindReceiver() is only called
// once.
DCHECK(!receiver_.is_bound());
receiver_.Bind(std::move(receiver));
receiver_.set_disconnect_handler(std::move(disconnect_cb));
}
void StableVideoDecoderFactoryService::CreateStableVideoDecoder(
mojo::PendingReceiver<stable::mojom::StableVideoDecoder> receiver,
mojo::PendingRemote<stable::mojom::StableVideoDecoderTracker> tracker) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
std::unique_ptr<mojom::VideoDecoder> dst_video_decoder;
if (video_decoder_creation_cb_for_testing_) {
dst_video_decoder = video_decoder_creation_cb_for_testing_.Run(
mojo_media_client_.get(), &cdm_service_context_);
} else {
dst_video_decoder = std::make_unique<MojoVideoDecoderService>(
mojo_media_client_.get(), &cdm_service_context_,
mojo::PendingRemote<stable::mojom::StableVideoDecoder>());
}
video_decoders_.Add(std::make_unique<StableVideoDecoderService>(
std::move(tracker), std::move(dst_video_decoder),
&cdm_service_context_, frame_registry_),
std::move(receiver));
}
} // namespace media