DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (e5ef045527c6)

VCS Links

Line Code
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
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef TEX_UNPACK_BLOB_H_
#define TEX_UNPACK_BLOB_H_

#include "GLContextTypes.h"
#include "mozilla/RefPtr.h"
#include "WebGLStrongTypes.h"
#include "WebGLTypes.h"

namespace mozilla {

class UniqueBuffer;
class WebGLContext;
class WebGLTexture;

namespace dom {
class Element;
class HTMLCanvasElement;
class HTMLVideoElement;
}  // namespace dom

namespace gfx {
class DataSourceSurface;
}  // namespace gfx

namespace layers {
class Image;
class ImageContainer;
}  // namespace layers

namespace webgl {

struct PackingInfo;
struct DriverUnpackInfo;

class TexUnpackBlob {
 public:
  const uint32_t mAlignment;
  const uint32_t mRowLength;
  const uint32_t mImageHeight;
  const uint32_t mSkipPixels;
  const uint32_t mSkipRows;
  const uint32_t mSkipImages;
  const uint32_t mWidth;
  const uint32_t mHeight;
  const uint32_t mDepth;

  const gfxAlphaType mSrcAlphaType;

  bool mNeedsExactUpload;

 protected:
  TexUnpackBlob(const WebGLContext* webgl, TexImageTarget target,
                uint32_t rowLength, uint32_t width, uint32_t height,
                uint32_t depth, gfxAlphaType srcAlphaType);

 public:
  virtual ~TexUnpackBlob() {}

 protected:
  bool ConvertIfNeeded(WebGLContext* webgl, const uint32_t rowLength,
                       const uint32_t rowCount, WebGLTexelFormat srcFormat,
                       const uint8_t* const srcBegin, const ptrdiff_t srcStride,
                       WebGLTexelFormat dstFormat, const ptrdiff_t dstStride,

                       const uint8_t** const out_begin,
                       UniqueBuffer* const out_anchoredBuffer) const;

 public:
  virtual bool HasData() const { return true; }

  virtual bool Validate(WebGLContext* webgl, const webgl::PackingInfo& pi) = 0;

  // Returns false when we've generated a WebGL error.
  // Returns true but with a non-zero *out_error if we still need to generate a
  // WebGL error.
  virtual bool TexOrSubImage(bool isSubImage, bool needsRespec,
                             WebGLTexture* tex, TexImageTarget target,
                             GLint level, const webgl::DriverUnpackInfo* dui,
                             GLint xOffset, GLint yOffset, GLint zOffset,
                             const webgl::PackingInfo& pi,
                             GLenum* const out_error) const = 0;
};

class TexUnpackBytes final : public TexUnpackBlob {
 public:
  const bool mIsClientData;
  const uint8_t* const mPtr;
  const size_t mAvailBytes;

  TexUnpackBytes(const WebGLContext* webgl, TexImageTarget target,
                 uint32_t width, uint32_t height, uint32_t depth,
                 bool isClientData, const uint8_t* ptr, size_t availBytes);

  virtual bool HasData() const override { return !mIsClientData || bool(mPtr); }

  virtual bool Validate(WebGLContext* webgl,
                        const webgl::PackingInfo& pi) override;
  virtual bool TexOrSubImage(bool isSubImage, bool needsRespec,
                             WebGLTexture* tex, TexImageTarget target,
                             GLint level, const webgl::DriverUnpackInfo* dui,
                             GLint xOffset, GLint yOffset, GLint zOffset,
                             const webgl::PackingInfo& pi,
                             GLenum* const out_error) const override;
};

class TexUnpackImage final : public TexUnpackBlob {
 public:
  const RefPtr<layers::Image> mImage;

  TexUnpackImage(const WebGLContext* webgl, TexImageTarget target,
                 uint32_t width, uint32_t height, uint32_t depth,
                 layers::Image* image, gfxAlphaType srcAlphaType);

  ~TexUnpackImage();  // Prevent needing to define layers::Image in the header.

  virtual bool Validate(WebGLContext* webgl,
                        const webgl::PackingInfo& pi) override;
  virtual bool TexOrSubImage(bool isSubImage, bool needsRespec,
                             WebGLTexture* tex, TexImageTarget target,
                             GLint level, const webgl::DriverUnpackInfo* dui,
                             GLint xOffset, GLint yOffset, GLint zOffset,
                             const webgl::PackingInfo& dstPI,
                             GLenum* const out_error) const override;
};

class TexUnpackSurface final : public TexUnpackBlob {
 public:
  const RefPtr<gfx::DataSourceSurface> mSurf;

  TexUnpackSurface(const WebGLContext* webgl, TexImageTarget target,
                   uint32_t width, uint32_t height, uint32_t depth,
                   gfx::DataSourceSurface* surf, gfxAlphaType srcAlphaType);

  virtual bool Validate(WebGLContext* webgl,
                        const webgl::PackingInfo& pi) override;
  virtual bool TexOrSubImage(bool isSubImage, bool needsRespec,
                             WebGLTexture* tex, TexImageTarget target,
                             GLint level, const webgl::DriverUnpackInfo* dui,
                             GLint xOffset, GLint yOffset, GLint zOffset,
                             const webgl::PackingInfo& dstPI,
                             GLenum* const out_error) const override;
};

}  // namespace webgl
}  // namespace mozilla

#endif  // TEX_UNPACK_BLOB_H_