The Tor Browser: gfx/angle/src/libGLESv2/renderer/Image9.cpp@129ffea94266

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 #include "precompiled.h"

     2 //

     3 // Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.

     4 // Use of this source code is governed by a BSD-style license that can be

     5 // found in the LICENSE file.

     6 //

     8 // Image9.cpp: Implements the rx::Image9 class, which acts as the interface to

     9 // the actual underlying surfaces of a Texture.

    11 #include "libGLESv2/renderer/Image9.h"

    13 #include "libGLESv2/main.h"

    14 #include "libGLESv2/Framebuffer.h"

    15 #include "libGLESv2/Renderbuffer.h"

    16 #include "libGLESv2/renderer/Renderer9.h"

    17 #include "libGLESv2/renderer/RenderTarget9.h"

    18 #include "libGLESv2/renderer/TextureStorage9.h"

    20 #include "libGLESv2/renderer/renderer9_utils.h"

    21 #include "libGLESv2/renderer/generatemip.h"

    23 namespace rx

    24 {

    26 Image9::Image9()

    27 {

    28     mSurface = NULL;

    29     mRenderer = NULL;

    31     mD3DPool = D3DPOOL_SYSTEMMEM;

    32     mD3DFormat = D3DFMT_UNKNOWN;

    33 }

    35 Image9::~Image9()

    36 {

    37     if (mSurface)

    38     {

    39         mSurface->Release();

    40     }

    41 }

    43 void Image9::generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9 *sourceSurface)

    44 {

    45     D3DSURFACE_DESC destDesc;

    46     HRESULT result = destSurface->GetDesc(&destDesc);

    47     ASSERT(SUCCEEDED(result));

    49     D3DSURFACE_DESC sourceDesc;

    50     result = sourceSurface->GetDesc(&sourceDesc);

    51     ASSERT(SUCCEEDED(result));

    53     ASSERT(sourceDesc.Format == destDesc.Format);

    54     ASSERT(sourceDesc.Width == 1 || sourceDesc.Width / 2 == destDesc.Width);

    55     ASSERT(sourceDesc.Height == 1 || sourceDesc.Height / 2 == destDesc.Height);

    57     D3DLOCKED_RECT sourceLocked = {0};

    58     result = sourceSurface->LockRect(&sourceLocked, NULL, D3DLOCK_READONLY);

    59     ASSERT(SUCCEEDED(result));

    61     D3DLOCKED_RECT destLocked = {0};

    62     result = destSurface->LockRect(&destLocked, NULL, 0);

    63     ASSERT(SUCCEEDED(result));

    65     const unsigned char *sourceData = reinterpret_cast<const unsigned char*>(sourceLocked.pBits);

    66     unsigned char *destData = reinterpret_cast<unsigned char*>(destLocked.pBits);

    68     if (sourceData && destData)

    69     {

    70         switch (sourceDesc.Format)

    71         {

    72           case D3DFMT_L8:

    73             GenerateMip<L8>(sourceDesc.Width, sourceDesc.Height, sourceData, sourceLocked.Pitch, destData, destLocked.Pitch);

    74             break;

    75           case D3DFMT_A8L8:

    76             GenerateMip<A8L8>(sourceDesc.Width, sourceDesc.Height, sourceData, sourceLocked.Pitch, destData, destLocked.Pitch);

    77             break;

    78           case D3DFMT_A8R8G8B8:

    79           case D3DFMT_X8R8G8B8:

    80             GenerateMip<A8R8G8B8>(sourceDesc.Width, sourceDesc.Height, sourceData, sourceLocked.Pitch, destData, destLocked.Pitch);

    81             break;

    82           case D3DFMT_A16B16G16R16F:

    83             GenerateMip<A16B16G16R16F>(sourceDesc.Width, sourceDesc.Height, sourceData, sourceLocked.Pitch, destData, destLocked.Pitch);

    84             break;

    85           case D3DFMT_A32B32G32R32F:

    86             GenerateMip<A32B32G32R32F>(sourceDesc.Width, sourceDesc.Height, sourceData, sourceLocked.Pitch, destData, destLocked.Pitch);

    87             break;

    88           default:

    89             UNREACHABLE();

    90             break;

    91         }

    93         destSurface->UnlockRect();

    94         sourceSurface->UnlockRect();

    95     }

    96 }

    98 Image9 *Image9::makeImage9(Image *img)

    99 {

   100     ASSERT(HAS_DYNAMIC_TYPE(rx::Image9*, img));

   101     return static_cast<rx::Image9*>(img);

   102 }

   104 void Image9::generateMipmap(Image9 *dest, Image9 *source)

   105 {

   106     IDirect3DSurface9 *sourceSurface = source->getSurface();

   107     if (sourceSurface == NULL)

   108         return gl::error(GL_OUT_OF_MEMORY);

   110     IDirect3DSurface9 *destSurface = dest->getSurface();

   111     generateMip(destSurface, sourceSurface);

   113     dest->markDirty();

   114 }

   116 void Image9::copyLockableSurfaces(IDirect3DSurface9 *dest, IDirect3DSurface9 *source)

   117 {

   118     D3DLOCKED_RECT sourceLock = {0};

   119     D3DLOCKED_RECT destLock = {0};

   121     source->LockRect(&sourceLock, NULL, 0);

   122     dest->LockRect(&destLock, NULL, 0);

   124     if (sourceLock.pBits && destLock.pBits)

   125     {

   126         D3DSURFACE_DESC desc;

   127         source->GetDesc(&desc);

   129         int rows = d3d9::IsCompressedFormat(desc.Format) ? desc.Height / 4 : desc.Height;

   130         int bytes = d3d9::ComputeRowSize(desc.Format, desc.Width);

   131         ASSERT(bytes <= sourceLock.Pitch && bytes <= destLock.Pitch);

   133         for(int i = 0; i < rows; i++)

   134         {

   135             memcpy((char*)destLock.pBits + destLock.Pitch * i, (char*)sourceLock.pBits + sourceLock.Pitch * i, bytes);

   136         }

   138         source->UnlockRect();

   139         dest->UnlockRect();

   140     }

   141     else UNREACHABLE();

   142 }

   144 bool Image9::redefine(rx::Renderer *renderer, GLint internalformat, GLsizei width, GLsizei height, bool forceRelease)

   145 {

   146     if (mWidth != width ||

   147         mHeight != height ||

   148         mInternalFormat != internalformat ||

   149         forceRelease)

   150     {

   151         mRenderer = Renderer9::makeRenderer9(renderer);

   153         mWidth = width;

   154         mHeight = height;

   155         mInternalFormat = internalformat;

   156         // compute the d3d format that will be used

   157         mD3DFormat = mRenderer->ConvertTextureInternalFormat(internalformat);

   158         mActualFormat = d3d9_gl::GetEquivalentFormat(mD3DFormat);

   160         if (mSurface)

   161         {

   162             mSurface->Release();

   163             mSurface = NULL;

   164         }

   166         return true;

   167     }

   169     return false;

   170 }

   172 void Image9::createSurface()

   173 {

   174     if(mSurface)

   175     {

   176         return;

   177     }

   179     IDirect3DTexture9 *newTexture = NULL;

   180     IDirect3DSurface9 *newSurface = NULL;

   181     const D3DPOOL poolToUse = D3DPOOL_SYSTEMMEM;

   182     const D3DFORMAT d3dFormat = getD3DFormat();

   183     ASSERT(d3dFormat != D3DFMT_INTZ); // We should never get here for depth textures

   185     if (mWidth != 0 && mHeight != 0)

   186     {

   187         int levelToFetch = 0;

   188         GLsizei requestWidth = mWidth;

   189         GLsizei requestHeight = mHeight;

   190         gl::MakeValidSize(true, gl::IsCompressed(mInternalFormat), &requestWidth, &requestHeight, &levelToFetch);

   192         IDirect3DDevice9 *device = mRenderer->getDevice();

   194         HRESULT result = device->CreateTexture(requestWidth, requestHeight, levelToFetch + 1, 0, d3dFormat,

   195                                                     poolToUse, &newTexture, NULL);

   197         if (FAILED(result))

   198         {

   199             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);

   200             ERR("Creating image surface failed.");

   201             return gl::error(GL_OUT_OF_MEMORY);

   202         }

   204         newTexture->GetSurfaceLevel(levelToFetch, &newSurface);

   205         newTexture->Release();

   206     }

   208     mSurface = newSurface;

   209     mDirty = false;

   210     mD3DPool = poolToUse;

   211 }

   213 HRESULT Image9::lock(D3DLOCKED_RECT *lockedRect, const RECT *rect)

   214 {

   215     createSurface();

   217     HRESULT result = D3DERR_INVALIDCALL;

   219     if (mSurface)

   220     {

   221         result = mSurface->LockRect(lockedRect, rect, 0);

   222         ASSERT(SUCCEEDED(result));

   224         mDirty = true;

   225     }

   227     return result;

   228 }

   230 void Image9::unlock()

   231 {

   232     if (mSurface)

   233     {

   234         HRESULT result = mSurface->UnlockRect();

   235         ASSERT(SUCCEEDED(result));

   236     }

   237 }

   239 bool Image9::isRenderableFormat() const

   240 {

   241     return TextureStorage9::IsTextureFormatRenderable(getD3DFormat());

   242 }

   244 D3DFORMAT Image9::getD3DFormat() const

   245 {

   246     // this should only happen if the image hasn't been redefined first

   247     // which would be a bug by the caller

   248     ASSERT(mD3DFormat != D3DFMT_UNKNOWN);

   250     return mD3DFormat;

   251 }

   253 IDirect3DSurface9 *Image9::getSurface()

   254 {

   255     createSurface();

   257     return mSurface;

   258 }

   260 void Image9::setManagedSurface(TextureStorageInterface2D *storage, int level)

   261 {

   262     TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage->getStorageInstance());

   263     setManagedSurface(storage9->getSurfaceLevel(level, false));

   264 }

   266 void Image9::setManagedSurface(TextureStorageInterfaceCube *storage, int face, int level)

   267 {

   268     TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage->getStorageInstance());

   269     setManagedSurface(storage9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, false));

   270 }

   272 void Image9::setManagedSurface(IDirect3DSurface9 *surface)

   273 {

   274     D3DSURFACE_DESC desc;

   275     surface->GetDesc(&desc);

   276     ASSERT(desc.Pool == D3DPOOL_MANAGED);

   278     if ((GLsizei)desc.Width == mWidth && (GLsizei)desc.Height == mHeight)

   279     {

   280         if (mSurface)

   281         {

   282             copyLockableSurfaces(surface, mSurface);

   283             mSurface->Release();

   284         }

   286         mSurface = surface;

   287         mD3DPool = desc.Pool;

   288     }

   289 }

   291 bool Image9::updateSurface(TextureStorageInterface2D *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)

   292 {

   293     ASSERT(getSurface() != NULL);

   294     TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage->getStorageInstance());

   295     return updateSurface(storage9->getSurfaceLevel(level, true), xoffset, yoffset, width, height);

   296 }

   298 bool Image9::updateSurface(TextureStorageInterfaceCube *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)

   299 {

   300     ASSERT(getSurface() != NULL);

   301     TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage->getStorageInstance());

   302     return updateSurface(storage9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, true), xoffset, yoffset, width, height);

   303 }

   305 bool Image9::updateSurface(IDirect3DSurface9 *destSurface, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)

   306 {

   307     if (!destSurface)

   308         return false;

   310     IDirect3DSurface9 *sourceSurface = getSurface();

   312     if (sourceSurface && sourceSurface != destSurface)

   313     {

   314         RECT rect;

   315         rect.left = xoffset;

   316         rect.top = yoffset;

   317         rect.right = xoffset + width;

   318         rect.bottom = yoffset + height;

   320         POINT point = {rect.left, rect.top};

   322         IDirect3DDevice9 *device = mRenderer->getDevice();

   324         if (mD3DPool == D3DPOOL_MANAGED)

   325         {

   326             D3DSURFACE_DESC desc;

   327             sourceSurface->GetDesc(&desc);

   329             IDirect3DSurface9 *surf = 0;

   330             HRESULT result = device->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &surf, NULL);

   332             if (SUCCEEDED(result))

   333             {

   334                 copyLockableSurfaces(surf, sourceSurface);

   335                 result = device->UpdateSurface(surf, &rect, destSurface, &point);

   336                 ASSERT(SUCCEEDED(result));

   337                 surf->Release();

   338             }

   339         }

   340         else

   341         {

   342             // UpdateSurface: source must be SYSTEMMEM, dest must be DEFAULT pools

   343             HRESULT result = device->UpdateSurface(sourceSurface, &rect, destSurface, &point);

   344             ASSERT(SUCCEEDED(result));

   345         }

   346     }

   348     destSurface->Release();

   349     return true;

   350 }

   352 // Store the pixel rectangle designated by xoffset,yoffset,width,height with pixels stored as format/type at input

   353 // into the target pixel rectangle.

   354 void Image9::loadData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,

   355                       GLint unpackAlignment, const void *input)

   356 {

   357     RECT lockRect =

   358     {

   359         xoffset, yoffset,

   360         xoffset + width, yoffset + height

   361     };

   363     D3DLOCKED_RECT locked;

   364     HRESULT result = lock(&locked, &lockRect);

   365     if (FAILED(result))

   366     {

   367         return;

   368     }

   371     GLsizei inputPitch = gl::ComputePitch(width, mInternalFormat, unpackAlignment);

   373     switch (mInternalFormat)

   374     {

   375       case GL_ALPHA8_EXT:

   376         if (gl::supportsSSE2())

   377         {

   378             loadAlphaDataToBGRASSE2(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   379         }

   380         else

   381         {

   382             loadAlphaDataToBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   383         }

   384         break;

   385       case GL_LUMINANCE8_EXT:

   386         loadLuminanceDataToNativeOrBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits, getD3DFormat() == D3DFMT_L8);

   387         break;

   388       case GL_ALPHA32F_EXT:

   389         loadAlphaFloatDataToRGBA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   390         break;

   391       case GL_LUMINANCE32F_EXT:

   392         loadLuminanceFloatDataToRGBA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   393         break;

   394       case GL_ALPHA16F_EXT:

   395         loadAlphaHalfFloatDataToRGBA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   396         break;

   397       case GL_LUMINANCE16F_EXT:

   398         loadLuminanceHalfFloatDataToRGBA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   399         break;

   400       case GL_LUMINANCE8_ALPHA8_EXT:

   401         loadLuminanceAlphaDataToNativeOrBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits, getD3DFormat() == D3DFMT_A8L8);

   402         break;

   403       case GL_LUMINANCE_ALPHA32F_EXT:

   404         loadLuminanceAlphaFloatDataToRGBA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   405         break;

   406       case GL_LUMINANCE_ALPHA16F_EXT:

   407         loadLuminanceAlphaHalfFloatDataToRGBA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   408         break;

   409       case GL_RGB8_OES:

   410         loadRGBUByteDataToBGRX(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   411         break;

   412       case GL_RGB565:

   413         loadRGB565DataToBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   414         break;

   415       case GL_RGBA8_OES:

   416         if (gl::supportsSSE2())

   417         {

   418             loadRGBAUByteDataToBGRASSE2(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   419         }

   420         else

   421         {

   422             loadRGBAUByteDataToBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   423         }

   424         break;

   425       case GL_RGBA4:

   426         loadRGBA4444DataToBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   427         break;

   428       case GL_RGB5_A1:

   429         loadRGBA5551DataToBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   430         break;

   431       case GL_BGRA8_EXT:

   432         loadBGRADataToBGRA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   433         break;

   434       // float textures are converted to RGBA, not BGRA, as they're stored that way in D3D

   435       case GL_RGB32F_EXT:

   436         loadRGBFloatDataToRGBA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   437         break;

   438       case GL_RGB16F_EXT:

   439         loadRGBHalfFloatDataToRGBA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   440         break;

   441       case GL_RGBA32F_EXT:

   442         loadRGBAFloatDataToRGBA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   443         break;

   444       case GL_RGBA16F_EXT:

   445         loadRGBAHalfFloatDataToRGBA(width, height, inputPitch, input, locked.Pitch, locked.pBits);

   446         break;

   447       default: UNREACHABLE();

   448     }

   450     unlock();

   451 }

   453 void Image9::loadCompressedData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,

   454                                 const void *input)

   455 {

   456     ASSERT(xoffset % 4 == 0);

   457     ASSERT(yoffset % 4 == 0);

   459     RECT lockRect = {

   460         xoffset, yoffset,

   461         xoffset + width, yoffset + height

   462     };

   464     D3DLOCKED_RECT locked;

   465     HRESULT result = lock(&locked, &lockRect);

   466     if (FAILED(result))

   467     {

   468         return;

   469     }

   471     GLsizei inputSize = gl::ComputeCompressedSize(width, height, mInternalFormat);

   472     GLsizei inputPitch = gl::ComputeCompressedPitch(width, mInternalFormat);

   473     int rows = inputSize / inputPitch;

   474     for (int i = 0; i < rows; ++i)

   475     {

   476         memcpy((void*)((BYTE*)locked.pBits + i * locked.Pitch), (void*)((BYTE*)input + i * inputPitch), inputPitch);

   477     }

   479     unlock();

   480 }

   482 // This implements glCopyTex[Sub]Image2D for non-renderable internal texture formats and incomplete textures

   483 void Image9::copy(GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)

   484 {

   485     RenderTarget9 *renderTarget = NULL;

   486     IDirect3DSurface9 *surface = NULL;

   487     gl::Renderbuffer *colorbuffer = source->getColorbuffer(0);

   489     if (colorbuffer)

   490     {

   491         renderTarget = RenderTarget9::makeRenderTarget9(colorbuffer->getRenderTarget());

   492     }

   494     if (renderTarget)

   495     {

   496         surface = renderTarget->getSurface();

   497     }

   499     if (!surface)

   500     {

   501         ERR("Failed to retrieve the render target.");

   502         return gl::error(GL_OUT_OF_MEMORY);

   503     }

   505     IDirect3DDevice9 *device = mRenderer->getDevice();

   507     IDirect3DSurface9 *renderTargetData = NULL;

   508     D3DSURFACE_DESC description;

   509     surface->GetDesc(&description);

   511     HRESULT result = device->CreateOffscreenPlainSurface(description.Width, description.Height, description.Format, D3DPOOL_SYSTEMMEM, &renderTargetData, NULL);

   513     if (FAILED(result))

   514     {

   515         ERR("Could not create matching destination surface.");

   516         surface->Release();

   517         return gl::error(GL_OUT_OF_MEMORY);

   518     }

   520     result = device->GetRenderTargetData(surface, renderTargetData);

   522     if (FAILED(result))

   523     {

   524         ERR("GetRenderTargetData unexpectedly failed.");

   525         renderTargetData->Release();

   526         surface->Release();

   527         return gl::error(GL_OUT_OF_MEMORY);

   528     }

   530     RECT sourceRect = {x, y, x + width, y + height};

   531     RECT destRect = {xoffset, yoffset, xoffset + width, yoffset + height};

   533     D3DLOCKED_RECT sourceLock = {0};

   534     result = renderTargetData->LockRect(&sourceLock, &sourceRect, 0);

   536     if (FAILED(result))

   537     {

   538         ERR("Failed to lock the source surface (rectangle might be invalid).");

   539         renderTargetData->Release();

   540         surface->Release();

   541         return gl::error(GL_OUT_OF_MEMORY);

   542     }

   544     D3DLOCKED_RECT destLock = {0};

   545     result = lock(&destLock, &destRect);

   547     if (FAILED(result))

   548     {

   549         ERR("Failed to lock the destination surface (rectangle might be invalid).");

   550         renderTargetData->UnlockRect();

   551         renderTargetData->Release();

   552         surface->Release();

   553         return gl::error(GL_OUT_OF_MEMORY);

   554     }

   556     if (destLock.pBits && sourceLock.pBits)

   557     {

   558         unsigned char *source = (unsigned char*)sourceLock.pBits;

   559         unsigned char *dest = (unsigned char*)destLock.pBits;

   561         switch (description.Format)

   562         {

   563           case D3DFMT_X8R8G8B8:

   564           case D3DFMT_A8R8G8B8:

   565             switch(getD3DFormat())

   566             {

   567               case D3DFMT_X8R8G8B8:

   568               case D3DFMT_A8R8G8B8:

   569                 for(int y = 0; y < height; y++)

   570                 {

   571                     memcpy(dest, source, 4 * width);

   573                     source += sourceLock.Pitch;

   574                     dest += destLock.Pitch;

   575                 }

   576                 break;

   577               case D3DFMT_L8:

   578                 for(int y = 0; y < height; y++)

   579                 {

   580                     for(int x = 0; x < width; x++)

   581                     {

   582                         dest[x] = source[x * 4 + 2];

   583                     }

   585                     source += sourceLock.Pitch;

   586                     dest += destLock.Pitch;

   587                 }

   588                 break;

   589               case D3DFMT_A8L8:

   590                 for(int y = 0; y < height; y++)

   591                 {

   592                     for(int x = 0; x < width; x++)

   593                     {

   594                         dest[x * 2 + 0] = source[x * 4 + 2];

   595                         dest[x * 2 + 1] = source[x * 4 + 3];

   596                     }

   598                     source += sourceLock.Pitch;

   599                     dest += destLock.Pitch;

   600                 }

   601                 break;

   602               default:

   603                 UNREACHABLE();

   604             }

   605             break;

   606           case D3DFMT_R5G6B5:

   607             switch(getD3DFormat())

   608             {

   609               case D3DFMT_X8R8G8B8:

   610                 for(int y = 0; y < height; y++)

   611                 {

   612                     for(int x = 0; x < width; x++)

   613                     {

   614                         unsigned short rgb = ((unsigned short*)source)[x];

   615                         unsigned char red = (rgb & 0xF800) >> 8;

   616                         unsigned char green = (rgb & 0x07E0) >> 3;

   617                         unsigned char blue = (rgb & 0x001F) << 3;

   618                         dest[x + 0] = blue | (blue >> 5);

   619                         dest[x + 1] = green | (green >> 6);

   620                         dest[x + 2] = red | (red >> 5);

   621                         dest[x + 3] = 0xFF;

   622                     }

   624                     source += sourceLock.Pitch;

   625                     dest += destLock.Pitch;

   626                 }

   627                 break;

   628               case D3DFMT_L8:

   629                 for(int y = 0; y < height; y++)

   630                 {

   631                     for(int x = 0; x < width; x++)

   632                     {

   633                         unsigned char red = source[x * 2 + 1] & 0xF8;

   634                         dest[x] = red | (red >> 5);

   635                     }

   637                     source += sourceLock.Pitch;

   638                     dest += destLock.Pitch;

   639                 }

   640                 break;

   641               default:

   642                 UNREACHABLE();

   643             }

   644             break;

   645           case D3DFMT_A1R5G5B5:

   646             switch(getD3DFormat())

   647             {

   648               case D3DFMT_X8R8G8B8:

   649                 for(int y = 0; y < height; y++)

   650                 {

   651                     for(int x = 0; x < width; x++)

   652                     {

   653                         unsigned short argb = ((unsigned short*)source)[x];

   654                         unsigned char red = (argb & 0x7C00) >> 7;

   655                         unsigned char green = (argb & 0x03E0) >> 2;

   656                         unsigned char blue = (argb & 0x001F) << 3;

   657                         dest[x + 0] = blue | (blue >> 5);

   658                         dest[x + 1] = green | (green >> 5);

   659                         dest[x + 2] = red | (red >> 5);

   660                         dest[x + 3] = 0xFF;

   661                     }

   663                     source += sourceLock.Pitch;

   664                     dest += destLock.Pitch;

   665                 }

   666                 break;

   667               case D3DFMT_A8R8G8B8:

   668                 for(int y = 0; y < height; y++)

   669                 {

   670                     for(int x = 0; x < width; x++)

   671                     {

   672                         unsigned short argb = ((unsigned short*)source)[x];

   673                         unsigned char red = (argb & 0x7C00) >> 7;

   674                         unsigned char green = (argb & 0x03E0) >> 2;

   675                         unsigned char blue = (argb & 0x001F) << 3;

   676                         unsigned char alpha = (signed short)argb >> 15;

   677                         dest[x + 0] = blue | (blue >> 5);

   678                         dest[x + 1] = green | (green >> 5);

   679                         dest[x + 2] = red | (red >> 5);

   680                         dest[x + 3] = alpha;

   681                     }

   683                     source += sourceLock.Pitch;

   684                     dest += destLock.Pitch;

   685                 }

   686                 break;

   687               case D3DFMT_L8:

   688                 for(int y = 0; y < height; y++)

   689                 {

   690                     for(int x = 0; x < width; x++)

   691                     {

   692                         unsigned char red = source[x * 2 + 1] & 0x7C;

   693                         dest[x] = (red << 1) | (red >> 4);

   694                     }

   696                     source += sourceLock.Pitch;

   697                     dest += destLock.Pitch;

   698                 }

   699                 break;

   700               case D3DFMT_A8L8:

   701                 for(int y = 0; y < height; y++)

   702                 {

   703                     for(int x = 0; x < width; x++)

   704                     {

   705                         unsigned char red = source[x * 2 + 1] & 0x7C;

   706                         dest[x * 2 + 0] = (red << 1) | (red >> 4);

   707                         dest[x * 2 + 1] = (signed char)source[x * 2 + 1] >> 7;

   708                     }

   710                     source += sourceLock.Pitch;

   711                     dest += destLock.Pitch;

   712                 }

   713                 break;

   714               default:

   715                 UNREACHABLE();

   716             }

   717             break;

   718           default:

   719             UNREACHABLE();

   720         }

   721     }

   723     unlock();

   724     renderTargetData->UnlockRect();

   726     renderTargetData->Release();

   727     surface->Release();

   729     mDirty = true;

   730 }

   732 }

The Tor Browser / file revision

gfx/angle/src/libGLESv2/renderer/Image9.cpp@129ffea94266

gfx/angle/src/libGLESv2/renderer/Image9.cpp