Big Cleanup: SkBitmapFactory, SkLazyPixelRef, SkImageCache

include/core/SkImageDecoder.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkImageDecoder_DEFINED
 #define SkImageDecoder_DEFINED
 
 #include "SkBitmap.h"
-#include "SkBitmapFactory.h"
 #include "SkImage.h"
 #include "SkRect.h"
 #include "SkRefCnt.h"
 #include "SkTRegistry.h"
 #include "SkTypes.h"
 
 class SkStream;
 class SkStreamRewindable;
 
 /** \class SkImageDecoder
@@ skipping 304 matching lines @@
      */
     static bool DecodeMemory(const void* buffer, size_t size, SkBitmap* bitmap,
                              SkBitmap::Config prefConfig, Mode,
                              Format* format = NULL);
     static bool DecodeMemory(const void* buffer, size_t size, SkBitmap* bitmap){
         return DecodeMemory(buffer, size, bitmap, SkBitmap::kNo_Config,
                             kDecodePixels_Mode, NULL);
     }
 
     /**
+     *  Struct containing information about a pixel destination.
+     */
+    struct Target {
+        /**
+         *  Pre-allocated memory.
+         */
+        void*  fAddr;
+
+        /**
+         *  Rowbytes of the allocated memory.
+         */
+        size_t fRowBytes;
+    };
+
+    /**
      *  Decode memory.
      *  @param info Output parameter. Returns info about the encoded image.
      *  @param target Contains the address of pixel memory to decode into
      *         (which must be large enough to hold the width in info) and
      *         the row bytes to use. If NULL, returns info and does not
      *         decode pixels.
      *  @return bool Whether the function succeeded.
      *
      *  Sample usage:
      *  <code>
      *      // Determine the image's info: width/height/config
      *      SkImageInfo info;
      *      bool success = DecodeMemoryToTarget(src, size, &info, NULL);
      *      if (!success) return;
      *      // Allocate space for the result:
      *      SkBitmapFactory::Target target;
      *      target.fAddr = malloc/other allocation
      *      target.fRowBytes = ...
      *      // Now decode the actual pixels into target. &info is optional,
      *      // and could be NULL
      *      success = DecodeMemoryToTarget(src, size, &info, &target);
      *  </code>
      */
     static bool DecodeMemoryToTarget(const void* buffer, size_t size, SkImageInfo* info,
-                                     const SkBitmapFactory::Target* target);
+                                     const Target* target);
 
     /** Decode the image stored in the specified SkStreamRewindable, and store the result
         in bitmap. Return true for success or false on failure.
 
         @param prefConfig If the PrefConfigTable is not set, prefer this config.
                           See NOTE ABOUT PREFERRED CONFIGS.
 
         @param format On success, if format is non-null, it is set to the format
                       of the decoded stream. On failure it is ignored.
      */
@@ skipping 173 matching lines @@
 DECLARE_DECODER_CREATOR(WBMPImageDecoder);
 DECLARE_DECODER_CREATOR(WEBPImageDecoder);
 
 
 // Typedefs to make registering decoder and formatter callbacks easier.
 // These have to be defined outside SkImageDecoder. :(
 typedef SkTRegistry<SkImageDecoder*(*)(SkStreamRewindable*)>        SkImageDecoder_DecodeReg;
 typedef SkTRegistry<SkImageDecoder::Format(*)(SkStreamRewindable*)> SkImageDecoder_FormatReg;
 
 #endif