Home | History | Annotate | Download | only in utils
      1 /*
      2  * Copyright 2014 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #ifndef SkTextureCompressor_DEFINED
      9 #define SkTextureCompressor_DEFINED
     10 
     11 #include "SkBitmapProcShader.h"
     12 #include "SkImageInfo.h"
     13 
     14 class SkBitmap;
     15 class SkBlitter;
     16 class SkData;
     17 
     18 namespace SkTextureCompressor {
     19     // Various texture compression formats that we support.
     20     enum Format {
     21         // Alpha only formats.
     22         kLATC_Format,       // 4x4 blocks, (de)compresses A8
     23         kR11_EAC_Format,    // 4x4 blocks, (de)compresses A8
     24 
     25         // RGB only formats
     26         kETC1_Format,       // 4x4 blocks, compresses RGB 565, decompresses 8-bit RGB
     27                             //    NOTE: ETC1 supports 8-bit RGB compression, but we
     28                             //    currently don't have any RGB8 SkColorTypes. We could
     29                             //    support 8-bit RGBA but we would have to preprocess the
     30                             //    bitmap to insert alphas.
     31 
     32         // Multi-purpose formats
     33         kASTC_4x4_Format,   // 4x4 blocks, no compression, decompresses RGBA
     34         kASTC_5x4_Format,   // 5x4 blocks, no compression, decompresses RGBA
     35         kASTC_5x5_Format,   // 5x5 blocks, no compression, decompresses RGBA
     36         kASTC_6x5_Format,   // 6x5 blocks, no compression, decompresses RGBA
     37         kASTC_6x6_Format,   // 6x6 blocks, no compression, decompresses RGBA
     38         kASTC_8x5_Format,   // 8x5 blocks, no compression, decompresses RGBA
     39         kASTC_8x6_Format,   // 8x6 blocks, no compression, decompresses RGBA
     40         kASTC_8x8_Format,   // 8x8 blocks, no compression, decompresses RGBA
     41         kASTC_10x5_Format,  // 10x5 blocks, no compression, decompresses RGBA
     42         kASTC_10x6_Format,  // 10x6 blocks, no compression, decompresses RGBA
     43         kASTC_10x8_Format,  // 10x8 blocks, no compression, decompresses RGBA
     44         kASTC_10x10_Format, // 10x10 blocks, no compression, decompresses RGBA
     45         kASTC_12x10_Format, // 12x10 blocks, no compression, decompresses RGBA
     46         kASTC_12x12_Format, // 12x12 blocks, compresses A8, decompresses RGBA
     47 
     48         kLast_Format = kASTC_12x12_Format
     49     };
     50     static const int kFormatCnt = kLast_Format + 1;
     51 
     52     // Returns the size of the compressed data given the width, height, and
     53     // desired compression format. If the width and height are not an appropriate
     54     // multiple of the block size, then this function returns an error (-1).
     55     int GetCompressedDataSize(Format fmt, int width, int height);
     56 
     57     // Returns an SkData holding a blob of compressed data that corresponds
     58     // to the pixmap. If the pixmap colorType cannot be compressed using the
     59     // associated format, then we return nullptr. The caller is responsible for
     60     // calling unref() on the returned data.
     61     SkData* CompressBitmapToFormat(const SkPixmap&, Format format);
     62 
     63     // Compresses the given src data into dst. The src data is assumed to be
     64     // large enough to hold width*height pixels. The dst data is expected to
     65     // be large enough to hold the compressed data according to the format.
     66     bool CompressBufferToFormat(uint8_t* dst, const uint8_t* src, SkColorType srcColorType,
     67                                 int width, int height, size_t rowBytes, Format format);
     68 
     69     // Decompresses the given src data from the format specified into the
     70     // destination buffer. The width and height of the data passed corresponds
     71     // to the width and height of the uncompressed image. The destination buffer (dst)
     72     // is assumed to be large enough to hold the entire decompressed image. The
     73     // decompressed image colors are determined based on the passed format.
     74     //
     75     // Note, CompressBufferToFormat compresses A8 data into ASTC. However,
     76     // general ASTC data encodes RGBA data, so that is what the decompressor
     77     // operates on.
     78     //
     79     // Returns true if successfully decompresses the src data.
     80     bool DecompressBufferFromFormat(uint8_t* dst, int dstRowBytes, const uint8_t* src,
     81                                     int width, int height, Format format);
     82 
     83     // Returns true if there exists a blitter for the specified format.
     84     inline bool ExistsBlitterForFormat(Format format) {
     85         switch (format) {
     86             case kLATC_Format:
     87             case kR11_EAC_Format:
     88             case kASTC_12x12_Format:
     89                 return true;
     90 
     91             default:
     92                 return false;
     93         }
     94     }
     95 
     96     // Returns the blitter for the given compression format. Note, the blitter
     97     // is intended to be used with the proper input. I.e. if you try to blit
     98     // RGB source data into an R11 EAC texture, you're gonna have a bad time.
     99     SkBlitter* CreateBlitterForFormat(int width, int height, void* compressedBuffer,
    100                                       SkTBlitterAllocator *allocator, Format format);
    101 
    102     // Returns the desired dimensions of the block size for the given format. These dimensions
    103     // don't necessarily correspond to the specification's dimensions, since there may
    104     // be specialized algorithms that operate on multiple blocks at once. If the
    105     // flag 'matchSpec' is true, then the actual dimensions from the specification are
    106     // returned. If the flag is false, then these dimensions reflect the appropriate operable
    107     // dimensions of the compression functions.
    108     void GetBlockDimensions(Format format, int* dimX, int* dimY, bool matchSpec = false);
    109 }
    110 
    111 #endif
    112