src/third_party/skia/src/images/SkImageDecoder_libbmp.cpp

   1
   2 /*
   3  * Copyright 2007 The Android Open Source Project
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9
  10 #include "bmpdecoderhelper.h"
  11 #include "SkColorPriv.h"
  12 #include "SkImageDecoder.h"
  13 #include "SkScaledBitmapSampler.h"
  14 #include "SkStream.h"
  15 #include "SkStreamPriv.h"
  16 #include "SkTDArray.h"
  17
  18 class SkBMPImageDecoder : public SkImageDecoder {
  19 public:
  20     SkBMPImageDecoder() {}
  21
  22     virtual Format getFormat() const SK_OVERRIDE {
  23         return kBMP_Format;
  24     }
  25
  26 protected:
  27     virtual Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) SK_OVERRIDE;
  28
  29 private:
  30     typedef SkImageDecoder INHERITED;
  31 };
  32
  33 ///////////////////////////////////////////////////////////////////////////////
  34 DEFINE_DECODER_CREATOR(BMPImageDecoder);
  35 ///////////////////////////////////////////////////////////////////////////////
  36
  37 static bool is_bmp(SkStreamRewindable* stream) {
  38     static const char kBmpMagic[] = { 'B', 'M' };
  39
  40
  41     char buffer[sizeof(kBmpMagic)];
  42
  43     return stream->read(buffer, sizeof(kBmpMagic)) == sizeof(kBmpMagic) &&
  44         !memcmp(buffer, kBmpMagic, sizeof(kBmpMagic));
  45 }
  46
  47 static SkImageDecoder* sk_libbmp_dfactory(SkStreamRewindable* stream) {
  48     if (is_bmp(stream)) {
  49         return SkNEW(SkBMPImageDecoder);
  50     }
  51     return NULL;
  52 }
  53
  54 static SkImageDecoder_DecodeReg gReg(sk_libbmp_dfactory);
  55
  56 static SkImageDecoder::Format get_format_bmp(SkStreamRewindable* stream) {
  57     if (is_bmp(stream)) {
  58         return SkImageDecoder::kBMP_Format;
  59     }
  60     return SkImageDecoder::kUnknown_Format;
  61 }
  62
  63 static SkImageDecoder_FormatReg gFormatReg(get_format_bmp);
  64
  65 ///////////////////////////////////////////////////////////////////////////////
  66
  67 class SkBmpDecoderCallback : public image_codec::BmpDecoderCallback {
  68 public:
  69     // we don't copy the bitmap, just remember the pointer
  70     SkBmpDecoderCallback(bool justBounds) : fJustBounds(justBounds) {}
  71
  72     // override from BmpDecoderCallback
  73     virtual uint8* SetSize(int width, int height) {
  74         fWidth = width;
  75         fHeight = height;
  76         if (fJustBounds) {
  77             return NULL;
  78         }
  79
  80         fRGB.setCount(width * height * 3);  // 3 == r, g, b
  81         return fRGB.begin();
  82     }
  83
  84     int width() const { return fWidth; }
  85     int height() const { return fHeight; }
  86     const uint8_t* rgb() const { return fRGB.begin(); }
  87
  88 private:
  89     SkTDArray<uint8_t> fRGB;
  90     int fWidth;
  91     int fHeight;
  92     bool fJustBounds;
  93 };
  94
  95 SkImageDecoder::Result SkBMPImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
  96     // First read the entire stream, so that all of the data can be passed to
  97     // the BmpDecoderHelper.
  98
  99     // Allocated space used to hold the data.
 100     SkAutoMalloc storage;
 101     // Byte length of all of the data.
 102     const size_t length = SkCopyStreamToStorage(&storage, stream);
 103     if (0 == length) {
 104         return kFailure;
 105     }
 106
 107     const bool justBounds = SkImageDecoder::kDecodeBounds_Mode == mode;
 108     SkBmpDecoderCallback callback(justBounds);
 109
 110     // Now decode the BMP into callback's rgb() array [r,g,b, r,g,b, ...]
 111     {
 112         image_codec::BmpDecoderHelper helper;
 113         const int max_pixels = 16383*16383; // max width*height
 114         if (!helper.DecodeImage((const char*)storage.get(), length,
 115                                 max_pixels, &callback)) {
 116             return kFailure;
 117         }
 118     }
 119
 120     // we don't need this anymore, so free it now (before we try to allocate
 121     // the bitmap's pixels) rather than waiting for its destructor
 122     storage.free();
 123
 124     int width = callback.width();
 125     int height = callback.height();
 126     SkColorType colorType = this->getPrefColorType(k32Bit_SrcDepth, false);
 127
 128     // only accept prefConfig if it makes sense for us
 129     if (kARGB_4444_SkColorType != colorType && kRGB_565_SkColorType != colorType) {
 130         colorType = kN32_SkColorType;
 131     }
 132
 133     SkScaledBitmapSampler sampler(width, height, getSampleSize());
 134
 135     bm->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(),
 136                                   colorType, kOpaque_SkAlphaType));
 137
 138     if (justBounds) {
 139         return kSuccess;
 140     }
 141
 142     if (!this->allocPixelRef(bm, NULL)) {
 143         return kFailure;
 144     }
 145
 146     SkAutoLockPixels alp(*bm);
 147
 148     if (!sampler.begin(bm, SkScaledBitmapSampler::kRGB, *this)) {
 149         return kFailure;
 150     }
 151
 152     const int srcRowBytes = width * 3;
 153     const int dstHeight = sampler.scaledHeight();
 154     const uint8_t* srcRow = callback.rgb();
 155
 156     srcRow += sampler.srcY0() * srcRowBytes;
 157     for (int y = 0; y < dstHeight; y++) {
 158         sampler.next(srcRow);
 159         srcRow += sampler.srcDY() * srcRowBytes;
 160     }
 161     return kSuccess;
 162 }