void
YCbCrDeprecatedTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
                                nsIntRegion* aRegion,
                                nsIntPoint* aOffset)
{
  if (!mGL) {
    return;
  }
  NS_ASSERTION(aImage.type() == SurfaceDescriptor::TYCbCrImage, "SurfaceDescriptor mismatch");

  YCbCrImageDataDeserializer deserializer(aImage.get_YCbCrImage().data().get<uint8_t>());

  gfxIntSize gfxSize = deserializer.GetYSize();
  gfxIntSize gfxCbCrSize = deserializer.GetCbCrSize();

  if (!mYTexture->mTexImage || mYTexture->mTexImage->GetSize() != gfxSize) {
    mYTexture->mTexImage = CreateBasicTextureImage(mGL,
                                                   gfxSize,
                                                   gfxASurface::CONTENT_ALPHA,
                                                   WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
                                                   FlagsToGLFlags(mFlags));
  }
  if (!mCbTexture->mTexImage || mCbTexture->mTexImage->GetSize() != gfxCbCrSize) {
    mCbTexture->mTexImage = CreateBasicTextureImage(mGL,
                                                    gfxCbCrSize,
                                                    gfxASurface::CONTENT_ALPHA,
                                                    WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
                                                    FlagsToGLFlags(mFlags));
  }
  if (!mCrTexture->mTexImage || mCrTexture->mTexImage->GetSize() != gfxCbCrSize) {
    mCrTexture->mTexImage = CreateBasicTextureImage(mGL,
                                                    gfxCbCrSize,
                                                    gfxASurface::CONTENT_ALPHA,
                                                    WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
                                                    FlagsToGLFlags(mFlags));
  }

  RefPtr<gfxImageSurface> tempY = new gfxImageSurface(deserializer.GetYData(),
                                       gfxSize, deserializer.GetYStride(),
                                       gfxASurface::ImageFormatA8);
  RefPtr<gfxImageSurface> tempCb = new gfxImageSurface(deserializer.GetCbData(),
                                       gfxCbCrSize, deserializer.GetCbCrStride(),
                                       gfxASurface::ImageFormatA8);
  RefPtr<gfxImageSurface> tempCr = new gfxImageSurface(deserializer.GetCrData(),
                                       gfxCbCrSize, deserializer.GetCbCrStride(),
                                       gfxASurface::ImageFormatA8);

  nsIntRegion yRegion(nsIntRect(0, 0, gfxSize.width, gfxSize.height));
  nsIntRegion cbCrRegion(nsIntRect(0, 0, gfxCbCrSize.width, gfxCbCrSize.height));

  mYTexture->mTexImage->DirectUpdate(tempY, yRegion);
  mCbTexture->mTexImage->DirectUpdate(tempCb, cbCrRegion);
  mCrTexture->mTexImage->DirectUpdate(tempCr, cbCrRegion);
}
示例#2
0
GPUBlurFilter::GPUBlurFilter(const IntPoint& size, PixelFormat pfSrc, PixelFormat pfDest,
        float stdDev, bool bClipBorders, bool bStandalone, bool bUseFloatKernel)
    : GPUFilter(pfSrc, pfDest, bStandalone, SHADERID_HORIZ, 2),
      m_bClipBorders(bClipBorders),
      m_bUseFloatKernel(bUseFloatKernel)
{
    ObjectCounter::get()->incRef(&typeid(*this));

    GLContext::getCurrent()->ensureFullShaders("GPUBlurFilter");
#ifndef AVG_ENABLE_EGL
    if (!m_bClipBorders) {
        //TODO: TO_BORDER DOES NOT EXIST IN GLESV2
        m_WrapMode = WrapMode(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_BORDER);
    }
#endif
    setDimensions(size, stdDev);
    GLContextManager* pCM = GLContextManager::get();
    pCM->createShader(SHADERID_VERT);
    setStdDev(stdDev);

    m_pHorizWidthParam = pCM->createShaderParam<float>(SHADERID_HORIZ, "u_Width");
    m_pHorizRadiusParam = pCM->createShaderParam<int>(SHADERID_HORIZ, "u_Radius");
    m_pHorizTextureParam = pCM->createShaderParam<int>(SHADERID_HORIZ, "u_Texture");
    m_pHorizKernelTexParam = pCM->createShaderParam<int>(SHADERID_HORIZ, "u_KernelTex");

    m_pVertWidthParam = pCM->createShaderParam<float>(SHADERID_VERT, "u_Width");
    m_pVertRadiusParam = pCM->createShaderParam<int>(SHADERID_VERT, "u_Radius");
    m_pVertTextureParam = pCM->createShaderParam<int>(SHADERID_VERT, "u_Texture");
    m_pVertKernelTexParam = pCM->createShaderParam<int>(SHADERID_VERT, "u_KernelTex");
}
示例#3
0
FilledVectorNode::FilledVectorNode(const ArgList& args)
    : VectorNode(args),
      m_pFillShape(new Shape(WrapMode(GL_REPEAT, GL_REPEAT), false))
{
    m_FillTexHRef = args.getArgVal<UTF8String>("filltexhref"); 
    setFillTexHRef(m_FillTexHRef);
    m_sFillColorName = args.getArgVal<UTF8String>("fillcolor");
    m_FillColor = colorStringToColor(m_sFillColorName);
}
示例#4
0
bool
TextureImageTextureSourceOGL::Update(gfx::DataSourceSurface* aSurface,
                                     nsIntRegion* aDestRegion,
                                     gfx::IntPoint* aSrcOffset)
{
    MOZ_ASSERT(mGL);
    if (!mGL) {
        NS_WARNING("trying to update TextureImageTextureSourceOGL without a GLContext");
        return false;
    }
    MOZ_ASSERT(aSurface);

    IntSize size = aSurface->GetSize();
    if (!mTexImage ||
            (mTexImage->GetSize() != size && !aSrcOffset) ||
            mTexImage->GetContentType() != gfx::ContentForFormat(aSurface->GetFormat())) {
        if (mFlags & TEXTURE_DISALLOW_BIGIMAGE) {
            mTexImage = CreateBasicTextureImage(mGL, size,
                                                gfx::ContentForFormat(aSurface->GetFormat()),
                                                WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
                                                FlagsToGLFlags(mFlags),
                                                SurfaceFormatToImageFormat(aSurface->GetFormat()));
        } else {
            // XXX - clarify which size we want to use. IncrementalContentHost will
            // require the size of the destination surface to be different from
            // the size of aSurface.
            // See bug 893300 (tracks the implementation of ContentHost for new textures).
            mTexImage = CreateTextureImage(mGL,
                                           size,
                                           gfx::ContentForFormat(aSurface->GetFormat()),
                                           WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
                                           FlagsToGLFlags(mFlags),
                                           SurfaceFormatToImageFormat(aSurface->GetFormat()));
        }
        ClearCachedFilter();
    }

    mTexImage->UpdateFromDataSource(aSurface, aDestRegion, aSrcOffset);

    if (mTexImage->InUpdate()) {
        mTexImage->EndUpdate();
    }
    return true;
}
void
TextureImageDeprecatedTextureHostOGL::EnsureBuffer(const nsIntSize& aSize,
                                         gfxContentType aContentType)
{
  if (!mTexture ||
      mTexture->GetSize() != aSize ||
      mTexture->GetContentType() != aContentType) {
    mTexture = mGL->CreateTextureImage(aSize,
                                       aContentType,
                                       WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
                                       FlagsToGLFlags(mFlags));
  }
  mTexture->Resize(aSize);
}
void
TextureImageTextureHostOGL::EnsureBuffer(const nsIntSize& aSize,
                                         gfxContentType aContentType)
{
  if (!mTexture ||
      mTexture->GetSize() != aSize ||
      mTexture->GetContentType() != aContentType) {
    mTexture = mGL->CreateTextureImage(aSize,
                                       aContentType,
                                       WrapMode(mGL, mFlags & AllowRepeat),
                                       FlagsToGLFlags(mFlags));
  }
  mTexture->Resize(aSize);
}
示例#7
0
void
TextureImageTextureSourceOGL::EnsureBuffer(const nsIntSize& aSize,
        gfxContentType aContentType)
{
    if (!mTexImage ||
            mTexImage->GetSize() != aSize.ToIntSize() ||
            mTexImage->GetContentType() != aContentType) {
        mTexImage = CreateTextureImage(mGL,
                                       aSize.ToIntSize(),
                                       aContentType,
                                       WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
                                       FlagsToGLFlags(mFlags));
    }
    mTexImage->Resize(aSize.ToIntSize());
}
void
TextureImageDeprecatedTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
                                       nsIntRegion* aRegion,
                                       nsIntPoint* aOffset)
{
  if (!mGL) {
    NS_WARNING("trying to update TextureImageDeprecatedTextureHostOGL without a compositor?");
    return;
  }

  AutoOpenSurface surf(OPEN_READ_ONLY, aImage);
  nsIntSize size = surf.Size();
  TextureImage::ImageFormat format = surf.ImageFormat();

  if (!mTexture ||
      (mTexture->GetSize() != size && !aOffset) ||
      mTexture->GetContentType() != surf.ContentType() ||
      (mTexture->GetImageFormat() != format &&
       mTexture->GetImageFormat() != gfxASurface::ImageFormatUnknown)) {

    mTexture = mGL->CreateTextureImage(size,
                                       surf.ContentType(),
                                       WrapMode(mGL, mFlags & TEXTURE_ALLOW_REPEAT),
                                       FlagsToGLFlags(mFlags),
                                       format);
  }

  // XXX this is always just ridiculously slow
  nsIntRegion updateRegion;

  if (!aRegion) {
    updateRegion = nsIntRegion(nsIntRect(0, 0, size.width, size.height));
  } else {
    updateRegion = *aRegion;
  }
  nsIntPoint offset;
  if (aOffset) {
    offset = *aOffset;
  }
  mTexture->DirectUpdate(surf.Get(), updateRegion, offset);
  mFormat = mTexture->GetTextureFormat();

  if (mTexture->InUpdate()) {
    mTexture->EndUpdate();
  }
}
示例#9
0
void GPUBlurFilter::applyOnGPU(GLContext* pContext, GLTexturePtr pSrcTex)
{
    int kernelWidth = m_pGaussCurveTex->getSize().x;
    getFBO(pContext, 1)->activate();
    getShader()->activate();
    m_pHorizWidthParam->set(pContext, float(kernelWidth));
    m_pHorizRadiusParam->set(pContext, (kernelWidth-1)/2);
    m_pHorizTextureParam->set(pContext, 0);
    m_pHorizKernelTexParam->set(pContext, 1);
    m_pGaussCurveTex->getTex(pContext)->activate(WrapMode(), GL_TEXTURE1);
    draw(pContext, pSrcTex, m_WrapMode);

    getFBO(pContext, 0)->activate();
    OGLShaderPtr pVShader = avg::getShader(SHADERID_VERT);
    pVShader->activate();
    m_pVertWidthParam->set(pContext, float(kernelWidth));
    m_pVertRadiusParam->set(pContext, (kernelWidth-1)/2);
    m_pVertTextureParam->set(pContext, 0);
    m_pVertKernelTexParam->set(pContext, 1);
    getDestTex(pContext, 1)->activate(m_WrapMode, GL_TEXTURE0);
    m_pProjection2->draw(pContext, pVShader);
}
示例#10
0
void GPUInvertFilter::applyOnGPU(GLContext* pContext, GLTexturePtr pSrcTex)
{
    getShader()->activate();
    m_pTextureParam->set(pContext, 0);
    draw(pContext, pSrcTex, WrapMode());
}