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
|
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef MEDIA_GPU_ANDROID_POOLED_SHARED_IMAGE_VIDEO_PROVIDER_H_
#define MEDIA_GPU_ANDROID_POOLED_SHARED_IMAGE_VIDEO_PROVIDER_H_
#include "base/memory/weak_ptr.h"
#include "base/threading/sequence_bound.h"
#include "gpu/ipc/service/command_buffer_stub.h"
#include "media/gpu/android/shared_image_video_provider.h"
#include "media/gpu/command_buffer_helper.h"
namespace media {
class PooledSharedImageVideoProviderTest;
// Provider class for shared images.
class MEDIA_GPU_EXPORT PooledSharedImageVideoProvider
: public SharedImageVideoProvider,
public gpu::RefCountedLockHelperDrDc {
public:
// Helper class that processes image returns on the gpu thread.
class GpuHelper {
public:
GpuHelper() = default;
GpuHelper(const GpuHelper&) = delete;
GpuHelper& operator=(const GpuHelper&) = delete;
virtual ~GpuHelper() = default;
// Called (on the gpu thread) to handle image return.
virtual void OnImageReturned(
const gpu::SyncToken& sync_token,
scoped_refptr<CodecImageHolder> codec_image_holder,
base::OnceClosure cb,
scoped_refptr<gpu::RefCountedLock> drdc_lock) = 0;
};
// Create a default implementation. |provider| is the underlying provider to
// create shared images.
static std::unique_ptr<PooledSharedImageVideoProvider> Create(
scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
GetStubCB get_stub_cb,
std::unique_ptr<SharedImageVideoProvider> provider,
scoped_refptr<gpu::RefCountedLock> drdc_lock);
PooledSharedImageVideoProvider(const PooledSharedImageVideoProvider&) =
delete;
PooledSharedImageVideoProvider& operator=(
const PooledSharedImageVideoProvider&) = delete;
~PooledSharedImageVideoProvider() override;
// SharedImageVideoProvider
void Initialize(GpuInitCB gpu_init_cb) override;
void RequestImage(ImageReadyCB cb, const ImageSpec& spec) override;
private:
friend class PooledSharedImageVideoProviderTest;
PooledSharedImageVideoProvider(
base::SequenceBound<GpuHelper> gpu_helper,
std::unique_ptr<SharedImageVideoProvider> provider,
scoped_refptr<gpu::RefCountedLock> drdc_lock);
class GpuHelperImpl : public GpuHelper {
public:
GpuHelperImpl(GetStubCB get_stub_cb);
~GpuHelperImpl() override;
// GpuHelper
void OnImageReturned(const gpu::SyncToken& sync_token,
scoped_refptr<CodecImageHolder> codec_image_holder,
base::OnceClosure cb,
scoped_refptr<gpu::RefCountedLock> drdc_lock) override;
private:
void OnSyncTokenCleared(scoped_refptr<CodecImageHolder> codec_image_holder,
base::OnceClosure cb,
scoped_refptr<gpu::RefCountedLock> drdc_lock);
scoped_refptr<CommandBufferHelper> command_buffer_helper_;
base::WeakPtrFactory<GpuHelperImpl> weak_factory_;
};
// Record of on image from |provider|.
class PooledImage : public base::RefCounted<PooledImage> {
public:
PooledImage(const ImageSpec& spec, ImageRecord record);
ImageSpec spec;
// The original record, including the original reuse callback.
ImageRecord record;
private:
virtual ~PooledImage();
friend class base::RefCounted<PooledImage>;
};
// One request from the client that's pending an image.
class PendingRequest {
public:
PendingRequest(const ImageSpec& spec, ImageReadyCB cb);
~PendingRequest();
ImageSpec spec;
ImageReadyCB cb;
};
// Called by |provider_| when a new image is created.
void OnImageCreated(ImageSpec spec, ImageRecord record);
// Called by our client when it runs the release cb, to notify us that the
// image is no longer in use.
void OnImageReturned(scoped_refptr<PooledImage> pooled_image,
const gpu::SyncToken& sync_token);
// Given a free image |pooled_image| that is not in our pool, use it to either
// fulfill a pending request, add it to the pool, or discard it.
void ProcessFreePooledImage(scoped_refptr<PooledImage> pooled_image);
// Underlying provider that we use to construct images.
std::unique_ptr<SharedImageVideoProvider> provider_;
// All currently unused images.
std::list<scoped_refptr<PooledImage>> pool_;
// Spec for all images in |pool_|.
ImageSpec pool_spec_;
std::list<PendingRequest> pending_requests_;
base::SequenceBound<GpuHelper> gpu_helper_;
base::WeakPtrFactory<PooledSharedImageVideoProvider> weak_factory_;
};
} // namespace media
#endif // MEDIA_GPU_ANDROID_POOLED_SHARED_IMAGE_VIDEO_PROVIDER_H_
|
