vcl/opengl/scale.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include <cmath>
  24
  25 #include <vcl/opengl/OpenGLHelper.hxx>
  26
  27 #include <vcl/bitmap.hxx>
  28
  29 #include <opengl/zone.hxx>
  30 #include <opengl/salbmp.hxx>
  31 #include <opengl/program.hxx>
  32 #include <opengl/texture.hxx>
  33 #include <opengl/RenderState.hxx>
  34
  35 #include <ResampleKernel.hxx>
  36
  37 using vcl::Kernel;
  38 using vcl::Lanczos3Kernel;
  39
  40 bool OpenGLSalBitmap::ImplScaleFilter(
  41     const rtl::Reference< OpenGLContext > &xContext,
  42     const double& rScaleX,
  43     const double& rScaleY,
  44     GLenum        nFilter )
  45 {
  46     OpenGLFramebuffer* pFramebuffer;
  47     OpenGLProgram* pProgram;
  48     GLenum nOldFilter;
  49     int nNewWidth( mnWidth * rScaleX );
  50     int nNewHeight( mnHeight * rScaleY );
  51
  52     pProgram = xContext->UseProgram( "textureVertexShader",
  53                                      "textureFragmentShader" );
  54     if( !pProgram )
  55         return false;
  56
  57     OpenGLTexture aNewTex(nNewWidth, nNewHeight);
  58     pFramebuffer = xContext->AcquireFramebuffer( aNewTex );
  59
  60     pProgram->SetTexture( "sampler", maTexture );
  61     nOldFilter = maTexture.GetFilter();
  62     maTexture.SetFilter( nFilter );
  63     pProgram->ApplyMatrix(mnWidth, mnHeight);
  64     pProgram->DrawTexture( maTexture );
  65     maTexture.SetFilter( nOldFilter );
  66     pProgram->Clean();
  67
  68     OpenGLContext::ReleaseFramebuffer( pFramebuffer );
  69
  70     mnWidth = nNewWidth;
  71     mnHeight = nNewHeight;
  72     maTexture = aNewTex;
  73
  74     CHECK_GL_ERROR();
  75     return true;
  76 }
  77
  78 void OpenGLSalBitmap::ImplCreateKernel(
  79     const double& fScale,
  80     const Kernel& rKernel,
  81     GLfloat*& pWeights,
  82     sal_uInt32& aKernelSize )
  83 {
  84     const double fSamplingRadius(rKernel.GetWidth());
  85     const double fScaledRadius((fScale < 1.0) ? fSamplingRadius / fScale : fSamplingRadius);
  86     const double fFilterFactor(std::min(fScale, 1.0));
  87     int aNumberOfContributions;
  88     double aSum( 0 );
  89
  90     aNumberOfContributions = (static_cast< sal_uInt32 >(fabs(ceil(fScaledRadius))) * 2) + 1 - 6;
  91     aKernelSize = aNumberOfContributions / 2 + 1;
  92
  93     // avoid a crash for now; re-think me.
  94     if (aKernelSize > 16)
  95         aKernelSize = 16;
  96
  97     pWeights = new GLfloat[16];
  98     memset( pWeights, 0, 16 * sizeof( GLfloat ) );
  99
 100     for( sal_uInt32 i(0); i < aKernelSize; i++ )
 101     {
 102         const GLfloat aWeight( rKernel.Calculate( fFilterFactor * i ) );
 103         if( fabs( aWeight ) >= 0.0001 )
 104         {
 105             pWeights[i] = aWeight;
 106             aSum += i > 0 ? aWeight * 2 : aWeight;
 107         }
 108     }
 109
 110     for( sal_uInt32 i(0); i < aKernelSize; i++ )
 111     {
 112         pWeights[i] /= aSum;
 113     }
 114 }
 115
 116 bool OpenGLSalBitmap::ImplScaleConvolution(
 117     const rtl::Reference< OpenGLContext > &xContext,
 118     const double& rScaleX,
 119     const double& rScaleY,
 120     const Kernel& aKernel )
 121 {
 122     OpenGLFramebuffer* pFramebuffer;
 123     OpenGLProgram* pProgram;
 124     GLfloat* pWeights( nullptr );
 125     sal_uInt32 nKernelSize;
 126     GLfloat aOffsets[32];
 127     int nNewWidth( mnWidth * rScaleX );
 128     int nNewHeight( mnHeight * rScaleY );
 129
 130     // TODO Make sure the framebuffer is alright
 131
 132     pProgram = xContext->UseProgram( "textureVertexShader",
 133                                       "convolutionFragmentShader" );
 134     if( pProgram == nullptr )
 135         return false;
 136
 137     // horizontal scaling in scratch texture
 138     if( mnWidth != nNewWidth )
 139     {
 140         OpenGLTexture aScratchTex(nNewWidth, nNewHeight);
 141
 142         pFramebuffer = xContext->AcquireFramebuffer( aScratchTex );
 143
 144         for( sal_uInt32 i = 0; i < 16; i++ )
 145         {
 146             aOffsets[i * 2] = i / static_cast<double>(mnWidth);
 147             aOffsets[i * 2 + 1] = 0;
 148         }
 149         ImplCreateKernel( rScaleX, aKernel, pWeights, nKernelSize );
 150         pProgram->SetUniform1fv( "kernel", 16, pWeights );
 151         pProgram->SetUniform2fv( "offsets", 16, aOffsets );
 152         pProgram->SetTexture( "sampler", maTexture );
 153         pProgram->DrawTexture( maTexture );
 154         pProgram->Clean();
 155
 156         maTexture = aScratchTex;
 157         OpenGLContext::ReleaseFramebuffer( pFramebuffer );
 158     }
 159
 160     // vertical scaling in final texture
 161     if( mnHeight != nNewHeight )
 162     {
 163         OpenGLTexture aScratchTex(nNewWidth, nNewHeight);
 164
 165         pFramebuffer = xContext->AcquireFramebuffer( aScratchTex );
 166
 167         for( sal_uInt32 i = 0; i < 16; i++ )
 168         {
 169             aOffsets[i * 2] = 0;
 170             aOffsets[i * 2 + 1] = i / static_cast<double>(mnHeight);
 171         }
 172         ImplCreateKernel( rScaleY, aKernel, pWeights, nKernelSize );
 173         pProgram->SetUniform1fv( "kernel", 16, pWeights );
 174         pProgram->SetUniform2fv( "offsets", 16, aOffsets );
 175         pProgram->SetTexture( "sampler", maTexture );
 176         pProgram->DrawTexture( maTexture );
 177         pProgram->Clean();
 178
 179         maTexture = aScratchTex;
 180         OpenGLContext::ReleaseFramebuffer( pFramebuffer );
 181     }
 182
 183     mnWidth = nNewWidth;
 184     mnHeight = nNewHeight;
 185
 186     CHECK_GL_ERROR();
 187     return true;
 188 }
 189
 190 /*
 191  "Area" scaling algorithm, which seems to give better results for downscaling
 192  than other algorithms. The principle (taken from opencv, see resize.cl)
 193  is that each resulting pixel is the average of all the source pixel values
 194  it represents. Which is trivial in the case of exact multiples for downscaling,
 195  the generic case needs to also consider that some source pixels contribute
 196  only partially to their resulting pixels (because of non-integer multiples).
 197 */
 198 bool OpenGLSalBitmap::ImplScaleArea( const rtl::Reference< OpenGLContext > &xContext,
 199                                      double rScaleX, double rScaleY )
 200 {
 201     int nNewWidth( mnWidth * rScaleX );
 202     int nNewHeight( mnHeight * rScaleY );
 203
 204     if( nNewWidth == mnWidth && nNewHeight == mnHeight )
 205         return true;
 206
 207     double ixscale = 1 / rScaleX;
 208     double iyscale = 1 / rScaleY;
 209     bool fast = ( ixscale == std::trunc( ixscale ) && iyscale == std::trunc( iyscale )
 210         && int( nNewWidth * ixscale ) == mnWidth && int( nNewHeight * iyscale ) == mnHeight );
 211
 212     bool bTwoPasses = false;
 213
 214     // The generic case has arrays only up to 100 ratio downscaling, which is hopefully enough
 215     // in practice, but protect against buffer overflows in case such an extreme case happens
 216     // (and in such case the precision of the generic algorithm probably doesn't matter anyway).
 217     if( ixscale > 100 || iyscale > 100 )
 218     {
 219         fast = true;
 220     }
 221     else
 222     {
 223         if (ixscale > 16 || iyscale > 16)
 224         {
 225             ixscale = std::floor(std::sqrt(ixscale));
 226             iyscale = std::floor(std::sqrt(iyscale));
 227             nNewWidth = int(mnWidth / ixscale);
 228             rScaleX *= ixscale; // second pass x-scale factor
 229             nNewHeight = int(mnHeight / iyscale);
 230             rScaleY *= iyscale; // second pass y-scale factor
 231             bTwoPasses = true;
 232         }
 233     }
 234
 235     // TODO Make sure the framebuffer is alright
 236
 237     OString sUseReducedRegisterVariantDefine;
 238     if (xContext->getOpenGLCapabilitySwitch().mbLimitedShaderRegisters)
 239         sUseReducedRegisterVariantDefine = OString("#define USE_REDUCED_REGISTER_VARIANT\n");
 240
 241     OpenGLProgram* pProgram = xContext->UseProgram( "textureVertexShader",
 242         fast ? OUString( "areaScaleFastFragmentShader" ) : OUString( "areaScaleFragmentShader" ),
 243         sUseReducedRegisterVariantDefine);
 244
 245     if( pProgram == nullptr )
 246         return false;
 247
 248     OpenGLTexture aScratchTex(nNewWidth, nNewHeight);
 249
 250     OpenGLFramebuffer* pFramebuffer = xContext->AcquireFramebuffer( aScratchTex );
 251
 252     // NOTE: This setup is also done in OpenGLSalGraphicsImpl::DrawTransformedTexture().
 253     if( fast )
 254     {
 255         pProgram->SetUniform1i( "xscale", ixscale );
 256         pProgram->SetUniform1i( "yscale", iyscale );
 257         // The shader operates on pixels in the surrounding area, so it's necessary
 258         // to know the step in texture coordinates to get to the next pixel.
 259         // With a texture atlas the "texture" is just a subtexture of a larger texture,
 260         // so while with a normal texture we'd map between <0.0,1.0> and <0,mnWidth>,
 261         // with a subtexture the texture coordinates range is smaller.
 262         GLfloat srcCoords[ 8 ];
 263         maTexture.GetWholeCoord( srcCoords );
 264         pProgram->SetUniform1f( "xstep", ( srcCoords[ 4 ] - srcCoords[ 0 ] ) / mnWidth );
 265         pProgram->SetUniform1f( "ystep", ( srcCoords[ 5 ] - srcCoords[ 1 ] ) / mnHeight );
 266         pProgram->SetUniform1f( "ratio", 1.0 / ( ixscale * iyscale ));
 267     }
 268     else
 269     {
 270         pProgram->SetUniform1f( "xscale", ixscale );
 271         pProgram->SetUniform1f( "yscale", iyscale );
 272         pProgram->SetUniform1i( "swidth", mnWidth );
 273         pProgram->SetUniform1i( "sheight", mnHeight );
 274         // The shader internally actually operates on pixel coordinates,
 275         // so it needs to know how to convert to those from the texture coordinates.
 276         // With a simple texture that would mean converting e.g. between
 277         // <0,mnWidth-1> and <0.0,1.0> coordinates.
 278         // However with a texture atlas the "texture" is just a subtexture
 279         // of a larger texture, so the texture coordinates need offset and ratio
 280         // conversion too.
 281         GLfloat srcCoords[ 8 ];
 282         maTexture.GetWholeCoord( srcCoords );
 283         pProgram->SetUniform1f( "xoffset", srcCoords[ 0 ] );
 284         pProgram->SetUniform1f( "yoffset", srcCoords[ 1 ] );
 285         pProgram->SetUniform1f( "xtopixelratio", nNewWidth / ( srcCoords[ 4 ] - srcCoords[ 0 ] ));
 286         pProgram->SetUniform1f( "ytopixelratio", nNewHeight / ( srcCoords[ 5 ] - srcCoords[ 1 ] ));
 287         pProgram->SetUniform1f( "xfrompixelratio", ( srcCoords[ 4 ] - srcCoords[ 0 ] ) / mnWidth );
 288         pProgram->SetUniform1f( "yfrompixelratio", ( srcCoords[ 5 ] - srcCoords[ 1 ] ) / mnHeight );
 289     }
 290
 291     pProgram->SetTexture( "sampler", maTexture );
 292     pProgram->DrawTexture( maTexture );
 293     pProgram->Clean();
 294
 295     OpenGLContext::ReleaseFramebuffer(pFramebuffer);
 296
 297     CHECK_GL_ERROR();
 298
 299     if (bTwoPasses)
 300     {
 301         mnWidth = nNewWidth;
 302         mnHeight = nNewHeight;
 303
 304         nNewWidth = round(mnWidth * rScaleX);
 305         nNewHeight = round(mnHeight * rScaleY);
 306
 307         ixscale = 1 / rScaleX;
 308         iyscale = 1 / rScaleY;
 309
 310         pProgram = xContext->UseProgram("textureVertexShader", "areaScaleFragmentShader", sUseReducedRegisterVariantDefine);
 311         if (pProgram == nullptr)
 312             return false;
 313
 314         OpenGLTexture aScratchTex2(nNewWidth, nNewHeight);
 315
 316         pFramebuffer = xContext->AcquireFramebuffer(aScratchTex2);
 317
 318         pProgram->SetUniform1f("xscale", ixscale);
 319         pProgram->SetUniform1f("yscale", iyscale);
 320         pProgram->SetUniform1i("swidth", mnWidth);
 321         pProgram->SetUniform1i("sheight", mnHeight);
 322
 323         GLfloat srcCoords[ 8 ];
 324         aScratchTex.GetWholeCoord( srcCoords );
 325         pProgram->SetUniform1f( "xoffset", srcCoords[ 0 ] );
 326         pProgram->SetUniform1f( "yoffset", srcCoords[ 1 ] );
 327         pProgram->SetUniform1f( "xtopixelratio", nNewWidth / ( srcCoords[ 4 ] - srcCoords[ 0 ] ));
 328         pProgram->SetUniform1f( "ytopixelratio", nNewHeight / ( srcCoords[ 5 ] - srcCoords[ 1 ] ));
 329         pProgram->SetUniform1f( "xfrompixelratio", ( srcCoords[ 4 ] - srcCoords[ 0 ] ) / mnWidth );
 330         pProgram->SetUniform1f( "yfrompixelratio", ( srcCoords[ 5 ] - srcCoords[ 1 ] ) / mnHeight );
 331
 332         pProgram->SetTexture("sampler", aScratchTex);
 333         pProgram->DrawTexture(aScratchTex);
 334         pProgram->Clean();
 335
 336         OpenGLContext::ReleaseFramebuffer(pFramebuffer);
 337
 338         CHECK_GL_ERROR();
 339
 340         maTexture = aScratchTex2;
 341         mnWidth = nNewWidth;
 342         mnHeight = nNewHeight;
 343     }
 344     else
 345     {
 346         maTexture = aScratchTex;
 347         mnWidth = nNewWidth;
 348         mnHeight = nNewHeight;
 349     }
 350
 351     return true;
 352 }
 353
 354 void OpenGLSalBitmap::ImplScale( const double& rScaleX, const double& rScaleY, BmpScaleFlag nScaleFlag )
 355 {
 356     VCL_GL_INFO( "::ImplScale" );
 357
 358     mpUserBuffer.reset();
 359     OpenGLVCLContextZone aContextZone;
 360     rtl::Reference<OpenGLContext> xContext = OpenGLContext::getVCLContext();
 361     xContext->state().scissor().disable();
 362     xContext->state().stencil().disable();
 363
 364     if (rScaleX <= 1 && rScaleY <= 1)
 365     {
 366         nScaleFlag = BmpScaleFlag::BestQuality;
 367     }
 368
 369     if( nScaleFlag == BmpScaleFlag::Fast )
 370     {
 371         ImplScaleFilter( xContext, rScaleX, rScaleY, GL_NEAREST );
 372     }
 373     else if( nScaleFlag == BmpScaleFlag::BiLinear )
 374     {
 375         ImplScaleFilter( xContext, rScaleX, rScaleY, GL_LINEAR );
 376     }
 377     else if( nScaleFlag == BmpScaleFlag::Default )
 378     {
 379         const Lanczos3Kernel aKernel;
 380
 381         ImplScaleConvolution( xContext, rScaleX, rScaleY, aKernel );
 382     }
 383     else if( nScaleFlag == BmpScaleFlag::BestQuality && rScaleX <= 1 && rScaleY <= 1 )
 384     { // Use area scaling for best quality, but only if downscaling.
 385         ImplScaleArea( xContext, rScaleX, rScaleY );
 386     }
 387     else if( nScaleFlag == BmpScaleFlag::Lanczos || nScaleFlag == BmpScaleFlag::BestQuality  )
 388     {
 389         const Lanczos3Kernel aKernel;
 390
 391         ImplScaleConvolution( xContext, rScaleX, rScaleY, aKernel );
 392     }
 393     else
 394         SAL_WARN( "vcl.opengl", "Invalid flag for scaling operation" );
 395 }
 396
 397 bool OpenGLSalBitmap::ScalingSupported() const
 398 {
 399     return true;
 400 }
 401
 402 bool OpenGLSalBitmap::Scale( const double& rScaleX, const double& rScaleY, BmpScaleFlag nScaleFlag )
 403 {
 404     OpenGLVCLContextZone aContextZone;
 405
 406     VCL_GL_INFO("::Scale " << int(nScaleFlag)
 407              << " from " << mnWidth << "x" << mnHeight
 408              << " to " << (mnWidth * rScaleX) << "x" << (mnHeight * rScaleY) );
 409
 410     if( nScaleFlag == BmpScaleFlag::Fast ||
 411         nScaleFlag == BmpScaleFlag::BiLinear ||
 412         nScaleFlag == BmpScaleFlag::Lanczos ||
 413         nScaleFlag == BmpScaleFlag::Default ||
 414         nScaleFlag == BmpScaleFlag::BestQuality )
 415     {
 416         ImplScale( rScaleX, rScaleY, nScaleFlag );
 417         return true;
 418     }
 419
 420     return false;
 421 }
 422
 423 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */