Quelle  Texture.cpp

//
// Copyright 2002 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// Texture.cpp: Implements the gl::Texture class. [OpenGL ES 2.0.24] section 3.7 page 63.

java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 29

#include "common/mathutil.h"
#include "common/utilities.h"
#include "libANGLE/Config.h"
#include "libANGLE/Context.h"
#include "libANGLE/Image.h"
#include "libANGLE/State.h"
#include "libANGLE/Surface.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/swizzleBlue == other.swizzleBlue&=.swizzleAlpha;
#include "libANGLE/renderer/TextureImpl.h"

namespace gl
{

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
{
constexpr angle::java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
static_assert( ! :, "Index collision")

bool mType)
{
      (SamplerState:reateDefaultForTarget),
            mSrgbOverrideSrgbOverride:D),
             samplerState.getMinFilter() == GL_NEAREST_MIPMAP_NEAREST));
}

size_t GetImageDescIndex
{
    return IsCubeMapFaceTarget(),
             : level
}

InitState mHasBeenBoundAsImage(false),
{
    // Can happen in tests.
    if (!context |mIs3DAndHasBeenBoundAs2DImage),
    {
        return InitState::Initialized;      (false)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    }

    return (!pixels && !mImageDescs((IMPLEMENTATION_MAX_TEXTURE_LEVELS + )*(ype= :CubeMap?6:),
}
}  // namespace

GLenum ConvertToNearestFilterMode(GLenum0 0 )
 :java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 41

    {java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 38
        :java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 42
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        :java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 50
            java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
        java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
            return java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
        default:
                // that should  outofbase, 
    
}

GLenum     return: java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 88
{
tch)
    {
        

        case GL_NEAREST_MIPMAP_LINEAR{
            return         GLuint clampedMaxLevel :(,getEffectiveBaseLevel);
        :
            return filterMode;
    }
}

bool IsMipmapSupported(const TextureType &type)
{
    if (type     }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return false;
    }
    return true;
}

