dom/canvas/TexUnpackBlob.h

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef TEX_UNPACK_BLOB_H_
   7 #define TEX_UNPACK_BLOB_H_
   8
   9 #include "GLContextTypes.h"
  10 #include "mozilla/RefPtr.h"
  11 #include "WebGLStrongTypes.h"
  12 #include "WebGLTypes.h"
  13
  14 #include <memory>
  15
  16 namespace mozilla {
  17
  18 class UniqueBuffer;
  19 class WebGLContext;
  20 class WebGLTexture;
  21
  22 namespace dom {
  23 class Element;
  24 class HTMLCanvasElement;
  25 class HTMLVideoElement;
  26 }  // namespace dom
  27
  28 namespace gfx {
  29 class DataSourceSurface;
  30 }  // namespace gfx
  31
  32 namespace layers {
  33 class Image;
  34 class ImageContainer;
  35 }  // namespace layers
  36
  37 bool IsTarget3D(TexImageTarget target);
  38
  39 namespace webgl {
  40
  41 struct PackingInfo;
  42 struct DriverUnpackInfo;
  43
  44 Maybe<std::string> BlitPreventReason(int32_t level, const ivec3& offset,
  45                                      const webgl::PackingInfo&,
  46                                      const TexUnpackBlobDesc&);
  47
  48 class TexUnpackBlob {
  49  public:
  50   const TexUnpackBlobDesc& mDesc;
  51   bool mNeedsExactUpload = true;
  52
  53   static std::unique_ptr<TexUnpackBlob> Create(const TexUnpackBlobDesc&);
  54
  55  protected:
  56   explicit TexUnpackBlob(const TexUnpackBlobDesc& desc) : mDesc(desc) {
  57     MOZ_ASSERT_IF(!IsTarget3D(mDesc.imageTarget), mDesc.size.z == 1);
  58   }
  59
  60  public:
  61   virtual ~TexUnpackBlob() = default;
  62
  63  protected:
  64   bool ConvertIfNeeded(const WebGLContext*, const uint32_t rowLength,
  65                        const uint32_t rowCount, WebGLTexelFormat srcFormat,
  66                        const uint8_t* const srcBegin, const ptrdiff_t srcStride,
  67                        WebGLTexelFormat dstFormat, const ptrdiff_t dstStride,
  68
  69                        const uint8_t** const out_begin,
  70                        UniqueBuffer* const out_anchoredBuffer) const;
  71
  72  public:
  73   virtual bool HasData() const { return true; }
  74
  75   virtual bool Validate(const WebGLContext*, const webgl::PackingInfo& pi) = 0;
  76
  77   // Returns false when we've generated a WebGL error.
  78   // Returns true but with a non-zero *out_error if we still need to generate a
  79   // WebGL error.
  80   virtual bool TexOrSubImage(bool isSubImage, bool needsRespec,
  81                              WebGLTexture* tex, GLint level,
  82                              const webgl::DriverUnpackInfo* dui, GLint xOffset,
  83                              GLint yOffset, GLint zOffset,
  84                              const webgl::PackingInfo& pi,
  85                              GLenum* const out_error) const = 0;
  86 };
  87
  88 class TexUnpackBytes final : public TexUnpackBlob {
  89  public:
  90   explicit TexUnpackBytes(const TexUnpackBlobDesc& desc) : TexUnpackBlob(desc) {
  91     MOZ_ASSERT(mDesc.srcAlphaType == gfxAlphaType::NonPremult);
  92   }
  93
  94   virtual bool HasData() const override {
  95     return mDesc.pboOffset || mDesc.cpuData;
  96   }
  97
  98   virtual bool Validate(const WebGLContext*,
  99                         const webgl::PackingInfo& pi) override;
 100   virtual bool TexOrSubImage(bool isSubImage, bool needsRespec,
 101                              WebGLTexture* tex, GLint level,
 102                              const webgl::DriverUnpackInfo* dui, GLint xOffset,
 103                              GLint yOffset, GLint zOffset,
 104                              const webgl::PackingInfo& pi,
 105                              GLenum* const out_error) const override;
 106 };
 107
 108 class TexUnpackImage final : public TexUnpackBlob {
 109  public:
 110   explicit TexUnpackImage(const TexUnpackBlobDesc& desc)
 111       : TexUnpackBlob(desc) {}
 112   ~TexUnpackImage();  // Prevent needing to define layers::Image in the header.
 113
 114   virtual bool Validate(const WebGLContext*,
 115                         const webgl::PackingInfo& pi) override;
 116   virtual bool TexOrSubImage(bool isSubImage, bool needsRespec,
 117                              WebGLTexture* tex, GLint level,
 118                              const webgl::DriverUnpackInfo* dui, GLint xOffset,
 119                              GLint yOffset, GLint zOffset,
 120                              const webgl::PackingInfo& dstPI,
 121                              GLenum* const out_error) const override;
 122 };
 123
 124 class TexUnpackSurface final : public TexUnpackBlob {
 125  public:
 126   explicit TexUnpackSurface(const TexUnpackBlobDesc& desc)
 127       : TexUnpackBlob(desc) {}
 128   ~TexUnpackSurface();
 129
 130   virtual bool Validate(const WebGLContext*,
 131                         const webgl::PackingInfo& pi) override;
 132   virtual bool TexOrSubImage(bool isSubImage, bool needsRespec,
 133                              WebGLTexture* tex, GLint level,
 134                              const webgl::DriverUnpackInfo* dui, GLint xOffset,
 135                              GLint yOffset, GLint zOffset,
 136                              const webgl::PackingInfo& dstPI,
 137                              GLenum* const out_error) const override;
 138 };
 139
 140 }  // namespace webgl
 141 }  // namespace mozilla
 142
 143 #endif  // TEX_UNPACK_BLOB_H_