1 // Copyright 2014 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 "ppapi/proxy/compositor_layer_resource.h"
6
7 #include "base/logging.h"
8 #include "gpu/GLES2/gl2extchromium.h"
9 #include "gpu/command_buffer/client/gles2_implementation.h"
10 #include "gpu/command_buffer/common/mailbox.h"
11 #include "ppapi/proxy/compositor_resource.h"
12 #include "ppapi/shared_impl/ppb_graphics_3d_shared.h"
13 #include "ppapi/thunk/enter.h"
14 #include "ppapi/thunk/ppb_graphics_3d_api.h"
15 #include "ppapi/thunk/ppb_image_data_api.h"
16
17 using gpu::gles2::GLES2Implementation;
18 using ppapi::thunk::EnterResourceNoLock;
19 using ppapi::thunk::PPB_ImageData_API;
20 using ppapi::thunk::PPB_Graphics3D_API;
21
22 namespace ppapi {
23 namespace proxy {
24
25 namespace {
26
clamp(float value)27 float clamp(float value) {
28 return std::min(std::max(value, 0.0f), 1.0f);
29 }
30
OnTextureReleased(const ScopedPPResource & layer,const ScopedPPResource & context,uint32_t texture,const scoped_refptr<TrackedCallback> & release_callback,int32_t result,uint32_t sync_point,bool is_lost)31 void OnTextureReleased(
32 const ScopedPPResource& layer,
33 const ScopedPPResource& context,
34 uint32_t texture,
35 const scoped_refptr<TrackedCallback>& release_callback,
36 int32_t result,
37 uint32_t sync_point,
38 bool is_lost) {
39 if (!TrackedCallback::IsPending(release_callback))
40 return;
41
42 if (result != PP_OK) {
43 release_callback->Run(result);
44 return;
45 }
46
47 do {
48 if (!sync_point)
49 break;
50
51 EnterResourceNoLock<PPB_Graphics3D_API> enter(context.get(), true);
52 if (enter.failed())
53 break;
54
55 PPB_Graphics3D_Shared* graphics =
56 static_cast<PPB_Graphics3D_Shared*>(enter.object());
57
58 GLES2Implementation* gl = graphics->gles2_impl();
59 gl->WaitSyncPointCHROMIUM(sync_point);
60 } while (false);
61
62 release_callback->Run(is_lost ? PP_ERROR_FAILED : PP_OK);
63 }
64
OnImageReleased(const ScopedPPResource & layer,const ScopedPPResource & image,const scoped_refptr<TrackedCallback> & release_callback,int32_t result,uint32_t sync_point,bool is_lost)65 void OnImageReleased(
66 const ScopedPPResource& layer,
67 const ScopedPPResource& image,
68 const scoped_refptr<TrackedCallback>& release_callback,
69 int32_t result,
70 uint32_t sync_point,
71 bool is_lost) {
72 if (!TrackedCallback::IsPending(release_callback))
73 return;
74 release_callback->Run(result);
75 }
76
77 } // namespace
78
CompositorLayerResource(Connection connection,PP_Instance instance,const CompositorResource * compositor)79 CompositorLayerResource::CompositorLayerResource(
80 Connection connection,
81 PP_Instance instance,
82 const CompositorResource* compositor)
83 : PluginResource(connection, instance),
84 compositor_(compositor),
85 source_size_(PP_MakeFloatSize(0.0f, 0.0f)) {
86 }
87
~CompositorLayerResource()88 CompositorLayerResource::~CompositorLayerResource() {
89 DCHECK(!compositor_);
90 DCHECK(release_callback_.is_null());
91 }
92
93 thunk::PPB_CompositorLayer_API*
AsPPB_CompositorLayer_API()94 CompositorLayerResource::AsPPB_CompositorLayer_API() {
95 return this;
96 }
97
SetColor(float red,float green,float blue,float alpha,const PP_Size * size)98 int32_t CompositorLayerResource::SetColor(float red,
99 float green,
100 float blue,
101 float alpha,
102 const PP_Size* size) {
103 if (!compositor_)
104 return PP_ERROR_BADRESOURCE;
105
106 if (compositor_->IsInProgress())
107 return PP_ERROR_INPROGRESS;
108
109 if (!SetType(TYPE_COLOR))
110 return PP_ERROR_BADARGUMENT;
111 DCHECK(data_.color);
112
113 if (!size)
114 return PP_ERROR_BADARGUMENT;
115
116 data_.color->red = clamp(red);
117 data_.color->green = clamp(green);
118 data_.color->blue = clamp(blue);
119 data_.color->alpha = clamp(alpha);
120 data_.common.size = *size;
121
122 return PP_OK;
123 }
124
SetTexture0_1(PP_Resource context,uint32_t texture,const PP_Size * size,const scoped_refptr<TrackedCallback> & release_callback)125 int32_t CompositorLayerResource::SetTexture0_1(
126 PP_Resource context,
127 uint32_t texture,
128 const PP_Size* size,
129 const scoped_refptr<TrackedCallback>& release_callback) {
130 return SetTexture(context, GL_TEXTURE_2D, texture, size, release_callback);
131 }
132
SetTexture(PP_Resource context,uint32_t target,uint32_t texture,const PP_Size * size,const scoped_refptr<TrackedCallback> & release_callback)133 int32_t CompositorLayerResource::SetTexture(
134 PP_Resource context,
135 uint32_t target,
136 uint32_t texture,
137 const PP_Size* size,
138 const scoped_refptr<TrackedCallback>& release_callback) {
139 int32_t rv = CheckForSetTextureAndImage(TYPE_TEXTURE, release_callback);
140 if (rv != PP_OK)
141 return rv;
142 DCHECK(data_.texture);
143
144 EnterResourceNoLock<PPB_Graphics3D_API> enter(context, true);
145 if (enter.failed())
146 return PP_ERROR_BADRESOURCE;
147
148 if (target != GL_TEXTURE_2D &&
149 target != GL_TEXTURE_EXTERNAL_OES &&
150 target != GL_TEXTURE_RECTANGLE_ARB) {
151 return PP_ERROR_BADARGUMENT;
152 }
153
154 if (!size || size->width <= 0 || size->height <= 0)
155 return PP_ERROR_BADARGUMENT;
156
157 PPB_Graphics3D_Shared* graphics =
158 static_cast<PPB_Graphics3D_Shared*>(enter.object());
159
160 GLES2Implementation* gl = graphics->gles2_impl();
161
162 // Generate a Mailbox for the texture.
163 gl->GenMailboxCHROMIUM(
164 reinterpret_cast<GLbyte*>(data_.texture->mailbox.name));
165 gl->ProduceTextureDirectCHROMIUM(
166 texture, target,
167 reinterpret_cast<const GLbyte*>(data_.texture->mailbox.name));
168
169 // Set the source size to (1, 1). It will be used to verify the source_rect
170 // passed to SetSourceRect().
171 source_size_ = PP_MakeFloatSize(1.0f, 1.0f);
172
173 data_.common.size = *size;
174 data_.common.resource_id = compositor_->GenerateResourceId();
175 data_.texture->target = target;
176 data_.texture->sync_point = gl->InsertSyncPointCHROMIUM();
177 data_.texture->source_rect.point = PP_MakeFloatPoint(0.0f, 0.0f);
178 data_.texture->source_rect.size = source_size_;
179
180 // If the PP_Resource of this layer is released by the plugin, the
181 // release_callback will be aborted immediately, but the texture or image
182 // in this layer may still being used by chromium compositor. So we have to
183 // use ScopedPPResource to keep this resource alive until the texture or image
184 // is released by the chromium compositor.
185 release_callback_ = base::Bind(
186 &OnTextureReleased,
187 ScopedPPResource(pp_resource()), // Keep layer alive.
188 ScopedPPResource(context), // Keep context alive
189 texture,
190 release_callback);
191
192 return PP_OK_COMPLETIONPENDING;
193 }
194
SetImage(PP_Resource image_data,const PP_Size * size,const scoped_refptr<TrackedCallback> & release_callback)195 int32_t CompositorLayerResource::SetImage(
196 PP_Resource image_data,
197 const PP_Size* size,
198 const scoped_refptr<TrackedCallback>& release_callback) {
199 int32_t rv = CheckForSetTextureAndImage(TYPE_IMAGE, release_callback);
200 if (rv != PP_OK)
201 return rv;
202 DCHECK(data_.image);
203
204 EnterResourceNoLock<PPB_ImageData_API> enter(image_data, true);
205 if (enter.failed())
206 return PP_ERROR_BADRESOURCE;
207
208 PP_ImageDataDesc desc;
209 if (!enter.object()->Describe(&desc))
210 return PP_ERROR_BADARGUMENT;
211
212 // TODO(penghuang): Support image which width * 4 != stride.
213 if (desc.size.width * 4 != desc.stride)
214 return PP_ERROR_BADARGUMENT;
215
216 // TODO(penghuang): Support all formats.
217 if (desc.format != PP_IMAGEDATAFORMAT_RGBA_PREMUL)
218 return PP_ERROR_BADARGUMENT;
219
220 if (!size || size->width <= 0 || size->height <= 0)
221 return PP_ERROR_BADARGUMENT;
222
223 // Set the source size to image's size. It will be used to verify
224 // the source_rect passed to SetSourceRect().
225 source_size_ = PP_MakeFloatSize(desc.size.width, desc.size.height);
226
227 data_.common.size = size ? *size : desc.size;
228 data_.common.resource_id = compositor_->GenerateResourceId();
229 data_.image->resource = enter.resource()->host_resource().host_resource();
230 data_.image->source_rect.point = PP_MakeFloatPoint(0.0f, 0.0f);
231 data_.image->source_rect.size = source_size_;
232
233 // If the PP_Resource of this layer is released by the plugin, the
234 // release_callback will be aborted immediately, but the texture or image
235 // in this layer may still being used by chromium compositor. So we have to
236 // use ScopedPPResource to keep this resource alive until the texture or image
237 // is released by the chromium compositor.
238 release_callback_ = base::Bind(
239 &OnImageReleased,
240 ScopedPPResource(pp_resource()), // Keep layer alive.
241 ScopedPPResource(image_data), // Keep image_data alive.
242 release_callback);
243
244 return PP_OK_COMPLETIONPENDING;
245 }
246
SetClipRect(const PP_Rect * rect)247 int32_t CompositorLayerResource::SetClipRect(const PP_Rect* rect) {
248 if (!compositor_)
249 return PP_ERROR_BADRESOURCE;
250
251 if (compositor_->IsInProgress())
252 return PP_ERROR_INPROGRESS;
253
254 data_.common.clip_rect = rect ? *rect : PP_MakeRectFromXYWH(0, 0, 0, 0);
255 return PP_OK;
256 }
257
SetTransform(const float matrix[16])258 int32_t CompositorLayerResource::SetTransform(const float matrix[16]) {
259 if (!compositor_)
260 return PP_ERROR_BADRESOURCE;
261
262 if (compositor_->IsInProgress())
263 return PP_ERROR_INPROGRESS;
264
265 std::copy(matrix, matrix + 16, data_.common.transform.matrix);
266 return PP_OK;
267 }
268
SetOpacity(float opacity)269 int32_t CompositorLayerResource::SetOpacity(float opacity) {
270 if (!compositor_)
271 return PP_ERROR_BADRESOURCE;
272
273 if (compositor_->IsInProgress())
274 return PP_ERROR_INPROGRESS;
275
276 data_.common.opacity = clamp(opacity);
277 return PP_OK;
278 }
279
SetBlendMode(PP_BlendMode mode)280 int32_t CompositorLayerResource::SetBlendMode(PP_BlendMode mode) {
281 if (!compositor_)
282 return PP_ERROR_BADRESOURCE;
283
284 if (compositor_->IsInProgress())
285 return PP_ERROR_INPROGRESS;
286
287 switch (mode) {
288 case PP_BLENDMODE_NONE:
289 case PP_BLENDMODE_SRC_OVER:
290 data_.common.blend_mode = mode;
291 return PP_OK;
292 }
293 return PP_ERROR_BADARGUMENT;
294 }
295
SetSourceRect(const PP_FloatRect * rect)296 int32_t CompositorLayerResource::SetSourceRect(
297 const PP_FloatRect* rect) {
298 if (!compositor_)
299 return PP_ERROR_BADRESOURCE;
300
301 if (compositor_->IsInProgress())
302 return PP_ERROR_INPROGRESS;
303
304 if (!rect ||
305 rect->point.x < 0.0f ||
306 rect->point.y < 0.0f ||
307 rect->point.x + rect->size.width > source_size_.width ||
308 rect->point.y + rect->size.height > source_size_.height) {
309 return PP_ERROR_BADARGUMENT;
310 }
311
312 if (data_.texture) {
313 data_.texture->source_rect = *rect;
314 return PP_OK;
315 }
316 if (data_.image) {
317 data_.image->source_rect = *rect;
318 return PP_OK;
319 }
320 return PP_ERROR_BADARGUMENT;
321 }
322
SetPremultipliedAlpha(PP_Bool premult)323 int32_t CompositorLayerResource::SetPremultipliedAlpha(PP_Bool premult) {
324 if (!compositor_)
325 return PP_ERROR_BADRESOURCE;
326
327 if (compositor_->IsInProgress())
328 return PP_ERROR_INPROGRESS;
329
330 if (data_.texture) {
331 data_.texture->premult_alpha = PP_ToBool(premult);
332 return PP_OK;
333 }
334 return PP_ERROR_BADARGUMENT;
335 }
336
SetType(LayerType type)337 bool CompositorLayerResource::SetType(LayerType type) {
338 if (type == TYPE_COLOR) {
339 if (data_.is_null())
340 data_.color.reset(new CompositorLayerData::ColorLayer());
341 return data_.color;
342 }
343
344 if (type == TYPE_TEXTURE) {
345 if (data_.is_null())
346 data_.texture.reset(new CompositorLayerData::TextureLayer());
347 return data_.texture;
348 }
349
350 if (type == TYPE_IMAGE) {
351 if (data_.is_null())
352 data_.image.reset(new CompositorLayerData::ImageLayer());
353 return data_.image;
354 }
355
356 // Should not be reached.
357 DCHECK(false);
358 return false;
359 }
360
CheckForSetTextureAndImage(LayerType type,const scoped_refptr<TrackedCallback> & release_callback)361 int32_t CompositorLayerResource::CheckForSetTextureAndImage(
362 LayerType type,
363 const scoped_refptr<TrackedCallback>& release_callback) {
364 if (!compositor_)
365 return PP_ERROR_BADRESOURCE;
366
367 if (compositor_->IsInProgress())
368 return PP_ERROR_INPROGRESS;
369
370 if (!SetType(type))
371 return PP_ERROR_BADARGUMENT;
372
373 // The layer's image has been set and it is not committed.
374 if (!release_callback_.is_null())
375 return PP_ERROR_INPROGRESS;
376
377 // Do not allow using a block callback as a release callback.
378 if (release_callback->is_blocking())
379 return PP_ERROR_BADARGUMENT;
380
381 return PP_OK;
382 }
383
384 } // namespace proxy
385 } // namespace ppapi
386