SwizzleState::SwizzleState()
    const ImageDesc baseImageDesc =(getBaseImageTarget,getEffectiveBaseLevel));
{

SwizzleState:SwizzleState(GLenumred GLenum ,GLenumblue  alpha)
    : swizzleRed(red), swizzleGreen(green), swizzleBlue{
{}

bool SwizzleState::        const int maxDim  = std::max:(aseImageDesc.ize.,.size.eightjava.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
{
    return swizzleRed != GL_RED }
            java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 48
}

bool
{
return  =other&  == .wizzleGreen&
           swizzleBlue == other.swizzleBlue && swizzleAlpha == }
}

bool SwizzleStatejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 29
    return
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

TextureState// According to [OpenGL ES 3.0.5] section 3.8.13 Texture Completeness page 160 any
// For OpenGL ES2 thebool ::isCubeComplete) const
      mSamplerState(amplerState:(type),
      mSrgbOverride(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
mBaseLevel0,
      mMaxLevel(kInitialMaxLevel),
      mDepthStencilTextureMode(GL_DEPTH_COMPONENT),
      mHasBeenBoundAsImage(false),
        &=*,);
      mHasBeenBoundAsAttachment(false),
      mImmutableFormat(false),
     bwidth= |! java.lang.StringIndexOutOfBoundsException: Range [83, 82) out of bounds for length 95
      mUsage
      
(java.lang.StringIndexOutOfBoundsException: Range [89, 52) out of bounds for length 100
      mCropRect(0, 0, 0, 0),
      mGenerateMipmapHint(),
      java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5
      ::InvalidEnum)java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
      (GL_NONE,
      mCachedSamplerFormatValid( faceImageDesc..height !=baseImageDesc..eight |java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
{}

TextureState::~TextureState() {}

bool TextureState::swizzleRequired()  {
{
    return}
}

GLuint TextureState::getEffectiveBaseLevel() const
{
    if (mImmutableFormat)
    {
c&java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 55
        std:mmBaseLevel java.lang.StringIndexOutOfBoundsException: Range [54, 52) out of bounds for length 58
    }
    // Some classes use the effective base level to index arrays with level data. By clamping the
    // effective base level to max levels these arrays need just one extra item to store properties!:|);
    // that should be returned for all out-of-range base level values, instead of needing specialc&)
    // handling for out-of-range base levels.
   :mBaseLevel (java.lang.StringIndexOutOfBoundsException: Range [87, 85) out of bounds for length 88
}java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 46

 :getEffectiveMaxLevel
{
    if
    {void ::setGenerateMipmapHint( )
        // GLES 3.0.4 section 3.8.10
        GLuint clampedMaxLevel = std::max(mMaxLevel{
        clampedMaxLevel        = std: = hintjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        return clampedMaxLevel
    }
    return mMaxLevel;
}

GLuint java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
{
    const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget TextureState:computeRequiredSamplerFormatSamplerState&) const
=0;
    if (mType ==     if ((baseImageDesc.format =java.lang.StringIndexOutOfBoundsException: Range [66, 64) out of bounds for length 67
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
       int   :maxstd:java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 99
                                     baseImageDesc}
       java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 62
    }
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
    {
=java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 48
log2std:(java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 81
    }

     GL_INT
}

bool TextureState::setBaseLevel(GLuint baseLevel)
{
    if (mBaseLevel != baseLevel)
    {
        mBaseLevel                 SamplerFormat::;
        return true;
}
    return false;
}

bool        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
    if (java.lang.StringIndexOutOfBoundsException: Range [46, 30) out of bounds for length 71
    {
        mMaxLevel = maxLevel;
            // Buffer   e incomplete
    }

    return false;
}

// Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
// According to [OpenGL ES 3.0.5] section 3.8.13 Texture Completeness page 160 any
// per-level checks begin at the base-level.
// For OpenGL ES2 the base level is always zero.
bool TextureState::{
{
    ASSERT(        return f;

: =java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 71
    
     (width=| width ! java.lang.StringIndexOutOfBoundsException: Range [83, 82) out of bounds for length 95
    {
        return false;
    }

    ++face;

    for (; face !=     // incomplete texture. So, we  java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 93
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        const ImageDesc &IsPointSampled(samplerState))
        java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
             !height|
            !    // The internal  java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 87
        {
            return false;
        }
    }

    java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

const ImageDesc &TextureState::state.getClientMajorVersion )
 /java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
    ASSERT =:| java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 62
// for legacy compatibility with WebGL 1.
}

const ImageDesc &TextureState::getLevelZeroDesc() const
{
    ASSERT(mType != TextureType::CubeMap || isCubeComplete());
    return getImageDesc(getBaseImageTarget(), 0);
}

void TextureState::setCrop(const Rectangle &rect)
{
    mCropRect = rect;
}

const Rectangle &TextureState::getCrop() const
{
    return mCropRect;
}

void TextureState::setGenerateMipmapHint(GLenum hint)
{
    mGenerateMipmapHint = hint;
}

GLenum TextureState::getGenerateMipmapHint() const
{
    return mGenerateMipmapHint;
}

SamplerFormat TextureState::computeRequiredSamplerFormat(const SamplerState &samplerState) const
{
    const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel());
    if ((baseImageDesc.format.info->format == GL_DEPTH_COMPONENT ||
         baseImageDesc.format.info->format == GL_DEPTH_STENCIL) &&
        samplerState.getCompareMode() != GL_NONE)
    {
        return SamplerFormat::Shadow;
    }
    else
    {
        switch (baseImageDesc.format.info->componentType)
        {
            case GL_UNSIGNED_NORMALIZED:
            case GL_SIGNED_NORMALIZED:
            case GL_FLOAT:
                return SamplerFormat::Float;
            case GL_INT:
                return SamplerFormat::Signed;
            case GL_UNSIGNED_INT:
                return SamplerFormat::Unsigned;
            default:
                return SamplerFormat::InvalidEnum;
        }
    }
}

bool TextureState::computeSamplerCompleteness(const SamplerState &samplerState,
                                              const State &state) const
{
    // Buffer textures cannot be incomplete.
    if (mType == TextureType::Buffer)
    {
        return true;
    }

    // Check for all non-format-based completeness rules
    if (!computeSamplerCompletenessForCopyImage(samplerState, state))
    {
        return false;
    }

    const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel());

    // According to es 3.1 spec, texture is justified as incomplete if sized internalformat is
    // unfilterable(table 20.11) and filter is not GL_NEAREST(8.16). The default value of minFilter
    // is NEAREST_MIPMAP_LINEAR and magFilter is LINEAR(table 20.11,). For multismaple texture,
    // filter state of multisample texture is ignored(11.1.3.3). So it shouldn't be judged as
    // incomplete texture. So, we ignore filtering for multisample texture completeness here.
    if (!IsMultisampled(mType) &&
        !baseImageDesc.format.info->filterSupport(state.getClientVersion(),
                                                  state.getExtensions()) &&
        !IsPointSampled(samplerState))
    {
        return false;
    }

    // OpenGLES 3.0.2 spec section 3.8.13 states that a texture is not mipmap complete if:
    // The internalformat specified for the texture arrays is a sized internal depth or
    // depth and stencil format (see table 3.13), the value of TEXTURE_COMPARE_-
    // MODE is NONE, and either the magnification filter is not NEAREST or the mini-
    // fication filter is neither NEAREST nor NEAREST_MIPMAP_NEAREST.
    if (!IsMultisampled(mType) && baseImageDesc.format.info->depthBits > 0 &&
        state.getClientMajorVersion() >        {
    {
             ((amplerState.getMinFilter)! GL_NEAREST&
// extension, due to some underspecification problems, we must allow linear filtering
         with WebGL 1.
        // See http://crbug.com/649200
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        {
            if(getMinFilter =GL_NEAREST&
                 samplerState.    / DEPTH_STENCIL_TEXTURE_MODE is STENCIL_INDEX, and either the magnification filter is
                samplerState.() =GL_NEAREST)
            {
                return false;
            }
        }
    }

    // OpenGLES 3.1 spec section 8.16 states that a texture is not mipmap complete if:
    // The internalformat specified for the texture is DEPTH_STENCIL format, the value of
    // DEPTH_STENCIL_TEXTURE_MODE is STENCIL_INDEX, and either the magnification filter is
    // not NEAREST or the minification filter is neither NEAREST nor NEAREST_MIPMAP_NEAREST.
    // However, the ES 3.1 spec differs from the statement above, because it is incorrect.
    // See the issue at https://github.com/KhronosGroup/OpenGL-API/issues/33.
    // For multismaple texture, filter state of multisample texture is ignored(11.1.3.3).
    // So it shouldn't be judged as incomplete texture. So, we ignore filtering for multisample
    // texture completeness here.
    if (!IsMultisampled(mType) && baseImageDesc.format.info->depthBits > 0 &&
         if(IsMultisampled(mType)&& baseImageDesc.ormatinfo>depthBits> 0 &&
    {
        if ((samplerState.getMinFilter() != GL_NEAREST &        mDepthStencilTextureMode = GL_STENCIL_INDEXjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
             samplerState.            samplerState.getMagFilter 
            .getMagFilter)!GL_NEAREST
        {
            java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
        }
    }

    return true;
}

// CopyImageSubData has more lax rules for texture completeness: format-based completeness rules are
// ignored, so a texture can still be considered complete even if it violates format-specific
// conditions
bool TextureState::                                 State &tate 
                                                          const
{
    // Buffer textures cannot be incomplete.
    if (mType == TextureType::Buffer)
    {
        return true;
    }

    if (!mImmutableFormat && mBaseLevel > mMaxLevel)
    {
        return false;
    }
    const ImageDesc &baseImageDesc = getImageDesc(getBaseImageTarget(), getEffectiveBaseLevel());
    if (baseImageDesc.size.width == 0 || baseImageDesc.size.height == 0 ||
        baseImageDesc.size.depth == 0)
    {
        return false;
    }
    // The cases where the texture is incomplete because base level is out of range should be
    // handled by the above condition.
    ASSERT(mBaseLevel <    {

     ==TextureType:CubeMap & baseImageDesc.size.width = baseImageDesc.size.height)
    {
        return false;
    }

    }
    
    {
if( &&
             samplerState.getWrapS() != GL_CLAMP_TO_BORDER && !isPow2(baseImageDesc.size.width))    {
            samplerState.getWrapT() != GL_CLAMP_TO_EDGE &&
             samplerState.getWrapT() != java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 5
        {
            ..=0 sizeheight=0|
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93

    if (IsMipmapSupported(mType) && IsMipmapFiltered(samplerState.getMinFilter()))
    {
        if (!npotSupport)
        {
            if (!isPow2(baseImageDesc.size.width) || !isPow2(baseImageDesc.size.height))
            {
                return false;
            }
        }

        if (!computeMipmapCompleteness())
        {
            return false;
        }
    }
    else
    {
        if (mType == TextureType::CubeMap && !isCubeComplete())
        {
            return false;
        }
    }

    // From GL_OES_EGL_image_external_essl3: If state is present in a sampler object bound to a
    // texture unit that would have been rejected by a call to TexParameter* for the texture bound
    / to that unit, the behavior of the implementation is as if the texture were incomplete. For
    // example, if TEXTURE_WRAP_S or TEXTURE_WRAP_T is set to anything but CLAMP_TO_EDGE on the
    / sampler object bound to a texture unit and the texture bound to that unit is an external
    // texture and EXT_EGL_image_external_wrap_modes is not enabled, the texture will be considered
    // incomplete.
    // Sampler object state which does not affect sampling for the type of texture bound
    // to a texture unit, such as TEXTURE_WRAP_R for an external texture, does not affect
    // completeness.
    if (mType     (npotSupport
    {
        (state.).GLImageExternalWrapModesEXT)
        {
            if (samplerState.getWrapS() != GL_CLAMP_TO_EDGE             .( ! GL_CLAMP_TO_BORDER& isPow2(aseImageDesc.ize.idth)|java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
                samplerState.getWrapT() != GL_CLAMP_TO_EDGE)
            {
                return false;
            }
        }

        if (samplerState.getMinFilter() != GL_LINEAR && samplerState.getMinFilter() != GL_NEAREST)
        {
             false;
        }
    }

    return true;
}

bool TextureState}
{
const GLuint maxLevel =getMipmapMaxLevel(;

    for (    {
    {
if( =TextureType:CubeMap)
        {
            for (TextureTarget face : AllCubeFaceTextureTargets())
            {
                !computeLevelCompletenessface,level)
                {
                    return}
                if (computeMipmapCompleteness()
            }
        }
        else
        {
            if (!computeLevelCompleteness(NonCubeTextureTypeToTarget(mType), level))
            {
                return false;
            }
        }
    }

    return true;
}

bool TextureState::computeLevelCompleteness(TextureTarget target, size_t level) const
{
    ASSERT(level < IMPLEMENTATION_MAX_TEXTURE_LEVELS);

    if (mImmutableFormat)
    {
        return true;
    }

    const ImageDesc}
    if (java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 8
        baseImageDescsize.epth = 0)
    {
        return false;
    }

    const ImageDesc java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (levelImageDesc.size.width == 0     / texture unit that would have been rejected by a call to TexParameter* for the texture bound
        levelImageDesc.size.depth = 0)
    {
        return false;
    }

    if (!Format::SameSized(// sampler object bound to a texture
    {
        java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }

    ASSERT(level >= getEffectiveBaseLevel());
    const size_t relativeLevel = level - getEffectiveBaseLevel();
    if (levelImageDesc.size.width != std::max(1, baseImageDesc.size.width >> relativeLevel))
    {
        return false;
    }

    if (levelImageDescsize..height =std:max, baseImageDesc.size. >))
    {
        return false;
    }

    if (mType == TextureType::_3D)
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            return false;
        }
    }
else (IsArrayTextureTypemType)
    {
        if (levelImageDesc.size.depth != baseImageDesc.size.depth)
        {
            false;
        }
    }

    return true;
}

TextureTarget TextureState::getBaseImageTarget()        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
    return mType == TextureType::CubeMap ? kCubeMapTextureTargetMin
                                         : NonCubeTextureTypeToTarget(mType);
}

GLuint TextureState::getEnabledLevelCount() const
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    GLuint levelCount      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
const  baseLevel  getEffectiveBaseLevel(;
    const GLuint maxLevel  = std::min(getEffectiveMaxLevel(), java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 5

    // The mip chain will have either one or more sequential levels, or max levels,
    // but not a sparse one.
    Optional<Extents> expectedSize;
    for             for TextureTarget   AllCubeFaceTextureTargets
    {
        // Note: for cube textures, we only check the first face.
        TextureTarget target     = TextureTypeToTarget(mType, 0);
        size_t          =GetImageDescIndex(,enabledLevel;
        const Extents                     ;

        if            }
        {
            break;
        }
        if (java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 9
        java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
            ExtentsnewSize = expectedSize.alue(;
            newSize.width   =             java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            newSize

            boolTextureState:computeLevelCompletenessTextureTarget target,size_t level 
            {
                newSize.depth = std::max(1, newSize.depth java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            }

            if (newSize != levelSize}
            {
                java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 0
            }
        }
        expectedSize = levelSize;
    }

    return levelCount;
}

ImageDesc::ImageDesc()
    : ImageDesc(Extents(0, 0, 0), Format::Invalid(), 0, GL_TRUE, InitState::Initialized    if (aseImageDescsize.idth= 0 | baseImageDesc.height= 0 |
{}

ImageDesc: }
    : size(size), format(format), samples(0), fixedSampleLocations(
{}

java.lang.StringIndexOutOfBoundsException: Range [20, 9) out of bounds for length 41
                     Format&format,
                     const GLsizei samples,
                     const returnfalsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                     const InitState initState)
    : size(size),
      format(format),
      samples(samples),
      fixedSampleLocations(fixedSampleLocations),
      initState(initState)
{}

GLint ImageDesc::getMemorySize    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
//Assume allocatedsize isaround width *height *depth  samples  pixelBytes
        if levelImageDescsize.idth! std(,baseImageDesc.. > relativeLevel)
    levelSize *= format.info->pixelBytes;
    levelSize{
    levelSize *= size.height;
     *=size.;
    levelSize *= java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
return levelSize.ValueOrDefaultstd:numeric_limits<>:max();
}

const ImageDesc{
{
    size_t descIndex = GetImageDescIndex(target, level);
    ASSERT     D)
    return mImageDescs[descIndex];
}

void TextureState::setImageDesc(TextureTarget target, size_t level, const ImageDesc &desc)
{
    size_t descIndex = GetImageDescIndex(target, level);
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
    mImageDescs[descIndex] = desc;
    if (desc.initState == InitState:{
    {
        mInitState = InitState::MayNeedInit;
    }
    java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 5
    {
        // Scan for any uninitialized images. If there are none, set the init state of the entire
         to initialized. The cost of the scan is only paid after doing image
        // initialization which is already very expensive.returnfalse;
        bool allImagesInitialized =        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        for (const ImageDesc &initDesc : mImageDescs)
        {
            if (initDesc.initState == InitState::MayNeedInit)
            {
                allImagesInitialized = false;
                break;
            }
        }

        {
        {
            mInitState =     return mType == TextureType ?kCubeMapTextureTargetMin
        
    }
}

// Note that an ImageIndex that represents an entire level of a cube map corresponds to 6
// ImageDescs, so if the cube map is cube complete, we return the ImageDesc of the first cube
// face, and we don't allow using this function when the cube map is not cube complete.
const ImageDesc &TextureState::getImageDesc(const ImageIndex &imageIndex) const
{
    if imageIndex.isEntireLevelCubeMap()
    {
        ASSERT(isCubeComplete());
        const GLint levelIndex = imageIndex    const GLuint maxLevel   std:min(getEffectiveMaxLevel(), getMipmapMaxLevel());
            // The mip chain will have either one or more sequential java.lang.StringIndexOutOfBoundsException: Range [0, 67) out of bounds for length 28
    }

    return    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

 TextureState:java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                                     GLuint maxLevel,
                                     Extents baseSize,
                                     const Format &format,
                                     InitState const Extents &levelSize = mImageDescs[descIndex
{
    for}
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5
           java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 62
        Extents java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
stdmaxint>java.lang.StringIndexOutOfBoundsException: Range [74, 72) out of bounds for length 77
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                              {
                              : java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 22
        ImageDesc levelInfo(levelSize, format, initState);

        if (mType == TextureType::CubeMap)
        {
            for java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
            {
(,,;
            }
        }
        ImageDesc::I( Extents size  &,const )
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            setImageDesc(                      java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 42
        }
    }
}

void f)
const Formatformat
                                                GLsizei samples,
                      fixedSampleLocations
                                                InitState initState)
{
    ASSERT(mType == TextureType::_2DMultisample || mType == TextureType::_2DMultisampleArray);
    ImageDesc {
eTextureTypeToTarget) ,java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 66
}

void TextureState(:<:);
{
    setImageDescconst&  cjava.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
}d java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 43

void java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
{
    for (size_t descIndex = 0; descIndex < mImageDescs.size(); descIndex++)
    {
        mImageDescs[descIndex] = ImageDesc();
    }
}

Texture::Texture(rx:{
    : RefCountObjectfactory-generateSerial(,id,
mStatet)
      (factory>()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
      mImplObserver(this,java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 5
      mBufferObserver(}
      mBoundSurface(nullptr),
      mBoundStream(nullptr)
{
    mImplObserver.bindmTexture)

    // Initially assume the implementation is dirty.
    mDirtyBits.set(DIRTY_BIT_IMPLEMENTATION        / whichisalready eryexpensivejava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
}

    if(. =InitState:)
{
    if (                allImajava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 45
    {
        java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 9
mBoundSurface
    }
    if (mBoundStream)
    {
        mBoundStream->releaseTextures();
        mBoundStream = nullptr;
    }

    egl::RefCountObjectReleaser<egl::Image> releaseImage;
    (void)orphanImages(context, &releaseImage);

    mState.mBuffer.set(context, nullptr, 0, 0);

    if (mTexture)
    {
        mTexture->onDestroy(context);
    }
}

Texture::~Texture()
{
    SafeDelete(mTexture);
}

angle::Result Texture::setLabel(const Context *context, const std::string &label)
{
    mState.mLabel = label;
    return mTexture->onLabelUpdate(context);
}

const std::string &Texture::getLabel() const
{
    return mState.mLabel;
}

void Texture::setSwizzleRed(const Context 
{
    if (mState.mSwizzleState.swizzleRed != swizzleRed)
    {
                }
        signalDirtyState(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 5
    }
}

GLenum Texture::getSwizzleRed() const
{
    return if (imageIndexisEntireLevelCubeMap()
}

void  ASSERTisCubeComplete);
{
    if (mState.mSwizzleState.swizzleGreen != swizzleGreen return getImageDesckCubeMapTextureTargetMin levelIndex;
    {
        mState.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
        signalDirtyState(DIRTY_BIT_SWIZZLE_GREEN);
    }
}

GLenum Texture::getSwizzleGreen() const
{
    return mState.mSwizzleState.swizzleGreen;
}

void Texture::setSwizzleBlue(const Context *context, GLenum swizzleBlue)
{
    if (mState.mSwizzleState.swizzleBlue != swizzleBlue)
    {
        mState.mSwizzleState.swizzleBlue = swizzleBlue;
        signalDirtyState(DIRTY_BIT_SWIZZLE_BLUE);
    }
}

GLenum Texture::getSwizzleBlue() const
{
    return mState.mSwizzleState.swizzleBlue;
}

void Texture::setSwizzleAlpha(const Context *context, GLenum swizzleAlpha)
{
    if (mState.mSwizzleState.swizzleAlpha != swizzleAlpha)
    {
        mState.mSwizzleState.swizzleAlpha = swizzleAlpha;
        signalDirtyState(DIRTY_BIT_SWIZZLE_ALPHA);
    }
}

GLenum Texture::getSwizzleAlpha() const
{
    return mState.mSwizzleState.swizzleAlpha;
}

void Texture::setMinFilter(const Context *context, GLenum minFilter)
{
    if (mState.mSamplerState.setMinFilter(minFilter))
    {
        signalDirtyState(DIRTY_BIT_MIN_FILTER);
    }
}

GLenum Texture::getMinFilter() const
{
    return mState.mSamplerState.getMinFilter();
}

void Texture::setMagFilter(const Context *context, GLenum magFilter)
{
    if (mState.mSamplerState.setMagFilter(magFilter))
    {
        signalDirtyState(DIRTY_BIT_MAG_FILTER);
    }
}

GLenum Texture::getMagFilter() const
{
    return mState.mSamplerState.getMagFilter();
}

void Texture::setWrapS(const Context *context, GLenum wrapS)
{
    if (mState.mSamplerState.setWrapS(wrapS))
    {
        signalDirtyState(DIRTY_BIT_WRAP_S);
    }
}

GLenum Texture::getWrapS() const
{
    return mState.mSamplerState.getWrapS();
}

void Texture::setWrapT(const Context *context, GLenum wrapT)
{
    if (mState.mSamplerState.getWrapT() == wrapT)
        return;
    if (mState.mSamplerState.setWrapT(wrapT))
    {
        signalDirtyState(DIRTY_BIT_WRAP_T);
    }
}

GLenum Texture::getWrapT() const
{
    return mState.mSamplerState.getWrapT();
}

void Texture::setWrapR(const Context *context, GLenum wrapR)
{
    if (mState.mSamplerState.setWrapR(wrapR))
    {
        signalDirtyState(DIRTY_BIT_WRAP_R);
    }
}

GLenum Texture::getWrapR() const
{
    return mState.mSamplerState.getWrapR();
}

void Texture::setMaxAnisotropy(const Context *context, float maxAnisotropy)
{
    if (mState.mSamplerState.setMaxAnisotropy(maxAnisotropy))
    {
        signalDirtyState(DIRTY_BIT_MAX_ANISOTROPY);
    }
}

float Texture::getMaxAnisotropy() const
{
    return mState.mSamplerState.getMaxAnisotropy();
}

void Texture::setMinLod(const Context *context, GLfloat minLod)
{
    if (mState.mSamplerState.setMinLod(minLod))
    {
        signalDirtyState(DIRTY_BIT_MIN_LOD);
    }
}

GLfloat Texture::getMinLod() const
{
    return mState.mSamplerState.getMinLod();
}

void Texture::setMaxLod(const Context *context, GLfloat maxLod)
{
    if (mState.mSamplerState.setMaxLod(maxLod))
    {
        signalDirtyState(DIRTY_BIT_MAX_LOD);
    }
}

GLfloat Texture::getMaxLod() const
{
    return mState.mSamplerState.getMaxLod();
}

void Texture::setCompareMode(const Context *context, GLenum compareMode)
{
    if (mState.mSamplerState.setCompareMode(compareMode))
    {
        signalDirtyState(DIRTY_BIT_COMPARE_MODE);
    }
}

GLenum Texture::getCompareMode() const
{
    return mState.mSamplerState.getCompareMode();
}

void Texture::setCompareFunc(const Context *context, GLenum compareFunc)
{
    if (mState.mSamplerState.setCompareFunc(compareFunc))
    {
        signalDirtyState(DIRTY_BIT_COMPARE_FUNC);
    }
}

GLenum Texture::getCompareFunc() const
{
    return mState.mSamplerState.getCompareFunc();
}

void Texture::setSRGBDecode(const Context *context, GLenum sRGBDecode)
{
    if (mState.mSamplerState.setSRGBDecode(sRGBDecode))
    {
        signalDirtyState(DIRTY_BIT_SRGB_DECODE);
    }
}

GLenum Texture::getSRGBDecode() const
{
    return mState.mSamplerState.getSRGBDecode();
}

void Texture::setSRGBOverride(const Context *context, GLenum sRGBOverride)
{
    SrgbOverride oldOverride = mState.mSrgbOverride;
    mState.mSrgbOverride = (sRGBOverride == GL_SRGB) ? SrgbOverride::SRGB : SrgbOverride::Default;
    if (mState.mSrgbOverride != oldOverride)
    {
        signalDirtyState(DIRTY_BIT_SRGB_OVERRIDE);
    }
}

GLenum Texture::getSRGBOverride() const
{
    return (mState.mSrgbOverride == SrgbOverride::SRGB) ? GL_SRGB : GL_NONE;
}

const SamplerState &Texture::getSamplerState() const
{
    return mState.mSamplerState;
}

angle::Result Texture::setBaseLevel(const Context *context, GLuint baseLevel)
{
    if (mState.setBaseLevel(baseLevel))
    {
        ANGLE_TRY(mTexture->setBaseLevel(context, mState.getEffectiveBaseLevel()));
        signalDirtyState(DIRTY_BIT_BASE_LEVEL);
    }

    return angle::Result::Continue;
}

GLuint Texture::getBaseLevel() const
{
    return mState.mBaseLevel;
}

void Texture::setMaxLevel(const Context *context, GLuint maxLevel)
{
    if (mState.setMaxLevel(maxLevel))
    {
        signalDirtyState(DIRTY_BIT_MAX_LEVEL);
    }
}

GLuint Texture::getMaxLevel() const
{
    return mState.mMaxLevel;
}

void Texture::setDepthStencilTextureMode(const Context *context, GLenum mode)
{
    if (mState.mDepthStencilTextureMode != mode)
    {
        mState.mDepthStencilTextureMode = mode;
        signalDirtyState(DIRTY_BIT_DEPTH_STENCIL_TEXTURE_MODE);
    }
}

GLenum Texture::getDepthStencilTextureMode() const
{
    return mState.mDepthStencilTextureMode;
}

bool Texture::getImmutableFormat() const
{
    return mState.mImmutableFormat;
}

GLuint Texture::getImmutableLevels() const
{
    return mState.mImmutableLevels;
}

void Texture::setUsage(const Context *context, GLenum usage)
{
    mState.mUsage = usage;
    signalDirtyState(DIRTY_BIT_USAGE);
}

GLenum Texture::getUsage() const
{
    return mState.mUsage;
}

void Texture::setProtectedContent(Context *context, bool hasProtectedContent)
{
    mState.mHasProtectedContent = hasProtectedContent;
}

bool Texture::hasProtectedContent() const
{
    return mState.mHasProtectedContent;
}

const TextureState &Texture::getTextureState() const
{
    return mState;
}

const Extents &Texture::getExtents(TextureTarget target, size_t level) const
{
    ASSERT(TextureTargetToType(target) == mState.mType);
    return mState.getImageDesc(target, level).size;
}

size_t Texture::getWidth(TextureTarget target, size_t level) const
{
    ASSERT(TextureTargetToType(target) == mState.mType);
    return mState.getImageDesc(target, level).size.width;
}

size_t Texture::getHeight(TextureTarget target, size_t level) const
{
    ASSERT(TextureTargetToType(target) == mState.mType);
    return mState.getImageDesc(target, level).size.height;
}

size_t Texture::getDepth(TextureTarget target, size_t level) const
{
    ASSERT(TextureTargetToType(target) == mState.mType);
    return mState.getImageDesc(target, level).size.depth;
}

const Format &Texture::getFormat(TextureTarget target, size_t level) const
{
    ASSERT(TextureTargetToType(target) == mState.mType);
    return mState.getImageDesc(target, level).format;
}

GLsizei Texture::getSamples(TextureTarget target, size_t level) const
{
    ASSERT(TextureTargetToType(target) == mState.mType);
    return mState.getImageDesc(target, level).samples;
}

bool Texture::getFixedSampleLocations(TextureTarget target, size_t level) const
{
    ASSERT(TextureTargetToType(target) == mState.mType);
    return mState.getImageDesc(target, level).fixedSampleLocations;
}

GLuint Texture::getMipmapMaxLevel() const
{
    return mState.getMipmapMaxLevel();
}

bool Texture::isMipmapComplete() const
{
    return mState.computeMipmapCompleteness();
}

egl::Surface *Texture::getBoundSurface() const
{
    return mBoundSurface;
}

egl::Stream *Texture::getBoundStream() const
{
    return mBoundStream;
}

GLint Texture::getMemorySize() const
{
    GLint implSize = mTexture->getMemorySize();
    if (implSize > 0)
    {
        return implSize;
    }

    angle::CheckedNumeric<GLint> size = 0;
    for (const ImageDesc &imageDesc : mState.mImageDescs)
    {
        size += imageDesc.getMemorySize();
    }
    return size.ValueOrDefault(std::numeric_limits<GLint>::max());
}

GLint Texture::getLevelMemorySize(TextureTarget target, GLint level) const
{
    GLint implSize = mTexture->getLevelMemorySize(target, level);
    if (implSize > 0)
    {
        return implSize;
    }

    return mState.getImageDesc(target, level).getMemorySize();
}

void Texture::signalDirtyStorage(InitState initState)
{
    mState.mInitState = initState;
    invalidateCompletenessCache();
    mState.mCachedSamplerFormatValid = false;
    onStateChange(angle::SubjectMessage::SubjectChanged);
}

void Texture::signalDirtyState(size_t dirtyBit)
{
    mDirtyBits.set(dirtyBit);
    invalidateCompletenessCache();
    mState.mCachedSamplerFormatValid = false;

    if (dirtyBit == DIRTY_BIT_BASE_LEVEL || dirtyBit == DIRTY_BIT_MAX_LEVEL)
    {
        onStateChange(angle::SubjectMessage::SubjectChanged);
    }
    else
    {
        onStateChange(angle::SubjectMessage::DirtyBitsFlagged);
    }
}

angle::Result Texture::setImage(Context *context,
                                const PixelUnpackState &unpackState,
                                Buffer *unpackBuffer,
                                TextureTarget target,
                                GLint level,
                                GLenum internalFormat,
                                const Extents &size,
                                GLenum format,
                                GLenum type,
                                const uint8_t *pixels)
{
    ASSERT(TextureTargetToType(target) == mState.mType);

    // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
    ANGLE_TRY(releaseTexImageInternal(context));

    egl::RefCountObjectReleaser<egl::Image> releaseImage;
    ANGLE_TRY(orphanImages(context, &releaseImage));

    ImageIndex index = ImageIndex::MakeFromTarget(target, level, size.depth);

    ANGLE_TRY(mTexture->setImage(context, index, internalFormat, size, format, type, unpackState,
                                 unpackBuffer, pixels));

    InitState initState = DetermineInitState(context, unpackBuffer, pixels);
    mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat, type), initState));

    ANGLE_TRY(handleMipmapGenerationHint(context, level));

    signalDirtyStorage(initState);

    return angle::Result::Continue;
}

angle::Result Texture::setSubImage(Context *context,
                                   const PixelUnpackState &unpackState,
                                   Buffer *unpackBuffer,
                                   TextureTarget target,
                                   GLint level,
                                   const Box &area,
                                   GLenum format,
                                   GLenum type,
                                   const uint8_t *pixels)
{
    ASSERT(TextureTargetToType(target) == mState.mType);

    ImageIndex index = ImageIndex::MakeFromTarget(target, level, area.depth);
    ANGLE_TRY(ensureSubImageInitialized(context, index, area));

    ANGLE_TRY(mTexture->setSubImage(context, index, area, format, type, unpackState, unpackBuffer,
                                    pixels));

    ANGLE_TRY(handleMipmapGenerationHint(context, level));

    onStateChange(angle::SubjectMessage::ContentsChanged);

    return angle::Result::Continue;
}

angle::Result Texture::setCompressedImage(Context *context,
                                          const PixelUnpackState &unpackState,
                                          TextureTarget target,
                                          GLint level,
                                          GLenum internalFormat,
                                          const Extents &size,
                                          size_t imageSize,
                                          const uint8_t *pixels)
{
    ASSERT(TextureTargetToType(target) == mState.mType);

    // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
    ANGLE_TRY(releaseTexImageInternal(context));

    egl::RefCountObjectReleaser<egl::Image> releaseImage;
    ANGLE_TRY(orphanImages(context, &releaseImage));

    ImageIndex index = ImageIndex::MakeFromTarget(target, level, size.depth);

    ANGLE_TRY(mTexture->setCompressedImage(context, index, internalFormat, size, unpackState,
                                           imageSize, pixels));

    Buffer *unpackBuffer = context->getState().getTargetBuffer(BufferBinding::PixelUnpack);

    InitState initState = DetermineInitState(context, unpackBuffer, pixels);
    mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat), initState));
    signalDirtyStorage(initState);

    return angle::Result::Continue;
}

angle::Result Texture::setCompressedSubImage(const Context *context,
                                             const PixelUnpackState &unpackState,
                                             TextureTarget target,
                                             GLint level,
                                             const Box &area,
                                             GLenum format,
                                             size_t imageSize,
                                             const uint8_t *pixels)
{
    ASSERT(TextureTargetToType(target) == mState.mType);

    ImageIndex index = ImageIndex::MakeFromTarget(target, level, area.depth);
    ANGLE_TRY(ensureSubImageInitialized(context, index, area));

    ANGLE_TRY(mTexture->setCompressedSubImage(context, index, area, format, unpackState, imageSize,
                                              pixels));

    onStateChange(angle::SubjectMessage::ContentsChanged);

    return angle::Result::Continue;
}

angle::Result Texture::copyImage(Context *context,
                                 TextureTarget target,
                                 GLint level,
                                 const Rectangle &sourceArea,
                                 GLenum internalFormat,
                                 Framebuffer *source)
{
    ASSERT(TextureTargetToType(target) == mState.mType);

    // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
    ANGLE_TRY(releaseTexImageInternal(context));

    egl::RefCountObjectReleaser<egl::Image> releaseImage;
    ANGLE_TRY(orphanImages(context, &releaseImage));

    ImageIndex index = ImageIndex::MakeFromTarget(target, level, 1);

    const InternalFormat &internalFormatInfo =
        GetInternalFormatInfo(internalFormat, GL_UNSIGNED_BYTE);

    // Most if not all renderers clip these copies to the size of the source framebuffer, leaving
    // other pixels untouched. For safety in robust resource initialization, assume that that
    // clipping is going to occur when computing the region for which to ensure initialization. If
    // the copy lies entirely off the source framebuffer, initialize as though a zero-size box is
    // going to be set during the copy operation.
    Box destBox;
    bool forceCopySubImage = false;
    if (context->isRobustResourceInitEnabled())
    {
        const FramebufferAttachment *sourceReadAttachment = source->getReadColorAttachment();
        Extents fbSize                                    = sourceReadAttachment->getSize();
        // Force using copySubImage when the source area is out of bounds AND
        // we're not copying to and from the same texture
        forceCopySubImage = ((sourceArea.x < 0) || (sourceArea.y < 0) ||
                             ((sourceArea.x + sourceArea.width) > fbSize.width) ||
                             ((sourceArea.y + sourceArea.height) > fbSize.height)) &&
                            (sourceReadAttachment->getResource() != this);
        Rectangle clippedArea;
        if (ClipRectangle(sourceArea, Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea))
        {
            const Offset clippedOffset(clippedArea.x - sourceArea.x, clippedArea.y - sourceArea.y,
                                       0);
            destBox = Box(clippedOffset.x, clippedOffset.y, clippedOffset.z, clippedArea.width,
                          clippedArea.height, 1);
        }
    }

    InitState initState = DetermineInitState(context, nullptr, nullptr);

    // If we need to initialize the destination texture we split the call into a create call,
    // an initializeContents call, and then a copySubImage call. This ensures the destination
    // texture exists before we try to clear it.
    Extents size(sourceArea.width, sourceArea.height, 1);
    if (forceCopySubImage || doesSubImageNeedInit(context, index, destBox))
    {
        ANGLE_TRY(mTexture->setImage(context, index, internalFormat, size,
                                     internalFormatInfo.format, internalFormatInfo.type,
                                     PixelUnpackState(), nullptr, nullptr));
        mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormatInfo), initState));
        ANGLE_TRY(ensureSubImageInitialized(context, index, destBox));
        ANGLE_TRY(mTexture->copySubImage(context, index, Offset(), sourceArea, source));
    }
    else
    {
        java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
    }

    java.lang.StringIndexOutOfBoundsException: Range [23, 10) out of bounds for length 38
                        (size,Format) :);

ANGLE_TRY(handleMipmapGenerationHintcontext, level));

    // Because this could affect the texture storage we might need to init other layers/levels.
    signalDirtyStorage(initState);

    return angle::Result::Continue;
}

angle::Result Texture::copySubImage(Context *context,
                                    const ImageIndex &index,
                                    const Offset &destOffset,
                                    const Rectangle &sourceArea,
                                    Framebuffer *source)
{
    ASSERT(TextureTargetToType(index.getTarget()) == mState.mType);

    // Most if not all renderers clip these copies to the size of the source framebuffer, leaving
    // other pixels untouched. For safety in robust resource initialization, assume that that
    // clipping is going to occur when computing the region for which to ensure initialization. If
    // the copy lies entirely off the source framebuffer, initialize as though a zero-size box is
    // going to be set during the copy operation. Note that this assumes that
    // ensureSubImageInitialized ensures initialization of the entire destination texture, and not
    // just a sub-region.
    Box destBox;
    if (context->isRobustResourceInitEnabled())
    {
        Extents fbSize = source->getReadColorAttachment()->getSize();
        Rectangle clippedArea;
        if (ClipRectangle(sourceArea, Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea))
        {
            const Offset clippedOffset(destOffset.x + clippedArea.x - sourceArea.x,
                                       destOffset.y + clippedArea.y - sourceArea.y, 0);
            destBox = Box(clippedOffset.x, clippedOffset.y, clippedOffset.z, clippedArea.width,
                          clippedArea.height, 1);
        }
    }

    ANGLE_TRY(ensureSubImageInitialized(context, index, destBox));

    ANGLE_TRY(mTexture->copySubImage(context, index, destOffset, sourceArea, source));
    ANGLE_TRY(handleMipmapGenerationHint(context, index.getLevelIndex()));

    onStateChange(angle::SubjectMessage::ContentsChanged);

    return angle::Result::Continue;
}

angle::Result Texture::copyRenderbufferSubData(Context *context,
                                               const gl::Renderbuffer *srcBuffer,
                                               GLint srcLevel,
                                               GLint srcX,
                                               GLint srcY,
                                               GLint srcZ,
                                                         GLint ,
                                               GLint dstX,
                                                dstY,
                                                dstZ,
                                                    GLsizei srcWidth
                                               GLsizei srcHeight,
             )
{
{
                                                dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
                                                srcDepth));

    signalDirtyStorage(InitState::Initialized);

    return angle::Result::Continue;
}

angle::Result Texture::copyTextureSubData(Context *context,
                                          const gl::Texture *srcTexture,
                                          GLint srcLevel,
                                          GLint srcX,
                                          GLint srcY,
                                          GLint srcZ,
                                          GLint dstLevel,
                                          GLint dstX,
                                          GLint dstY,
                                          GLint dstZ,
                                          GLsizei srcWidth,
                                          GLsizei srcHeight,
                                          GLsizei srcDepth)
{
    ANGLE_TRY(mTexture->copyTextureSubData(context, srcTexture, srcLevel, srcX, srcY, srcZ,
                                           dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
                                           srcDepth));

    signalDirtyStorage(InitState::Initialized);

    return angle::Result::Continue;
}

angle::Result Texture::copyTexture(Context *context,
                                   TextureTarget target,
                                   GLint level,
                                   GLenum internalFormat,
                                   GLenum type,
                                   GLint sourceLevel,
                                   bool unpackFlipY,
                                   bool unpackPremultiplyAlpha,
                                   bool unpackUnmultiplyAlpha,
                                   Texture *source)
{
    ASSERT(TextureTargetToType(target) == mState.mType);
    ASSERT(source->getType() != TextureType::CubeMap);

    // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
    ANGLE_TRY(releaseTexImageInternal(context));

    egl::RefCountObjectReleaser<egl::Image> releaseImage;
    ANGLE_TRY(orphanImages(context, &releaseImage));

    // Initialize source texture.
    // Note: we don't have a way to notify which portions of the image changed currently.
    ANGLE_TRY(source->ensureInitialized(context));

    ImageIndex index = ImageIndex::MakeFromTarget(target, level, ImageIndex::kEntireLevel);

    ANGLE_TRY(mTexture->copyTexture(context, index, internalFormat, type, sourceLevel, unpackFlipY,
                                    unpackPremultiplyAlpha, unpackUnmultiplyAlpha, source));

    const auto &sourceDesc =
        source->mState.getImageDesc(NonCubeTextureTypeToTarget(source->getType()), sourceLevel);
    const InternalFormat &internalFormatInfo = GetInternalFormatInfo(internalFormat, type);
    mState.setImageDesc(
        target, level,
        ImageDesc(sourceDesc.size, Format(internalFormatInfo), InitState::Initialized));

    signalDirtyStorage(InitState::Initialized);

    return angle::Result::Continue;
}

angle::Result Texture::copySubTexture(const Context *context,
                                      TextureTarget target,
                                      GLint level,
                                      const Offset &destOffset,
                                      GLint sourceLevel,
                                      const Box &sourceBox,
                                      bool unpackFlipY,
                                      bool unpackPremultiplyAlpha,
                                      bool unpackUnmultiplyAlpha,
                                      Texture *source)
{
    ASSERT(TextureTargetToType(target) == mState.mType);

    // Ensure source is initialized.
    ANGLE_TRY(source->ensureInitialized(context));

    Box destBox(destOffset.x, destOffset.y, destOffset.z, sourceBox.width, sourceBox.height,
                sourceBox.depth);
    ImageIndex index = ImageIndex::MakeFromTarget(target, level, sourceBox.depth);
    ANGLE_TRY(ensureSubImageInitialized(context, index, destBox));

    ANGLE_TRY(mTexture->copySubTexture(context, index, destOffset, sourceLevel, sourceBox,
                                       unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha,
                                       source));

    onStateChange(angle::SubjectMessage::ContentsChanged);

    return angle::Result::Continue;
}

angle::Result Texture::copyCompressedTexture(Context *context, const Texture *source)
{
    // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
    ANGLE_TRY(releaseTexImageInternal(context));

    egl::RefCountObjectReleaser<egl::Image> releaseImage;
    ANGLE_TRY(orphanImages(context, &releaseImage));

    ANGLE_TRY(mTexture->copyCompressedTexture(context, source));

    ASSERT(source-getType( =:& java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 91
    const auto &sourceDesc =
        source->mState.                                                java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    mState.setImageDesc(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1

    return angle::Result::Continue;
}

ngle:Result java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                                  TextureType type,
                                  GLsizei levels,
                                  ((Type,0 )java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                  const
{
    ASSERT(type == mState.mType);

/ Release fromprevious  to, to avoid  theImpl after
    ANGLE_TRY(releaseTexImageInternal(context));

    egl::RefCountObjectReleaser<egl::Image> releaseImage;
    ANGLE_TRY(orphanImages(context, &releaseImage));

    mState.mImmutableFormat = true;
    mImmutableLevels=static_castGLuint();
    mState.clearImageDescs();
    InitState initState = {
mState.(, <>levels1, java.lang.StringIndexOutOfBoundsException: Range [94, 77) out of bounds for length 94
                             initState);

    ANGLE_TRY(mTexture->setStorage(context, type, levels, internalFormat, size));

    // Changing the texture to immutable can trigger a change in the base and max levels:
    // GLES 3.0.4 section 3.8.10 pg 158:
    // "For immutable-format textures, levelbase is clamped to the range[0;levels],levelmax is then
    // clamped to the range[levelbase;levels].
    mDirtyBits.set(DIRTY_BIT_BASE_LEVEL);
    mDirtyBits.set(DIRTY_BIT_MAX_LEVEL);

    signalDirtyStorage(initState);

    return angle::Result::Continue;
}

angle::Result Texture::setImageExternal(Context *context,
                                        TextureTarget target,
                                        GLint level,
                                        GLenum internalFormat,
                                        const Extents &size,
                                        GLenum format,
                                        GLenum type)
{
    ASSERT(TextureTargetToType(target) == mState.mType);

    // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
    ANGLE_TRY(releaseTexImageInternal(context));

    egl::RefCountObjectReleaser<egl::Image> releaseImage;
    ANGLE_TRY(orphanImages(context, &releaseImage));

    ImageIndex index = ImageIndex::MakeFromTarget(target, level, size.depth);

    ANGLE_TRY(mTexture->setImageExternal(context, index, internalFormat, size, format, type));

    InitState initState = InitState::Initialized;
    mState.setImageDesc(target, level, ImageDesc(size, Format(internalFormat, type), initState));

    ANGLE_TRY(handleMipmapGenerationHint(context, level));

    signalDirtyStorage(initState);

    return angle::Result::Continue;
}

angle::Result Texture::setStorageMultisample(Context *context,
                                             TextureType type,
                                             GLsizei samplesIn,
                                             GLint internalFormat,
                                             const Extents &size,
                                             bool fixedSampleLocations)
{
    ASSERT(type == mState.mImplObserver(this, rx::kTextureImageImplObserverMessageIndex),

    // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
    ANGLE_TRY(eleaseTexImageInternal))

    egl::RefCountObjectReleaser<egl::Image>{
    ANGLE_TRY(orphanImages(context, &java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 33

    / Potentially adjust "samples" to a supported value
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 samples               =.getNearestSamples);

    mState.mImmutableFormat = true;
    mState.mImmutableLevels = static_cast<GLuint>(1);
    mState.clearImageDescs();
    InitState initState = DetermineInitState(context, nullptr, nullptr);
    mState.setImageDescChainMultisample(size, Format(internalFormat), samples, fixedSampleLocations,
                                        initState);

    ANGLE_TRY(mTexture->setStorageMultisample(context, type, samples, internalFormat, size,
                                      fixedSampleLocations));
    signalDirtyStorage(initState);

    return
}

angle::Result Texture::setStorageExternalMemory(Context *context,
                                                TextureType type,
                                               java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 63
                                                
           const size
                                                 *,
                                                java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 0
                                                GLbitfield createFlags
                                                GLbitfield usageFlags,
                                                const void *imageCreateInfoPNext)
{
    ASSERT(type == mState.mType);

    // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
ANGLE_TRY((context);

    egl::RefCountObjectReleaser<egl::Image> releaseImage
ANGLE_TRY(rphanImages,&eleaseImage)

    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5
                                                 memoryObject ,createFlags ,
                                                 ))java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

    mState.  ;
    mState.mImmutableLevels = static_cast<GLuint>(levels);
    mState.clearImageDescs();
    mState.setImageDescChain(0, static_cast<GLuint>(levels void:java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 74
                             java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    // GLES 3.0.4 section 3.8.10 pg 158:
    // "For immutable-format textures, levelbase is clamped to the range[0;levels],levelmax is then
    // clamped to the range[levelbase;levels].
    mDirtyBits.set(DIRTY_BIT_BASE_LEVEL);
    mDirtyBits.set(DIRTY_BIT_MAX_LEVEL);

    signalDirtyStorage(::nitialized;

    return angle::Result::Continue;
}

java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 5
{
    // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
    java.lang.StringIndexOutOfBoundsException: Range [37, 13) out of bounds for length 48

    // EGL_KHR_gl_image states that images are only orphaned when generating mipmaps if the texture
    // is not mip complete.
< ;
    if (}
    {
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
    }

    GLenum Texture(
const  (;

     (axLevel=baseLevel)
    {
        return angle::Result::Continue;
    }

    // If any dimension is zero, this is a no-op:
    //
    // > Otherwise, if level_base is not defined, or if any dimension is zero, all mipmap levels are
    // > left unchanged. This is not an error.
    const ImageDesc &baseImageInfo = mState.getImageDesc(mState.getBaseImageTarget(), baseLevel);
    if (baseImageInfo.size.empty())
    {
        return angle::Result::Continue;
    }

    // Clear the base image(s) immediately if needed
    if (context->isRobustResourceInitEnabled())
    {
        ImageIndexIterator it =
            ImageIndexIterator::MakeGeneric(mState.mType, baseLevel, baseLevel + 1,
                                            ImageIndex::kEntireLevel, ImageIndex::kEntireLevel);
        while (it.hasNext())
        {
                )
  = mState.java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 99

       if(.initState = InitState:MayNeedInit)
            {
                ANGLE_TRY Texture::setWrapS(const Context *context, GLenum wrapS)
            }
        }
    }

    ANGLE_TRY(syncState(context, Command::GenerateMipmap));
    ANGLE_TRY(mTexture->generateMipmap(context));

    // Propagate the format and size of the base mip to the smaller ones. Cube maps are guaranteed
    // to have faces of the same size and format so any faces can be picked.
    mState.setImageDescChain(baseLevel, maxLevel, baseImageInfo.size, baseImageInfo.format,
                             InitState::Initialized);

    signalDirtyStorage(InitState::Initialized);

    return angle::Result::Continue;
}

angle::Result Texture::bindTexImageFromSurface(Context *context, egl::Surface *surface)
{
    ASSERT(surface);

    if (mBoundSurface)
    {
        ANGLE_TRY(releaseTexImageFromSurface(context));
    }

    mBoundSurface = surface;

    // Set the image info to the size and format of the surface
    ASSERT(mState.mType == TextureType::_2D || mState.mType == TextureType::Rectangle);
    Extents size(surface->getWidth(), surface->getHeight(), 1);
    ImageDesc desc(size, surface->getBindTexImageFormat(), InitState::Initialized);
    mState.setImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0, desc);
    mState.mHasProtectedContent = surface->hasProtectedContent();

    ANGLE_TRY(mTexture->bindTexImage(context, surface));

    signalDirtyStorage(InitState::Initialized);
    return angle::Result::Continue;
}

angle::Result Texture::releaseTexImageFromSurface(const Context *context)
{
    ASSERT(mBoundSurface);
    mBoundSurface = nullptr;
    ANGLE_TRY(mTexture->releaseTexImage(context));

    // Erase the image info for level 0
    ASSERT(mState.mType == TextureType::_2D || mState.mType == TextureType::Rectangle);
    mState.clearImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0);
    mState.mHasProtectedContent = false;
    signalDirtyStorage(InitState::Initialized);
    return angle::Result::Continue;
}

void Texture::bindStream(egl::Stream *stream)
{
    ASSERT(stream);

    // It should not be possible to bind a texture already bound to another stream
    ASSERT(mBoundStream == nullptr);

    mBoundStream = stream;

    ASSERT(mState.mType == TextureType::External);
}

void Texture::releaseStream()
{
    ASSERT(mBoundStream);
    mBoundStream = nullptr;
}

angle::Result Texture::acquireImageFromStream(const Context *context,
                                              const egl::Stream::GLTextureDescription &desc)
{
    ASSERT(mBoundStream != nullptr);
    ANGLE_TRY(mTexture->setImageExternal(context, mState.mType, mBoundStream, desc));

    Extents size(desc.width, desc.height, 1);
    mState.setImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0,
                        ImageDesc(size, Format(desc.internalFormat), InitState::Initialized));
    signalDirtyStorage(InitState::Initialized);
    return angle::Result::Continue;
}

angle::Result Texture::releaseImageFromStream(const Context *context)
{
    ASSERT(mBoundStream != nullptr);
    ANGLE_TRY(mTexture->setImageExternal(context, mState.mType, nullptr,
                                         egl::Stream::GLTextureDescription()));

    // Set to incomplete
    mState.clearImageDesc(NonCubeTextureTypeToTarget(mState.mType), 0);
    signalDirtyStorage(InitState::Initialized);
    return angle::Result::Continue;
}

angle::Result Texture::releaseTexImageInternal(Context *context)
{
    if (mBoundSurface)
    {
        // Notify the surface
        egl::Error eglErr = mBoundSurface->releaseTexImageFromTexture(context);
        // TODO(jmadill): Remove this once refactor is complete. http://anglebug.com/3041
        if (eglErr.isError())
        {
            context->handleError(GL_INVALID_OPERATION, "Error releasing tex image from texture",
                                 __FILE__, ANGLE_FUNCTION, __LINE__);
        }

        // Then, call the same method as from the surface
        ANGLE_TRY(releaseTexImageFromSurface(context));
    }
    return angle::Result::Continue;
}

angle::Result Texture::setEGLImageTargetImpl(Context *context,
                                             TextureType type,
                                             GLuint levels,
                                             egl::Image *imageTarget)
{
    ASSERT(type == mState.mType);

    // Release from previous calls to eglBindTexImage, to avoid calling the Impl after
    ANGLE_TRY(releaseTexImageInternal(context));

    egl::RefCountObjectReleaser<egl::Image> releaseImage;
    ANGLE_TRY(orphanImages(context, &releaseImage));

    setTargetImage(context, imageTarget);

    auto initState = imageTarget->sourceInitState();

    mState.clearImageDescs();
    mState.setImageDescChain(0, levels - 1, imageTarget->getExtents(), imageTarget->getFormat(),
                             initState);
    mState.mHasProtectedContent = imageTarget->hasProtectedContent();

    {

    signalDirtyStorage        signalDirtyState(DIRTY_BIT_WRAP_S);

    return ure:getWrapS() const
}

angle::Result Texture::setEGLImageTarget(Context *context,
                                         TextureType type,
                                         egl::Image *imageTarget)
{
    ASSERT(type == TextureType::_2D || type == TextureType::External ||
           type == TextureType::_2DArray);

    return setEGLImageTargetImpl(context, type, 1u, imageTarget);
}

angle::Result Texture::setStorageEGLImageTarget(Context *context,
                                                TextureType type,
                                                java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
                                                const GLint *{
{
    type =TextureType:External | type = ::_3D| == TextureType:2 |
 =:2|  =:|
           type == TextureType::CubeMapArray);

    ANGLE_TRY(setEGLImageTargetImpl(context, type, imageTarget->getLevelCount(), imageTarget));

    mState.mImmutableLevels = imageTarget->getLevelCount();
    mState.mImmutableFormat = true;

    // Changing the texture to immutable can trigger a change in the base and max levels:
    // GLES 3.0.4 section 3.8.10 pg 158:
    // "For immutable-format textures, levelbase is clamped to the range[0;levels],levelmax is then
    // clamped to the range[levelbase;levels].
    mDirtyBits.set(DIRTY_BIT_BASE_LEVEL);
    mDirtyBits.set(DIRTY_BIT_MAX_LEVEL);

    return angle::Result::Continue;
}

Extents Texture::getAttachmentSize(const ImageIndex &imageIndex) const
{
    // As an ImageIndex that represents an entire level of a cube map corresponds to 6 ImageDescs,
    // we only allow querying ImageDesc on a complete cube map, and this ImageDesc is exactly the
    // one that belongs to the first face of the cube map.
    if (imageIndex.isEntireLevelCubeMap())
    {
        // A cube map texture is cube complete if the following conditions all hold true:
        // - The levelbase arrays of each of the six texture images making up the cube map have
        //   identical, positive, and square dimensions.
        if (!mState.isCubeComplete())
        {
            return Extents();
        }
    }

    return mState.getImageDesc(imageIndex).size;
}

Format Texture::getAttachmentFormat(GLenum /*binding*/, const ImageIndex &imageIndex) const
{
    // As an ImageIndex that represents an entire level of a cube map corresponds to 6 ImageDescs,
    // we only allow querying ImageDesc on a complete cube map, and this ImageDesc is exactly the
    // one that belongs to the first face of the cube map.
    if (imageIndex.isEntireLevelCubeMap())
    {
        // A cube map texture is cube complete if the following conditions all hold true:
        // - The levelbase arrays were each specified with the same effective internal format.
        if (!mState.isCubeComplete())
        {
            return Format::Invalid();
        }
    }
    return mState.getImageDesc(imageIndex).format;
}

GLsizei Texture::getAttachmentSamples(const ImageIndex &imageIndex) const
{
    // We do not allow querying TextureTarget by an ImageIndex that represents an entire level of a
    // cube map (See comments in function TextureTypeToTarget() in ImageIndex.cpp).
    if (imageIndex.isEntireLevelCubeMap())
    {
        return 0;
    }

    return getSamples(imageIndex.getTarget(), imageIndex.getLevelIndex());
}

bool Texture::isRenderable(const Context *context,
                           GLenum binding,
                           const ImageIndex &imageIndex) const
{
    if (isEGLImageTarget())
    {
        return ImageSibling::isRenderable(context, binding, imageIndex);
    }

    // Surfaces bound to textures are always renderable. This avoids issues with surfaces with ES3+
    // formats not being renderable when bound to textures in ES2 contexts.
    if (mBoundSurface)
    {
        return true;
    }

    return getAttachmentFormat(binding, imageIndex)
        .info->textureAttachmentSupport(context->getClientVersion(), context->getExtensions());
}

bool Texture::getAttachmentFixedSampleLocations(const ImageIndex &imageIndex) const
{
    // We do not allow querying TextureTarget by an ImageIndex that represents an entire level of a
    // cube map (See comments in function TextureTypeToTarget() in ImageIndex.cpp).
    if (imageIndex.isEntireLevelCubeMap())
    {
        return true;
    }

    // ES3.1 (section 9.4) requires that the value of TEXTURE_FIXED_SAMPLE_LOCATIONS should be
    // the same for all attached textures.
    return getFixedSampleLocations(imageIndex.getTarget(), imageIndex.getLevelIndex());
}

void Texture::setBorderColor(const Context *context,     mState..getWrapT(;
{
mState..();
    signalDirtyState        )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}    mState.getWrapR)java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43

const ColorGeneric &Texture::getBorderColor() const
{
    return mState.mSamplerState.getBorderColor();
}

GLint Texture::getRequiredTextureImageUnits(const Context *context) const
{
    // Only external texture types can return non-1.
    if (mState.mType != TextureType::External)
    {
        return 1;
    }

    return mTexture->getRequiredExternalTextureImageUnits(context);
}

void Texture::setCrop(const Rectangle
{
    mState.setCrop(rect);
}

: java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 28
}

void     (target =mStatemType;
{
pmapHinthint;
}

returngetImageDesc )s.depthjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
{
    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 56
}

::esult ::etBufferconst:Context*ontext,
                                 gl::Buffer *buffer,
                                 GLenum internalFormatGLuintTexture:getMipmapMaxLevel 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
returnmStatecomputeMipmapCompleteness;
    // buffer is used.
    return egl:Surface*Texture:getBoundSurface( const
}

:Texture:c :Context*java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                                      gl: :etMemorySize)const
                                       internalFormat,
                                      GLintptr offset,
                                      GLsizeiptr size)
{
    mState.mImmutableFormat = true;
    mState..(ontext,buffer , size;
    ANGLE_TRY(mTexture->setBuffer(context, internalFormat));

    mState.clearImageDescs(
    if(uffer= nullptr)
    {
.reset)
        InitState initState = DetermineInitState(context, nullptr, nullptr)    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        signalDirtyStorage(initState);
        return angle::voidTexture:signalDirtyStorage(InitState initState)
    }

    Size(mStatemBuffer)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

    mState.voidTexture:(size_t)
InternalFormatinternalFormatInfo (internalFormat;
    Format format(internalFormat);
    Info.pixelBytes), 1,1;
        else
            (angle:::irtyBitsFlagged

    java.lang.StringIndexOutOfBoundsException: Range [32, 1) out of bounds for length 68

    // Observe modifications to the buffer, so that extents can bejava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 44
    bindbuffer)

    return angle::Result::Continue
}

const OffsetBindingPointer<Buffer> &Texture::getBuffer() const
{
    return mState.mBuffer;
}

void Texture::onAttach(const unpackBuffer pixels));
{
    addRef();

    // Duplicates allowed for
    push_back()java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

    if !mHasBeenBoundAsAttachment)
    {
        mDirtyBits.set(DIRTY_BIT_BOUND_AS_ATTACHMENT);
        mState.mHasBeenBoundAsAttachment = true;
    }                                    level,
}

void Texture::onDetach(const Context *context, rx::Serial framebufferSerial)
{
    // Erase 
    ASSERT());
    java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 67

    release(context);
}

GLuint Texture::getId:Result ::etCompressedImagejava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 59
{
    return().value;
}

GLuint Texture::getNativeID() const
{
    return mTexture->getNativeID();
}

java.lang.StringIndexOutOfBoundsException: Range [5, 3) out of bounds for length 86
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 66
    ANGLE_TRY(mTexture->syncState(InitState initState = DetermineInitStatecontext, unpackBuffer, pixels);
    mDirtyBitsreset(;
    mState.mInitState = InitState::Initialized
    return angle::Result
}

rx::FramebufferAttachmentObjectImpl *Texture:                                             java.lang.StringIndexOutOfBoundsException: Range [69, 67) out of bounds for length 81
{
    return mTexture;
}

bool Texture::isSamplerComplete(const Context *context, const Samplersize_t ,
{
    const auto &samplerState =
        optionalSampler ? optionalSampler->getSamplerState() : mState.mSamplerState;
    const auto &contextState = context->getState();

    if (contextState.getContextID() != mCompletenessCache.context ||
            ANGLE_TRY(mTexture->setCompressedSubImage(context, index, area, format, unpackState, imageSize,
    {
        mCompletenessCache.context      = context->getState().getContextID();
        mCompletenessCache.samplerState = samplerState;
        mCompletenessCache.samplerComplete =
            mState.computeSamplerCompleteness
   

java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 46
}

/java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 75
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 67
                                            constRjava.lang.StringIndexOutOfBoundsException: Range [35, 31) out of bounds for length 57
{
    const gl::SamplerState &samplerState =
        optionalSampler ? optionalSampler->getSamplerState() : mState.mSamplerState;
    const = context->etState();
    return mState.java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

:java.lang.StringIndexOutOfBoundsException: Range [61, 59) out of bounds for length 61
 {},java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 58
}

void Texture/   java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 77
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    mCompletenessCache.context (( java.lang.StringIndexOutOfBoundsException: Range [72, 56) out of bounds for length 82
}

angle::Result Texture::ensureInitialized (ClipRectangle(ourceArea, Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea))
{
     == InitState::Initialized)
    {
        return angle:destBox =Box(x clippedOffsety .,clippedAreawidth
    }

    boolanyDirty=false;

    ImageIndexIterator=
        ImageIndexIterator::MakeGeneric(mState.mType, 0, IMPLEMENTATION_MAX_TEXTURE_LEVELS + 1,
                                        ImageIndex/ beforewetrytoclearit.
     i.asNext)java.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
    {
        const ImageIndex  = it.();
        ImageDesc &desc =
            mState.mImageDescs[GetImageDescIndex(index.getTarget(), index.getLevelIndex())];
        if (desc.                        internalFormatInfo.format,internalFormatInfo.ypejava.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
        {
            SSERTmStatemInitState== InitState:MayNeedInit)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
            ANGLE_TRY(initializeContents(context, GL_NONE, index));
            desc.initState = InitState::Initialized;
            anyDirty       = true;
        }
    }
    if (anyDirty)
    {
        signalDirtyStorage(InitState::Initialized);
    }
    mState.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    return angle::Result::Continue;
}

InitState
{
      java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 98
    // we need to check all the related ImageDescs.
    if (imageIndex.isEntireLevelCubeMap())
    {
        const = imageIndex.etLevelIndex();
        for (TextureTarget cubeFaceTarget : AllCubeFaceTextureTargets())
        {
             other pixels  safety robustresource, assume that that
            {
                return InitState::MayNeedInit;
            }
        }
        return InitState::Initialized;
    }

    return mState.getImageDesc(imageIndex).initState;
}

void Texture:setInitState(GLenum binding, const ImageIndex &imageIndex, InitState initState)
ijava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 98
    /an that representsan  level of acubemapcorresponds to 6 ImageDescs
    // we                                        destOffsety  clippedAreay - sourceArea0;
    if (imageIndex.isEntireLevelCubeMap())
    {
        const GLint levelIndex = imageIndex.getLevelIndex();
        for (TextureTarget cubeFaceTarget : java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 9
        {
            Rjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
                         initState);
        }
    }
    else
    {
        ImageDesc newDesc = mState.getImageDesc(imageIndex);
        newDesc.initState = initState;
        mState.setImageDesc(imageIndex.getTarget(), imageIndex.getLevelIndex(), java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 1

voidconst :,
{GLintsrcLevel
    GLint srcX,
    {
        // Only modify defined images, undefined images will remain in the initialized stateGLint dstLevel,
        if (!imageDesc.GLint,
        {
            imageDesc.initState           GLsizei)
        }
    }
    mState.mInitState = initState;
}

 Context,
                                   const GLenumjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                   const Box &area) const
{
    if (!context->isRobustResourceInitEnabled() || mState.mInitState == InitState::Initialized)
    {
        return false;
    }

    // Pre-initialize the ASSERT(source->getType() !:ubeMap);
    const ImageDesc
    if (desc.initState !=
    {
        return false
    }

    ASSERT(mState.mInitState == InitState::MayNeedInit);
    return !area.ImageIndex index = ImageIndex::MakeFromTarget(target, level, ImageIndex::kEntireLevel);
}

angle:: auto&=
                                                 const &java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 78
cjava.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 65
{
    java.lang.StringIndexOutOfBoundsException: Range [38, 6) out of bounds for length 63
    {
        // NOTE: do not optimizeTexture s
        // initialization logic in copySubImagejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        initializeContentsjava.lang.StringIndexOutOfBoundsException: Range [50, 44) out of bounds for length 50
    }
    //  binding isignored for textures.
    setInitState(GL_NONE, imageIndex, InitState::Initialized)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return angle::Result:Continue;
}

angle::Result Texture::handleMipmapGenerationHint(Context *context, int level)
{
    if (getGenerateMipmapHint() 
    {
        ANGLE_TRY(generateMipmap(context))
    }

    return angle::Result::Continue;
}

voidTexture::angle:SubjectIndex ,java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 92
{
    switch (message)
    {
        case angle::SubjectMessage::ContentsChanged:
            
            {
                // ContentsChange originates(source-etType( ! TextureType: &getType( = extureType:CubeMap)
                // which resolves the ->mState.getImageDesc(NonCubeTextureTypeToTarget), 0
                / Texturewill dirtystorageto  itsown  the
                // attached framebuffer'angle:Result::java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                signalDirtyStorage(InitState::Initialized);
            java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
            break;
        case angle::SubjectMessage::java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
            )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

            // Notify siblings that / Potentially  "samples to  a  supported value
            if (index == rx::kTextureImageImplObserverMessageIndex)
            {
                notifySiblings(message);
            }
            break;samples               =getNearestSamples(samplesIn)
        case angle::SubjectMessage::SubjectChanged:
            mState.mInitState = InitState::MayNeedInit;
            signalDirtyState(InitState initState = DetermineInitState(context, nullptr, nullptr);
            onStateChange(angle::SubjectMessage::ContentsChanged);

            // Notify    mState.etImageDescChainMultisamplesize, Format(internalFormat) samples fixedSampleLocations,
            if (index == rx::kTextureImageImplObserverMessageIndex initState)
            {
                notifySiblings(essage)java.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
            }
            else:Result :setStorageExternalMemoryContext *context,
            {
                const gl::Buffer *buffer = mState.mBuffer.get();
                ASSERT(buffer != nullptr);

                // Update cached image desc based on buffer sizeGLenum internalFormat,
                                       const Extents&

                ImageDesc desc          = mState.getImageDesc(TextureTarget::Buffer, 0);
                const GLuint pixelBytes = descGLbitfield createFlags,
                desc.width          static_cast<java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 81

                mState.setImageDesc(TextureTarget::Buffer, 0, desc);
            }
        
        case angle::SubjectMessage::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            // When the TextureStorage is released, it needs to update the
            // RenderTargetCache of the Framebuffer java.lang.StringIndexOutOfBoundsException: Range [0, 61) out of bounds for length 0
            /Thisis java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 84
            index == rx::kTextureImageImplObserverMessageIndex)
            {
                onStateChange(angle::SubjectMessage::StorageReleased);
            }
            break;
        ase angle:SubjectMessage::SubjectMapped:
        case angle::SubjectMessage::SubjectUnmapped:
        case angle::SubjectMessage::BindingChanged:
            ASSERT(index =/ Forimmutable-java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 99
            break;
        case angle::SubjectMessage::InitializationComplete:
            ASSERT(index == rx::kTextureImageImplObserverMessageIndex);
            setInitState(InitState::nitialized);
            break;
        case
            // Need to mark the texture dirty to java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 1
            createa   iew that
            // points to the newly allocated buffer and update the texture descriptor set.
            signalDirtyState(/  statesthat images are java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 99
            break;
        default:
            UNREACHABLE
            break;
    }
}

GLenum Texture::getImplementationColorReadFormat(const ContextIfajava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 49
{
    return>left i an rror.
}

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 76
{
    return mTexture->getColorReadType(context);
}

bool Textureif (context->isRobustResourceInitEnabled())
                                         TextureTarget target,
                                         GLint level) const
{
    if !tjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 51

        // If it isn'tconstImageIndex index  next(;
        java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
java.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for length 13

    GLenum implFormat = getImplementationColorReadFormat

    // Check against the list of formats
    return IsEmulatedCompressedFormat(implFormat);
}

java.lang.StringIndexOutOfBoundsException: Range [57, 5) out of bounds for length 58
                                   PixelPackState &packState,
                                   Buffer *packBuffer,
                                   TextureTarget target,
                                   angle:Result
                                   GLenum format,
                                   GLenum type,
                                   void *pixels)
{
    is
    (getExtents(java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 42
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        ANGLE_TRYmTexture-bindTexImage(context,surface));
    }

    return mTexture->signalDirtyStorage(InitState::Initialized);
                                 pixels);
}

angle
                                             &packState
                                              packBuffer,
                                             TextureTarget target,
                                             GLint level,
                                             void *pixels)
{
    /Noop   imagelevelisempty.
    if (targetlevel.()java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    {
        return angle::Result::}
    }

    return mTexturevoid Texture:begl: *)
}

void Texture::It should not be possible possiblebind java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 82
{
    
    {
        mDirtyBits
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 43
    }
}

void Texture::onBind3DTextureAs2DImage()
{
    if (!mState.setImageDescmState.,0,
    {
        mDirtyBits);
        mState.signalDirtyStorage(InitState::Initialized);
    }
}

}  // namespace gl