Home | History | Annotate | Download | only in c
      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 
      6 /* From ppb_compositor_layer.idl modified Thu Aug 14 18:06:33 2014. */
      7 
      8 #ifndef PPAPI_C_PPB_COMPOSITOR_LAYER_H_
      9 #define PPAPI_C_PPB_COMPOSITOR_LAYER_H_
     10 
     11 #include "ppapi/c/pp_bool.h"
     12 #include "ppapi/c/pp_completion_callback.h"
     13 #include "ppapi/c/pp_macros.h"
     14 #include "ppapi/c/pp_point.h"
     15 #include "ppapi/c/pp_rect.h"
     16 #include "ppapi/c/pp_resource.h"
     17 #include "ppapi/c/pp_size.h"
     18 #include "ppapi/c/pp_stdint.h"
     19 
     20 #define PPB_COMPOSITORLAYER_INTERFACE_0_1 "PPB_CompositorLayer;0.1" /* dev */
     21 #define PPB_COMPOSITORLAYER_INTERFACE_0_2 "PPB_CompositorLayer;0.2" /* dev */
     22 /**
     23  * @file
     24  */
     25 
     26 
     27 /**
     28  * @addtogroup Enums
     29  * @{
     30  */
     31 /**
     32  * This enumeration contains blend modes used for computing the result pixels
     33  * based on the source RGBA values in layers with the RGBA values that are
     34  * already in the destination framebuffer.
     35  * alpha_src, color_src: source alpha and color.
     36  * alpha_dst, color_dst: destination alpha and color (before compositing).
     37  * Below descriptions of the blend modes assume the colors are pre-multiplied.
     38  * This interface is still in development (Dev API status) and may change,
     39  * so is only supported on Dev channel and Canary currently.
     40  */
     41 typedef enum {
     42   /**
     43    * No blending, copy source to the destination directly.
     44    */
     45   PP_BLENDMODE_NONE,
     46   /**
     47    * Source is placed over the destination.
     48    * Resulting alpha = alpha_src + alpha_dst - alpha_src * alpha_dst
     49    * Resulting color = color_src + color_dst * (1 - alpha_src)
     50    */
     51   PP_BLENDMODE_SRC_OVER,
     52   /**
     53    * The last blend mode.
     54    */
     55   PP_BLENDMODE_LAST = PP_BLENDMODE_SRC_OVER
     56 } PP_BlendMode;
     57 /**
     58  * @}
     59  */
     60 
     61 /**
     62  * @addtogroup Interfaces
     63  * @{
     64  */
     65 /**
     66  * Defines the <code>PPB_CompositorLayer</code> interface. It is used by
     67  * <code>PPB_Compositor</code>.
     68  */
     69 struct PPB_CompositorLayer_0_2 { /* dev */
     70   /**
     71    * Determines if a resource is a compositor layer resource.
     72    *
     73    * @param[in] resource The <code>PP_Resource</code> to test.
     74    *
     75    * @return A <code>PP_Bool</code> with <code>PP_TRUE</code> if the given
     76    * resource is a compositor layer resource or <code>PP_FALSE</code>
     77    * otherwise.
     78    */
     79   PP_Bool (*IsCompositorLayer)(PP_Resource resource);
     80   /**
     81    * Sets the color of a solid color layer. If the layer is uninitialized,
     82    * it will initialize the layer first, and then set its color.
     83    * If the layer has been initialized to another kind of layer, the layer will
     84    * not be changed, and <code>PP_ERROR_BADARGUMENT</code> will be returned.
     85    *
     86    * param[in] layer A <code>PP_Resource</code> corresponding to a compositor
     87    * layer resource.
     88    * param[in] red A <code>float</code> for the red color component. It will be
     89    * clamped to [0, 1].
     90    * param[in] green A <code>float</code> for the green color component. It will
     91    * be clamped to [0, 1].
     92    * param[in] blue A <code>float</code> for the blue color component. It will
     93    * be clamped to [0, 1].
     94    * param[in] alpha A <code>float</code> for the alpha color component. It will
     95    * be clamped to [0, 1].
     96    * param[in] size A <code>PP_Size</code> for the size of the layer before
     97    * transform.
     98    *
     99    * @return An int32_t containing a result code from <code>pp_errors.h</code>.
    100    */
    101   int32_t (*SetColor)(PP_Resource layer,
    102                       float red,
    103                       float green,
    104                       float blue,
    105                       float alpha,
    106                       const struct PP_Size* size);
    107   /**
    108    * Sets the texture of a texture layer. If the layer is uninitialized,
    109    * it will initialize the layer first, and then set its texture.
    110    * The source rect will be set to ((0, 0), (1, 1)). If the layer has been
    111    * initialized to another kind of layer, the layer will not be changed,
    112    * and <code>PP_ERROR_BADARGUMENT</code> will be returned.
    113    *
    114    * param[in] layer A <code>PP_Resource</code> corresponding to a compositor
    115    * layer resource.
    116    * param[in] context A <code>PP_Resource</code> corresponding to a graphics
    117    * 3d resource which owns the GL texture.
    118    * param[in] target GL texture target (GL_TEXTURE_2D, etc).
    119    * param[in] texture A GL texture object id.
    120    * param[in] size A <code>PP_Size</code> for the size of the layer before
    121    * transform.
    122    * param[in] cc A <code>PP_CompletionCallback</code> to be called when
    123    * the texture is released by Chromium compositor.
    124    *
    125    * @return An int32_t containing a result code from <code>pp_errors.h</code>.
    126    */
    127   int32_t (*SetTexture)(PP_Resource layer,
    128                         PP_Resource context,
    129                         uint32_t target,
    130                         uint32_t texture,
    131                         const struct PP_Size* size,
    132                         struct PP_CompletionCallback cc);
    133   /**
    134    * Sets the image of an image layer. If the layer is uninitialized,
    135    * it will initialize the layer first, and then set its image.
    136    * The layer size will be set to the image's size. The source rect will be set
    137    * to the full image. If the layer has been initialized to another kind of
    138    * layer, the layer will not be changed, and <code>PP_ERROR_BADARGUMENT</code>
    139    * will be returned.
    140    *
    141    * param[in] layer A <code>PP_Resource</code> corresponding to a compositor
    142    * layer resource.
    143    * param[in] image_data A <code>PP_Resource</code> corresponding to
    144    * an image data resource.
    145    * param[in] size A <code>PP_Size</code> for the size of the layer before
    146    * transform. If NULL, the image's size will be used.
    147    * param[in] cc A <code>PP_CompletionCallback</code> to be called when
    148    * the image data is released by Chromium compositor.
    149    *
    150    * @return An int32_t containing a result code from <code>pp_errors.h</code>.
    151    */
    152   int32_t (*SetImage)(PP_Resource layer,
    153                       PP_Resource image_data,
    154                       const struct PP_Size* size,
    155                       struct PP_CompletionCallback cc);
    156   /**
    157    * Sets a clip rectangle for a compositor layer. The Chromium compositor
    158    * applies a transform matrix on the layer first, and then clips the layer
    159    * with the rectangle.
    160    *
    161    * param[in] layer A <code>PP_Resource</code> corresponding to a compositor
    162    * layer resource.
    163    * param[in] rect The clip rectangle. The origin is top-left corner of
    164    * the plugin.
    165    *
    166    * @return An int32_t containing a result code from <code>pp_errors.h</code>.
    167    */
    168   int32_t (*SetClipRect)(PP_Resource layer, const struct PP_Rect* rect);
    169   /**
    170    * Sets a transform matrix which is used to composite the layer.
    171    *
    172    * param[in] layer A <code>PP_Resource</code> corresponding to a compositor
    173    * layer resource.
    174    * param[in] matrix A float array with 16 elements. The matrix is
    175    * column major. The default transform matrix is an identity matrix.
    176    *
    177    * @return An int32_t containing a result code from <code>pp_errors.h</code>.
    178    */
    179   int32_t (*SetTransform)(PP_Resource layer, const float matrix[16]);
    180   /**
    181    * Sets the opacity value which will be applied to the layer. The effective
    182    * value of each pixel is computed as:
    183    *
    184    *   if (premult_alpha)
    185    *     pixel.rgb = pixel.rgb * opacity;
    186    *   pixel.a = pixel.a * opactiy;
    187    *
    188    * param[in] layer A <code>PP_Resource</code> corresponding to a compositor
    189    * layer resource.
    190    * param[in] opacity A <code>float</code> for the opacity value, The default
    191    * value is 1.0f.
    192    *
    193    * @return An int32_t containing a result code from <code>pp_errors.h</code>.
    194    */
    195   int32_t (*SetOpacity)(PP_Resource layer, float opacity);
    196   /**
    197    * Sets the blend mode which is used to composite the layer.
    198    *
    199    * param[in] layer A <code>PP_Resource</code> corresponding to a compositor
    200    * layer resource.
    201    * param[in] mode A <code>PP_BlendMode</code>. The default mode is
    202    * <code>PP_BLENDMODE_SRC_OVER</code>.
    203    *
    204    * @return An int32_t containing a result code from <code>pp_errors.h</code>.
    205    */
    206   int32_t (*SetBlendMode)(PP_Resource layer, PP_BlendMode mode);
    207   /**
    208    * Sets a source rectangle for a texture layer or an image layer.
    209    *
    210    * param[in] layer A <code>PP_Resource</code> corresponding to a compositor
    211    * layer resource.
    212    * param[in] rect A <code>PP_FloatRect</code> for an area of the source to
    213    * consider. For a texture layer, rect is in uv coordinates. For an image
    214    * layer, rect is in pixels. If the rect is beyond the dimensions of the
    215    * texture or image, <code>PP_ERROR_BADARGUMENT</code> will be returned.
    216    * If the layer size does not match the source rect size, bilinear scaling
    217    * will be used.
    218    *
    219    * @return An int32_t containing a result code from <code>pp_errors.h</code>.
    220    */
    221   int32_t (*SetSourceRect)(PP_Resource layer, const struct PP_FloatRect* rect);
    222   /**
    223    * Sets the premultiplied alpha for an texture layer.
    224    *
    225    * param[in] layer A <code>PP_Resource</code> corresponding to a compositor
    226    * layer resource.
    227    * param[in] premult A <code>PP_Bool</code> with <code>PP_TRUE</code> if
    228    * pre-multiplied alpha is used.
    229    *
    230    * @return An int32_t containing a result code from <code>pp_errors.h</code>.
    231    */
    232   int32_t (*SetPremultipliedAlpha)(PP_Resource layer, PP_Bool premult);
    233 };
    234 
    235 struct PPB_CompositorLayer_0_1 { /* dev */
    236   PP_Bool (*IsCompositorLayer)(PP_Resource resource);
    237   int32_t (*SetColor)(PP_Resource layer,
    238                       float red,
    239                       float green,
    240                       float blue,
    241                       float alpha,
    242                       const struct PP_Size* size);
    243   int32_t (*SetTexture)(PP_Resource layer,
    244                         PP_Resource context,
    245                         uint32_t texture,
    246                         const struct PP_Size* size,
    247                         struct PP_CompletionCallback cc);
    248   int32_t (*SetImage)(PP_Resource layer,
    249                       PP_Resource image_data,
    250                       const struct PP_Size* size,
    251                       struct PP_CompletionCallback cc);
    252   int32_t (*SetClipRect)(PP_Resource layer, const struct PP_Rect* rect);
    253   int32_t (*SetTransform)(PP_Resource layer, const float matrix[16]);
    254   int32_t (*SetOpacity)(PP_Resource layer, float opacity);
    255   int32_t (*SetBlendMode)(PP_Resource layer, PP_BlendMode mode);
    256   int32_t (*SetSourceRect)(PP_Resource layer, const struct PP_FloatRect* rect);
    257   int32_t (*SetPremultipliedAlpha)(PP_Resource layer, PP_Bool premult);
    258 };
    259 /**
    260  * @}
    261  */
    262 
    263 #endif  /* PPAPI_C_PPB_COMPOSITOR_LAYER_H_ */
    264 
    265