Refactor texture compressors into separate files

src/utils/SkTextureCompressor.h

Index: src/utils/SkTextureCompressor.h
diff --git a/src/utils/SkTextureCompressor.h b/src/utils/SkTextureCompressor.h
index ea57934c642d8a1cbe8cf5a5aefe0e3c24f73535..a7afe0384b041f196b3bccb4baf1d66e32241d34 100644
--- a/src/utils/SkTextureCompressor.h
+++ b/src/utils/SkTextureCompressor.h
@@ -18,13 +18,18 @@ namespace SkTextureCompressor {
     // Various texture compression formats that we support.
     enum Format {
         // Alpha only formats.
-        kLATC_Format,
-        kR11_EAC_Format,
+        kLATC_Format,    // 4x4 blocks, compresses A8
+        kR11_EAC_Format, // 4x4 blocks, compresses A8
 
         kLast_Format = kR11_EAC_Format
     };
     static const int kFormatCnt = kLast_Format + 1;
 
+    // Returns the size of the compressed data given the width, height, and
+    // desired compression format. If the width and height are not an appropriate
+    // multiple of the block size, then this function returns an error (-1).
+    int GetCompressedDataSize(Format fmt, int width, int height);
+
     // Returns an SkData holding a blob of compressed data that corresponds
     // to the bitmap. If the bitmap colorType cannot be compressed using the 
     // associated format, then we return NULL. The caller is responsible for
@@ -44,166 +49,11 @@ namespace SkTextureCompressor {
     typedef bool (*CompressionProc)(uint8_t* dst, const uint8_t* src,
                                     int width, int height, int rowBytes);
 
-    // This class implements a blitter that blits directly into a buffer that will
-    // be used as an R11 EAC compressed texture. We compute this buffer by
-    // buffering four scan lines and then outputting them all at once. This blitter
-    // is only expected to be used with alpha masks, i.e. kAlpha8_SkColorType.
-    class R11_EACBlitter : public SkBlitter {
-    public:
-        R11_EACBlitter(int width, int height, void *compressedBuffer);
-        virtual ~R11_EACBlitter() { this->flushRuns(); }
-
-        // Blit a horizontal run of one or more pixels.
-        virtual void blitH(int x, int y, int width) SK_OVERRIDE {
-            // This function is intended to be called from any standard RGB
-            // buffer, so we should never encounter it. However, if some code
-            // path does end up here, then this needs to be investigated.
-            SkFAIL("Not implemented!");
-        }
-
-        /// Blit a horizontal run of antialiased pixels; runs[] is a *sparse*
-        /// zero-terminated run-length encoding of spans of constant alpha values.
-        virtual void blitAntiH(int x, int y,
-                               const SkAlpha antialias[],
-                               const int16_t runs[]) SK_OVERRIDE;
-
-        // Blit a vertical run of pixels with a constant alpha value.
-        virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
-            // This function is currently not implemented. It is not explicitly
-            // required by the contract, but if at some time a code path runs into
-            // this function (which is entirely possible), it needs to be implemented.
-            //
-            // TODO (krajcevski):
-            // This function will be most easily implemented in one of two ways:
-            // 1. Buffer each vertical column value and then construct a list
-            //    of alpha values and output all of the blocks at once. This only
-            //    requires a write to the compressed buffer
-            // 2. Replace the indices of each block with the proper indices based
-            //    on the alpha value. This requires a read and write of the compressed
-            //    buffer, but much less overhead.
-            SkFAIL("Not implemented!");
-        }
-
-        // Blit a solid rectangle one or more pixels wide.
-        virtual void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
-            // Analogous to blitRow, this function is intended for RGB targets
-            // and should never be called by this blitter. Any calls to this function
-            // are probably a bug and should be investigated.
-            SkFAIL("Not implemented!");
-        }
-
-        // Blit a rectangle with one alpha-blended column on the left,
-        // width (zero or more) opaque pixels, and one alpha-blended column
-        // on the right. The result will always be at least two pixels wide.
-        virtual void blitAntiRect(int x, int y, int width, int height,
-                                  SkAlpha leftAlpha, SkAlpha rightAlpha) SK_OVERRIDE {
-            // This function is currently not implemented. It is not explicitly
-            // required by the contract, but if at some time a code path runs into
-            // this function (which is entirely possible), it needs to be implemented.
-            //
-            // TODO (krajcevski):
-            // This function will be most easily implemented as follows:
-            // 1. If width/height are smaller than a block, then update the
-            //    indices of the affected blocks.
-            // 2. If width/height are larger than a block, then construct a 9-patch
-            //    of block encodings that represent the rectangle, and write them
-            //    to the compressed buffer as necessary. Whether or not the blocks
-            //    are overwritten by zeros or just their indices are updated is up
-            //    to debate.
-            SkFAIL("Not implemented!");
-        }
-
-        // Blit a pattern of pixels defined by a rectangle-clipped mask;
-        // typically used for text.
-        virtual void blitMask(const SkMask&, const SkIRect& clip) SK_OVERRIDE {
-            // This function is currently not implemented. It is not explicitly
-            // required by the contract, but if at some time a code path runs into
-            // this function (which is entirely possible), it needs to be implemented.
-            //
-            // TODO (krajcevski):
-            // This function will be most easily implemented in the same way as
-            // blitAntiRect above.
-            SkFAIL("Not implemented!");
-        }
-
-        // If the blitter just sets a single value for each pixel, return the
-        // bitmap it draws into, and assign value. If not, return NULL and ignore
-        // the value parameter.
-        virtual const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE {
-            return NULL;
-        }
-
-        /**
-         * Compressed texture blitters only really work correctly if they get
-         * four blocks at a time. That being said, this blitter tries it's best
-         * to preserve semantics if blitAntiH doesn't get called in too many
-         * weird ways...
-         */
-        virtual int requestRowsPreserved() const { return kR11_EACBlockSz; }
-
-    protected:
-        virtual void onNotifyFinished() { this->flushRuns(); }
-
-    private:
-        static const int kR11_EACBlockSz = 4;
-        static const int kPixelsPerBlock = kR11_EACBlockSz * kR11_EACBlockSz;
-
-        // The longest possible run of pixels that this blitter will receive.
-        // This is initialized in the constructor to 0x7FFE, which is one less
-        // than the largest positive 16-bit integer. We make sure that it's one
-        // less for debugging purposes. We also don't make this variable static
-        // in order to make sure that we can construct a valid pointer to it.
-        const int16_t kLongestRun;
-
-        // Usually used in conjunction with kLongestRun. This is initialized to
-        // zero.
-        const SkAlpha kZeroAlpha;
-
-        // This is the information that we buffer whenever we're asked to blit
-        // a row with this blitter.
-        struct BufferedRun {
-            const SkAlpha* fAlphas;
-            const int16_t* fRuns;
-            int fX, fY;
-        } fBufferedRuns[kR11_EACBlockSz];
-
-        // The next row (0-3) that we need to blit. This value should never exceed
-        // the number of rows that we have (kR11_EACBlockSz)
-        int fNextRun;
-
-        // The width and height of the image that we're blitting
-        const int fWidth;
-        const int fHeight;
-
-        // The R11 EAC buffer that we're blitting into. It is assumed that the buffer
-        // is large enough to store a compressed image of size fWidth*fHeight.
-        uint64_t* const fBuffer;
-
-        // Various utility functions
-        int blocksWide() const { return fWidth / kR11_EACBlockSz; }
-        int blocksTall() const { return fHeight / kR11_EACBlockSz; }
-        int totalBlocks() const { return (fWidth * fHeight) / kPixelsPerBlock; }
-
-        // Returns the block index for the block containing pixel (x, y). Block
-        // indices start at zero and proceed in raster order.
-        int getBlockOffset(int x, int y) const {
-            SkASSERT(x < fWidth);
-            SkASSERT(y < fHeight);
-            const int blockCol = x / kR11_EACBlockSz;
-            const int blockRow = y / kR11_EACBlockSz;
-            return blockRow * this->blocksWide() + blockCol;
-        }
-
-        // Returns a pointer to the block containing pixel (x, y)
-        uint64_t *getBlock(int x, int y) const {
-            return fBuffer + this->getBlockOffset(x, y);
-        }
-
-        // The following function writes the buffered runs to compressed blocks.
-        // If fNextRun < 4, then we fill the runs that we haven't buffered with
-        // the constant zero buffer.
-        void flushRuns();
-    };
+    // Returns the blitter for the given compression format. Note, the blitter
+    // is intended to be used with the proper input. I.e. if you try to blit
+    // RGB source data into an R11 EAC texture, you're gonna have a bad time.
+    SkBlitter* CreateBlitterForFormat(int width, int height, void* compressedBuffer,
+                                      Format format);
 }
 
 #endif