TextureHostOGL.h

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef MOZILLA_GFX_TEXTUREOGL_H
   7 #define MOZILLA_GFX_TEXTUREOGL_H
   8
   9 #include <stddef.h>                     // for size_t
  10 #include <stdint.h>                     // for uint64_t
  11 #include "GLContextTypes.h"             // for GLContext
  12 #include "GLDefs.h"                     // for GLenum, LOCAL_GL_CLAMP_TO_EDGE, etc
  13 #include "GLTextureImage.h"             // for TextureImage
  14 #include "gfx3DMatrix.h"                // for gfx3DMatrix
  15 #include "gfxASurface.h"                // for gfxASurface, etc
  16 #include "mozilla/GfxMessageUtils.h"    // for gfxContentType
  17 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
  18 #include "mozilla/Attributes.h"         // for MOZ_OVERRIDE
  19 #include "mozilla/RefPtr.h"             // for RefPtr
  20 #include "mozilla/gfx/Point.h"          // for IntSize, IntPoint
  21 #include "mozilla/gfx/Types.h"          // for SurfaceFormat, etc
  22 #include "mozilla/layers/CompositorTypes.h"  // for TextureFlags
  23 #include "mozilla/layers/LayersSurfaces.h"  // for SurfaceDescriptor
  24 #include "mozilla/layers/LayersTypes.h"  // for MOZ_LAYERS_HAVE_LOG
  25 #include "mozilla/layers/TextureHost.h"  // for DeprecatedTextureHost, etc
  26 #include "mozilla/mozalloc.h"           // for operator delete, etc
  27 #include "nsAutoPtr.h"                  // for nsRefPtr
  28 #include "nsCOMPtr.h"                   // for already_AddRefed
  29 #include "nsDebug.h"                    // for NS_WARNING
  30 #include "nsISupportsImpl.h"            // for TextureImage::Release, etc
  31 #include "nsTraceRefcnt.h"              // for MOZ_COUNT_CTOR, etc
  32 #include "LayerManagerOGLProgram.h"     // for ShaderProgramType, etc
  33 #ifdef MOZ_WIDGET_GONK
  34 #include <ui/GraphicBuffer.h>
  35 #endif
  36
  37 class gfxImageSurface;
  38 class gfxReusableSurfaceWrapper;
  39 class nsIntRegion;
  40 struct nsIntPoint;
  41 struct nsIntRect;
  42 struct nsIntSize;
  43
  44 namespace mozilla {
  45 namespace gfx {
  46 class DataSourceSurface;
  47 class SurfaceStream;
  48 }
  49
  50 namespace layers {
  51
  52 class Compositor;
  53 class CompositorOGL;
  54 class TextureImageDeprecatedTextureHostOGL;
  55
  56 /*
  57  * TextureHost implementations for the OpenGL backend.
  58  *
  59  * Note that it is important to be careful about the ownership model with
  60  * the OpenGL backend, due to some widget limitation on Linux: before
  61  * the nsBaseWidget associated with our OpenGL context has been completely
  62  * deleted, every resource belonging to the OpenGL context MUST have been
  63  * released. At the moment the teardown sequence happens in the middle of
  64  * the nsBaseWidget's destructor, meaning that at a given moment we must be
  65  * able to easily find and release all the GL resources.
  66  * The point is: be careful about the ownership model and limit the number
  67  * of objects sharing references to GL resources to make the tear down
  68  * sequence as simple as possible.
  69  */
  70
  71 inline ShaderProgramType
  72 GetProgramTypeForSurfaceFormat(gfx::SurfaceFormat aFormat)
  73  {
  74   switch (aFormat) {
  75   case gfx::FORMAT_B8G8R8A8:
  76     return BGRALayerProgramType;;
  77   case gfx::FORMAT_B8G8R8X8:
  78     return BGRXLayerProgramType;;
  79   case gfx::FORMAT_R8G8B8X8:
  80     return RGBXLayerProgramType;;
  81   case gfx::FORMAT_R8G8B8A8:
  82     return RGBALayerProgramType;;
  83   default:
  84     MOZ_CRASH("unhandled program type");
  85   }
  86 }
  87
  88 inline ShaderProgramType
  89 GetProgramTypeForTexture(const DeprecatedTextureHost *aDeprecatedTextureHost)
  90 {
  91   return GetProgramTypeForSurfaceFormat(aDeprecatedTextureHost->GetFormat());
  92 }
  93
  94 /**
  95  * TextureSourceOGL provides the necessary API for CompositorOGL to composite
  96  * a TextureSource.
  97  */
  98 class TextureSourceOGL
  99 {
 100 public:
 101   virtual bool IsValid() const = 0;
 102
 103   virtual void BindTexture(GLenum aTextureUnit) = 0;
 104
 105   virtual void UnbindTexture() = 0;
 106
 107   virtual gfx::IntSize GetSize() const = 0;
 108
 109   virtual GLenum GetTextureTarget() const { return LOCAL_GL_TEXTURE_2D; }
 110
 111   virtual gfx::SurfaceFormat GetFormat() const = 0;
 112
 113   virtual GLenum GetWrapMode() const = 0;
 114
 115   virtual gfx3DMatrix GetTextureTransform() { return gfx3DMatrix(); }
 116
 117   virtual TextureImageDeprecatedTextureHostOGL* AsTextureImageDeprecatedTextureHost() { return nullptr; }
 118 };
 119
 120 /**
 121  * A TextureSource backed by a TextureImage.
 122  *
 123  * Depending on the underlying TextureImage, may support texture tiling, so
 124  * make sure to check AsTileIterator() and use the texture accordingly.
 125  *
 126  * This TextureSource can be used without a TextureHost and manage it's own
 127  * GL texture(s).
 128  */
 129 class TextureImageTextureSourceOGL : public DataTextureSource
 130                                    , public TextureSourceOGL
 131                                    , public TileIterator
 132 {
 133 public:
 134   TextureImageTextureSourceOGL(gl::GLContext* aGL, bool aAllowBiImage = true)
 135     : mGL(aGL)
 136     , mAllowBigImage(aAllowBiImage)
 137     , mIterating(false)
 138   {}
 139
 140   // DataTextureSource
 141
 142   virtual bool Update(gfx::DataSourceSurface* aSurface,
 143                       TextureFlags aFlags,
 144                       nsIntRegion* aDestRegion = nullptr,
 145                       gfx::IntPoint* aSrcOffset = nullptr) MOZ_OVERRIDE;
 146
 147   // TextureSource
 148
 149   virtual void DeallocateDeviceData() MOZ_OVERRIDE
 150   {
 151     mTexImage = nullptr;
 152     SetUpdateSerial(0);
 153   }
 154
 155   virtual TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE { return this; }
 156
 157   virtual void BindTexture(GLenum aTextureUnit) MOZ_OVERRIDE;
 158
 159   virtual gfx::IntSize GetSize() const MOZ_OVERRIDE;
 160
 161   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE;
 162
 163   virtual bool IsValid() const MOZ_OVERRIDE { return !!mTexImage; }
 164
 165   virtual void UnbindTexture() MOZ_OVERRIDE
 166   {
 167     mTexImage->ReleaseTexture();
 168   }
 169
 170   virtual GLenum GetWrapMode() const MOZ_OVERRIDE
 171   {
 172     return mTexImage->GetWrapMode();
 173   }
 174
 175   // TileIterator
 176
 177   virtual TileIterator* AsTileIterator() MOZ_OVERRIDE { return this; }
 178
 179   virtual void BeginTileIteration() MOZ_OVERRIDE
 180   {
 181     mTexImage->BeginTileIteration();
 182     mIterating = true;
 183   }
 184
 185   virtual void EndTileIteration() MOZ_OVERRIDE
 186   {
 187     mIterating = false;
 188   }
 189
 190   virtual nsIntRect GetTileRect() MOZ_OVERRIDE;
 191
 192   virtual size_t GetTileCount() MOZ_OVERRIDE
 193   {
 194     return mTexImage->GetTileCount();
 195   }
 196
 197   virtual bool NextTile() MOZ_OVERRIDE
 198   {
 199     return mTexImage->NextTile();
 200   }
 201
 202 protected:
 203   nsRefPtr<gl::TextureImage> mTexImage;
 204   gl::GLContext* mGL;
 205   bool mAllowBigImage;
 206   bool mIterating;
 207 };
 208
 209 /**
 210  * A texture source meant for use with SharedTextureHostOGL.
 211  *
 212  * It does not own any GL texture, and attaches its shared handle to one of
 213  * the compositor's temporary textures when binding.
 214  *
 215  * The shared texture handle is owned by the TextureHost.
 216  */
 217 class SharedTextureSourceOGL : public NewTextureSource
 218                              , public TextureSourceOGL
 219 {
 220 public:
 221   typedef gl::SharedTextureShareType SharedTextureShareType;
 222
 223   SharedTextureSourceOGL(CompositorOGL* aCompositor,
 224                          gl::SharedTextureHandle aHandle,
 225                          gfx::SurfaceFormat aFormat,
 226                          GLenum aTarget,
 227                          GLenum aWrapMode,
 228                          SharedTextureShareType aShareType,
 229                          gfx::IntSize aSize,
 230                          const gfx3DMatrix& aTexTransform);
 231
 232   virtual TextureSourceOGL* AsSourceOGL() { return this; }
 233
 234   virtual void BindTexture(GLenum activetex) MOZ_OVERRIDE;
 235
 236   virtual bool IsValid() const MOZ_OVERRIDE;
 237
 238   virtual gfx::IntSize GetSize() const MOZ_OVERRIDE { return mSize; }
 239
 240   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE { return mFormat; }
 241
 242   virtual gfx3DMatrix GetTextureTransform() MOZ_OVERRIDE { return mTextureTransform; }
 243
 244   virtual GLenum GetTextureTarget() const { return mTextureTarget; }
 245
 246   virtual GLenum GetWrapMode() const MOZ_OVERRIDE { return mWrapMode; }
 247
 248   virtual void UnbindTexture() MOZ_OVERRIDE {}
 249
 250   // SharedTextureSource doesn't own any gl texture
 251   virtual void DeallocateDeviceData() {}
 252
 253   void DetachSharedHandle();
 254
 255   void SetCompositor(CompositorOGL* aCompositor);
 256
 257   gl::GLContext* gl() const;
 258
 259 protected:
 260   gfx3DMatrix mTextureTransform;
 261   gfx::IntSize mSize;
 262   CompositorOGL* mCompositor;
 263   gl::SharedTextureHandle mSharedHandle;
 264   gfx::SurfaceFormat mFormat;
 265   SharedTextureShareType mShareType;
 266   GLenum mTextureTarget;
 267   GLenum mWrapMode;
 268 };
 269
 270 /**
 271  * A TextureHost for shared GL Textures
 272  *
 273  * Most of the logic actually happens in SharedTextureSourceOGL.
 274  */
 275 class SharedTextureHostOGL : public TextureHost
 276 {
 277 public:
 278   SharedTextureHostOGL(uint64_t aID,
 279                        TextureFlags aFlags,
 280                        gl::SharedTextureShareType aShareType,
 281                        gl::SharedTextureHandle aSharedhandle,
 282                        gfx::IntSize aSize,
 283                        bool inverted);
 284
 285   virtual ~SharedTextureHostOGL();
 286
 287   // SharedTextureHostOGL doesn't own any GL texture
 288   virtual void DeallocateDeviceData() MOZ_OVERRIDE {}
 289
 290   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 291
 292   virtual bool Lock() MOZ_OVERRIDE;
 293
 294   virtual void Unlock() MOZ_OVERRIDE;
 295
 296   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE;
 297
 298   virtual NewTextureSource* GetTextureSources() MOZ_OVERRIDE
 299   {
 300     return mTextureSource;
 301   }
 302
 303   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE
 304   {
 305     return nullptr; // XXX - implement this (for MOZ_DUMP_PAINTING)
 306   }
 307
 308   gl::GLContext* gl() const;
 309
 310   virtual gfx::IntSize GetSize() const MOZ_OVERRIDE { return mSize; }
 311
 312 #ifdef MOZ_LAYERS_HAVE_LOG
 313   virtual const char* Name() { return "SharedTextureHostOGL"; }
 314 #endif
 315
 316 protected:
 317   gfx::IntSize mSize;
 318   CompositorOGL* mCompositor;
 319   gl::SharedTextureHandle mSharedHandle;
 320   gl::SharedTextureShareType mShareType;
 321
 322   RefPtr<SharedTextureSourceOGL> mTextureSource;
 323 };
 324
 325 /**
 326  * DeprecatedTextureHost implementation using a TextureImage as the underlying texture.
 327  */
 328 class TextureImageDeprecatedTextureHostOGL : public DeprecatedTextureHost
 329                                            , public TextureSourceOGL
 330                                            , public TileIterator
 331 {
 332 public:
 333   TextureImageDeprecatedTextureHostOGL(gl::TextureImage* aTexImage = nullptr)
 334     : mTexture(aTexImage)
 335     , mGL(nullptr)
 336     , mIterating(false)
 337   {
 338     MOZ_COUNT_CTOR(TextureImageDeprecatedTextureHostOGL);
 339   }
 340
 341   ~TextureImageDeprecatedTextureHostOGL();
 342
 343   TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE
 344   {
 345     return this;
 346   }
 347
 348   virtual TextureImageDeprecatedTextureHostOGL* AsTextureImageDeprecatedTextureHost() MOZ_OVERRIDE
 349   {
 350     return this;
 351   }
 352
 353   // This is a hack that is here to not break on-main-thread ThebesLayerBuffer
 354   // please do not use it anywhere else, use SetCompositor instead.
 355   void SetGLContext(gl::GLContext* aGL)
 356   {
 357     mGL = aGL;
 358   }
 359
 360   // DeprecatedTextureHost
 361
 362   void UpdateImpl(const SurfaceDescriptor& aImage,
 363                   nsIntRegion* aRegion = nullptr,
 364                   nsIntPoint* aOffset = nullptr) MOZ_OVERRIDE;
 365
 366   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 367
 368   virtual void EnsureBuffer(const nsIntSize& aSize, gfxContentType aType) MOZ_OVERRIDE;
 369
 370   virtual void CopyTo(const nsIntRect& aSourceRect,
 371                       DeprecatedTextureHost *aDest,
 372                       const nsIntRect& aDestRect) MOZ_OVERRIDE;
 373
 374   bool IsValid() const MOZ_OVERRIDE
 375   {
 376     return !!mTexture;
 377   }
 378
 379   virtual bool Lock() MOZ_OVERRIDE;
 380
 381   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE;
 382
 383   // textureSource
 384   void BindTexture(GLenum aTextureUnit) MOZ_OVERRIDE
 385   {
 386     mTexture->BindTexture(aTextureUnit);
 387   }
 388
 389   void UnbindTexture() MOZ_OVERRIDE
 390   {
 391     mTexture->ReleaseTexture();
 392   }
 393
 394   gfx::IntSize GetSize() const MOZ_OVERRIDE;
 395
 396   GLenum GetWrapMode() const MOZ_OVERRIDE
 397   {
 398     return mTexture->GetWrapMode();
 399   }
 400
 401   gl::TextureImage* GetTextureImage()
 402   {
 403     return mTexture;
 404   }
 405
 406   void SetTextureImage(gl::TextureImage* aImage)
 407   {
 408     mTexture = aImage;
 409   }
 410
 411   // TileIterator
 412
 413   TileIterator* AsTileIterator() MOZ_OVERRIDE
 414   {
 415     return this;
 416   }
 417
 418   void BeginTileIteration() MOZ_OVERRIDE
 419   {
 420     mTexture->BeginTileIteration();
 421     mIterating = true;
 422   }
 423
 424   void EndTileIteration() MOZ_OVERRIDE
 425   {
 426     mIterating = false;
 427   }
 428
 429   nsIntRect GetTileRect() MOZ_OVERRIDE;
 430
 431   size_t GetTileCount() MOZ_OVERRIDE
 432   {
 433     return mTexture->GetTileCount();
 434   }
 435
 436   bool NextTile() MOZ_OVERRIDE
 437   {
 438     return mTexture->NextTile();
 439   }
 440
 441   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE
 442   {
 443     return DeprecatedTextureHost::GetFormat();
 444   }
 445
 446 #ifdef MOZ_LAYERS_HAVE_LOG
 447   virtual const char* Name() { return "TextureImageDeprecatedTextureHostOGL"; }
 448 #endif
 449
 450 protected:
 451   nsRefPtr<gl::TextureImage> mTexture;
 452   gl::GLContext* mGL;
 453   bool mIterating;
 454 };
 455
 456 /**
 457  * DeprecatedTextureHost implementation for YCbCr images in the OpenGL backend.
 458  *
 459  * This DeprecatedTextureHost is a little bit particular in that it implements
 460  * the TextureSource interface, as it is required that a DeprecatedTextureHost
 461  * provides access to a TextureSource, but does not implement the
 462  * DeprecatedTextureHostOGL interface. Instead it contains 3 channels (one per
 463  * plane) that implement the TextureSourceOGL interface, and
 464  * YCbCrDeprecatedTextureHostOGL's TextureSource implementation provide access
 465  * to these channels with the GetSubSource method.
 466  */
 467 class YCbCrDeprecatedTextureHostOGL : public DeprecatedTextureHost
 468 {
 469 public:
 470   YCbCrDeprecatedTextureHostOGL()
 471     : mGL(nullptr)
 472   {
 473     MOZ_COUNT_CTOR(YCbCrDeprecatedTextureHostOGL);
 474     mYTexture  = new Channel;
 475     mCbTexture = new Channel;
 476     mCrTexture = new Channel;
 477     mFormat = gfx::FORMAT_YUV;
 478   }
 479
 480   ~YCbCrDeprecatedTextureHostOGL()
 481   {
 482     MOZ_COUNT_DTOR(YCbCrDeprecatedTextureHostOGL);
 483   }
 484
 485   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 486
 487   virtual void UpdateImpl(const SurfaceDescriptor& aImage,
 488                           nsIntRegion* aRegion = nullptr,
 489                           nsIntPoint* aOffset = nullptr) MOZ_OVERRIDE;
 490
 491   virtual bool Lock() MOZ_OVERRIDE;
 492
 493   virtual bool IsValid() const MOZ_OVERRIDE
 494   {
 495     return mYTexture->IsValid()
 496         && mCbTexture->IsValid()
 497         && mCrTexture->IsValid();
 498   }
 499
 500   struct Channel : public TextureSourceOGL
 501                  , public TextureSource
 502   {
 503     TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE
 504     {
 505       return this;
 506     }
 507     nsRefPtr<gl::TextureImage> mTexImage;
 508
 509     void BindTexture(GLenum aUnit) MOZ_OVERRIDE
 510     {
 511       mTexImage->BindTexture(aUnit);
 512     }
 513     void UnbindTexture() MOZ_OVERRIDE
 514     {
 515       mTexImage->ReleaseTexture();
 516     }
 517     virtual bool IsValid() const MOZ_OVERRIDE
 518     {
 519       return !!mTexImage;
 520     }
 521     virtual gfx::IntSize GetSize() const MOZ_OVERRIDE
 522     {
 523       return gfx::IntSize(mTexImage->GetSize().width, mTexImage->GetSize().height);
 524     }
 525     virtual GLenum GetWrapMode() const MOZ_OVERRIDE
 526     {
 527       return mTexImage->GetWrapMode();
 528     }
 529     virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE
 530     {
 531       return gfx::FORMAT_A8;
 532     }
 533   };
 534
 535   // TextureSource implementation
 536
 537   TextureSource* GetSubSource(int index) MOZ_OVERRIDE
 538   {
 539     switch (index) {
 540       case 0 : return mYTexture.get();
 541       case 1 : return mCbTexture.get();
 542       case 2 : return mCrTexture.get();
 543     }
 544     return nullptr;
 545   }
 546
 547   gfx::IntSize GetSize() const MOZ_OVERRIDE
 548   {
 549     if (!mYTexture->mTexImage) {
 550       NS_WARNING("YCbCrDeprecatedTextureHost::GetSize called but no data has been set yet");
 551       return gfx::IntSize(0,0);
 552     }
 553     return mYTexture->GetSize();
 554   }
 555
 556   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE;
 557
 558 #ifdef MOZ_LAYERS_HAVE_LOG
 559   virtual const char* Name() { return "YCbCrDeprecatedTextureHostOGL"; }
 560 #endif
 561
 562 private:
 563   RefPtr<Channel> mYTexture;
 564   RefPtr<Channel> mCbTexture;
 565   RefPtr<Channel> mCrTexture;
 566   gl::GLContext* mGL;
 567 };
 568
 569
 570 class SharedDeprecatedTextureHostOGL : public DeprecatedTextureHost
 571                            , public TextureSourceOGL
 572 {
 573 public:
 574   typedef gfxASurface::gfxContentType ContentType;
 575   typedef mozilla::gl::GLContext GLContext;
 576   typedef mozilla::gl::TextureImage TextureImage;
 577
 578   SharedDeprecatedTextureHostOGL()
 579     : mGL(nullptr)
 580     , mTextureHandle(0)
 581     , mWrapMode(LOCAL_GL_CLAMP_TO_EDGE)
 582     , mSharedHandle(0)
 583     , mShareType(gl::SameProcess)
 584   {}
 585
 586   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 587
 588   virtual ~SharedDeprecatedTextureHostOGL()
 589   {
 590     if (mSharedHandle || mTextureHandle) {
 591       DeleteTextures();
 592     }
 593   }
 594
 595   virtual GLuint GetTextureHandle()
 596   {
 597     return mTextureHandle;
 598   }
 599
 600   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE
 601   {
 602     return DeprecatedTextureHost::GetFormat();
 603   }
 604
 605   virtual TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE { return this; }
 606
 607   bool IsValid() const MOZ_OVERRIDE { return !!mSharedHandle; }
 608
 609   // override from DeprecatedTextureHost, we support both buffered
 610   // and unbuffered operation.
 611   virtual void UpdateImpl(const SurfaceDescriptor& aImage,
 612                           nsIntRegion* aRegion = nullptr,
 613                           nsIntPoint* aOffset = nullptr) MOZ_OVERRIDE;
 614   virtual void SwapTexturesImpl(const SurfaceDescriptor& aImage,
 615                                 nsIntRegion* aRegion = nullptr) MOZ_OVERRIDE;
 616   virtual bool Lock() MOZ_OVERRIDE;
 617   virtual void Unlock() MOZ_OVERRIDE;
 618
 619   virtual GLenum GetWrapMode() const MOZ_OVERRIDE { return mWrapMode; }
 620   virtual void SetWrapMode(GLenum aMode) { mWrapMode = aMode; }
 621
 622   virtual GLenum GetTextureTarget() const MOZ_OVERRIDE
 623   {
 624     return mTextureTarget;
 625   }
 626
 627   gfx::IntSize GetSize() const MOZ_OVERRIDE {
 628     return mSize;
 629   }
 630
 631   void BindTexture(GLenum activetex) MOZ_OVERRIDE
 632   {
 633     MOZ_ASSERT(mGL);
 634     // Lock already bound us!
 635     MOZ_ASSERT(activetex == LOCAL_GL_TEXTURE0);
 636   }
 637   void UnbindTexture() MOZ_OVERRIDE {}
 638   GLuint GetTextureID() { return mTextureHandle; }
 639   ContentType GetContentType()
 640   {
 641     return (mFormat == gfx::FORMAT_B8G8R8A8) ?
 642              gfxASurface::CONTENT_COLOR_ALPHA :
 643              gfxASurface::CONTENT_COLOR;
 644   }
 645
 646   virtual gfx3DMatrix GetTextureTransform() MOZ_OVERRIDE;
 647
 648   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE;
 649
 650 #ifdef MOZ_LAYERS_HAVE_LOG
 651   virtual const char* Name() { return "SharedDeprecatedTextureHostOGL"; }
 652 #endif
 653
 654 protected:
 655   void DeleteTextures();
 656
 657   gfx::IntSize mSize;
 658   nsRefPtr<gl::GLContext> mGL;
 659   GLuint mTextureHandle;
 660   GLenum mWrapMode;
 661   GLenum mTextureTarget;
 662   gl::SharedTextureHandle mSharedHandle;
 663   gl::SharedTextureShareType mShareType;
 664 };
 665
 666 class SurfaceStreamHostOGL : public DeprecatedTextureHost
 667                            , public TextureSourceOGL
 668 {
 669 public:
 670   typedef gfxASurface::gfxContentType ContentType;
 671   typedef mozilla::gl::GLContext GLContext;
 672   typedef mozilla::gl::TextureImage TextureImage;
 673
 674   virtual ~SurfaceStreamHostOGL()
 675   {
 676     DeleteTextures();
 677   }
 678
 679   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 680
 681   virtual GLuint GetTextureHandle()
 682   {
 683     return mTextureHandle;
 684   }
 685
 686   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE
 687   {
 688     return DeprecatedTextureHost::GetFormat();
 689   }
 690
 691   virtual TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE { return this; }
 692
 693   bool IsValid() const MOZ_OVERRIDE { return true; }
 694
 695   // override from DeprecatedTextureHost
 696   virtual void UpdateImpl(const SurfaceDescriptor& aImage,
 697                           nsIntRegion* aRegion,
 698                           nsIntPoint* aOffset);
 699   virtual bool Lock() MOZ_OVERRIDE;
 700   virtual void Unlock() MOZ_OVERRIDE;
 701
 702   virtual GLenum GetWrapMode() const MOZ_OVERRIDE {
 703     return mWrapMode;
 704   }
 705   virtual void SetWrapMode(GLenum aMode) {
 706     mWrapMode = aMode;
 707   }
 708
 709   gfx::IntSize GetSize() const MOZ_OVERRIDE {
 710     return mSize;
 711   }
 712
 713   virtual GLenum GetTextureTarget() const MOZ_OVERRIDE
 714   {
 715     return mTextureTarget;
 716   }
 717
 718   void BindTexture(GLenum activetex) MOZ_OVERRIDE;
 719
 720   void UnbindTexture() MOZ_OVERRIDE {}
 721
 722   GLuint GetTextureID() { return mTextureHandle; }
 723   ContentType GetContentType() {
 724     return (mFormat == gfx::FORMAT_B8G8R8A8) ?
 725              gfxASurface::CONTENT_COLOR_ALPHA :
 726              gfxASurface::CONTENT_COLOR;
 727   }
 728
 729   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE;
 730
 731 #ifdef MOZ_LAYERS_HAVE_LOG
 732   virtual const char* Name() { return "SurfaceStreamHostOGL"; }
 733 #endif
 734
 735   SurfaceStreamHostOGL()
 736     : mGL(nullptr)
 737     , mTextureHandle(0)
 738     , mTextureTarget(LOCAL_GL_TEXTURE_2D)
 739     , mUploadTexture(0)
 740     , mWrapMode(LOCAL_GL_CLAMP_TO_EDGE)
 741     , mStream(nullptr)
 742   {}
 743
 744 protected:
 745   void DeleteTextures();
 746
 747   gfx::IntSize mSize;
 748   nsRefPtr<GLContext> mGL;
 749   GLuint mTextureHandle;
 750   GLenum mTextureTarget;
 751   GLuint mUploadTexture;
 752   GLenum mWrapMode;
 753   nsRefPtr<GLContext> mStreamGL;
 754   gfx::SurfaceStream *mStream;
 755 };
 756
 757 class TiledDeprecatedTextureHostOGL : public DeprecatedTextureHost
 758                           , public TextureSourceOGL
 759 {
 760 public:
 761   TiledDeprecatedTextureHostOGL()
 762     : mTextureHandle(0)
 763     , mGL(nullptr)
 764   {}
 765   ~TiledDeprecatedTextureHostOGL();
 766
 767   virtual void SetCompositor(Compositor* aCompositor);
 768
 769   // have to pass the size in here (every time) because of DrawQuad API :-(
 770   virtual void Update(gfxReusableSurfaceWrapper* aReusableSurface, TextureFlags aFlags, const gfx::IntSize& aSize) MOZ_OVERRIDE;
 771   virtual bool Lock() MOZ_OVERRIDE;
 772   virtual void Unlock() MOZ_OVERRIDE {}
 773
 774   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE
 775   {
 776     return DeprecatedTextureHost::GetFormat();
 777   }
 778
 779   virtual TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE { return this; }
 780   virtual bool IsValid() const MOZ_OVERRIDE { return true; }
 781   virtual GLenum GetWrapMode() const MOZ_OVERRIDE { return LOCAL_GL_CLAMP_TO_EDGE; }
 782   virtual void BindTexture(GLenum aTextureUnit);
 783   virtual void UnbindTexture() MOZ_OVERRIDE {}
 784   virtual gfx::IntSize GetSize() const MOZ_OVERRIDE
 785   {
 786     return mSize;
 787   }
 788
 789   virtual void SwapTexturesImpl(const SurfaceDescriptor& aImage,
 790                                 nsIntRegion* aRegion = nullptr)
 791   { MOZ_ASSERT(false, "Tiles should not use this path"); }
 792
 793   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE;
 794
 795 #ifdef MOZ_LAYERS_HAVE_LOG
 796   virtual const char* Name() { return "TiledDeprecatedTextureHostOGL"; }
 797 #endif
 798
 799 protected:
 800   void DeleteTextures();
 801
 802   virtual uint64_t GetIdentifier() const MOZ_OVERRIDE {
 803     return static_cast<uint64_t>(mTextureHandle);
 804   }
 805
 806 private:
 807   GLenum GetTileType()
 808   {
 809     // Deduce the type that was assigned in GetFormatAndTileForImageFormat
 810     return mGLFormat == LOCAL_GL_RGB ? LOCAL_GL_UNSIGNED_SHORT_5_6_5 : LOCAL_GL_UNSIGNED_BYTE;
 811   }
 812
 813   gfx::IntSize mSize;
 814   GLuint mTextureHandle;
 815   GLenum mGLFormat;
 816   nsRefPtr<gl::GLContext> mGL;
 817 };
 818
 819 #ifdef MOZ_WIDGET_GONK
 820
 821 // For direct texturing with gralloc buffers. The corresponding DeprecatedTextureClient is DeprecatedTextureClientShmem,
 822 // which automatically gets gralloc when it can, in which case the compositor sees that the
 823 // SurfaceDescriptor is gralloc, and decides to use a GrallocDeprecatedTextureHostOGL to do direct texturing,
 824 // saving the cost of a texture upload.
 825 class GrallocDeprecatedTextureHostOGL
 826   : public DeprecatedTextureHost
 827   , public TextureSourceOGL
 828 {
 829 public:
 830   GrallocDeprecatedTextureHostOGL();
 831
 832   ~GrallocDeprecatedTextureHostOGL();
 833
 834   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 835
 836   virtual void UpdateImpl(const SurfaceDescriptor& aImage,
 837                           nsIntRegion* aRegion = nullptr,
 838                           nsIntPoint* aOffset = nullptr) MOZ_OVERRIDE;
 839   virtual void SwapTexturesImpl(const SurfaceDescriptor& aImage,
 840                           nsIntRegion* aRegion = nullptr) MOZ_OVERRIDE;
 841   virtual bool Lock() MOZ_OVERRIDE;
 842   virtual void Unlock() MOZ_OVERRIDE;
 843
 844   virtual gfx::IntSize GetSize() const MOZ_OVERRIDE
 845   {
 846     return mGraphicBuffer.get() ? gfx::IntSize(mGraphicBuffer->getWidth(), mGraphicBuffer->getHeight()) : gfx::IntSize(0, 0);
 847   }
 848
 849   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE;
 850
 851   GLenum GetWrapMode() const MOZ_OVERRIDE
 852   {
 853     return LOCAL_GL_CLAMP_TO_EDGE;
 854   }
 855
 856   virtual GLenum GetTextureTarget() const MOZ_OVERRIDE
 857   {
 858     return mTextureTarget;
 859   }
 860
 861   bool IsValid() const MOZ_OVERRIDE;
 862
 863   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE;
 864
 865 #ifdef MOZ_LAYERS_HAVE_LOG
 866   virtual const char* Name() { return "GrallocDeprecatedTextureHostOGL"; }
 867 #endif
 868
 869   void BindTexture(GLenum aTextureUnit) MOZ_OVERRIDE;
 870   void UnbindTexture() MOZ_OVERRIDE {}
 871
 872   virtual TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE
 873   {
 874     return this;
 875   }
 876
 877   // only overridden for hacky fix in gecko 23 for bug 862324
 878   // see bug 865908 about fixing this.
 879   virtual void SetBuffer(SurfaceDescriptor* aBuffer, ISurfaceAllocator* aAllocator) MOZ_OVERRIDE;
 880
 881   // used only for hacky fix in gecko 23 for bug 862324
 882   virtual void ForgetBuffer()
 883   {
 884     if (mBuffer) {
 885       // Intentionally don't destroy the actor held by mBuffer here.
 886       // The point is that this is only called from GrallocBufferActor::ActorDestroy
 887       // where we know that the actor is already being deleted.
 888       // See bug 862324 comment 39.
 889       delete mBuffer;
 890       mBuffer = nullptr;
 891     }
 892
 893     mGraphicBuffer = nullptr;
 894     DeleteTextures();
 895   }
 896
 897   virtual LayerRenderState GetRenderState() MOZ_OVERRIDE;
 898
 899 private:
 900   gl::GLContext* gl() const;
 901
 902   void DeleteTextures();
 903
 904   RefPtr<CompositorOGL> mCompositor;
 905   android::sp<android::GraphicBuffer> mGraphicBuffer;
 906   GLenum mTextureTarget;
 907   EGLImage mEGLImage;
 908   //Set when the composer needs to swap RB pixels of gralloc buffer
 909   bool mIsRBSwapped;
 910 };
 911 #endif
 912
 913 } // namespace
 914 } // namespace
 915
 916 #endif /* MOZILLA_GFX_TEXTUREOGL_H */