SkImageGenerator.cpp revision 4447b64a88ea141161fca772c2fec28b6141bbc3 
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#include "SkImage.h"
9#include "SkImageGenerator.h"
10#include "SkNextID.h"
11
12SkImageGenerator::SkImageGenerator(const SkImageInfo& info, uint32_t uniqueID)
13    : fInfo(info)
14    , fUniqueID(kNeedNewImageUniqueID == uniqueID ? SkNextID::ImageID() : uniqueID)
15{}
16
17bool SkImageGenerator::getPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
18                                 SkPMColor ctable[], int* ctableCount) {
19    if (kUnknown_SkColorType == info.colorType()) {
20        return false;
21    }
22    if (nullptr == pixels) {
23        return false;
24    }
25    if (rowBytes < info.minRowBytes()) {
26        return false;
27    }
28
29    if (kIndex_8_SkColorType == info.colorType()) {
30        if (nullptr == ctable || nullptr == ctableCount) {
31            return false;
32        }
33    } else {
34        if (ctableCount) {
35            *ctableCount = 0;
36        }
37        ctableCount = nullptr;
38        ctable = nullptr;
39    }
40
41    const bool success = this->onGetPixels(info, pixels, rowBytes, ctable, ctableCount);
42    if (success && ctableCount) {
43        SkASSERT(*ctableCount >= 0 && *ctableCount <= 256);
44    }
45    return success;
46}
47
48bool SkImageGenerator::getPixels(const SkImageInfo& info, void* pixels, size_t rowBytes) {
49    SkASSERT(kIndex_8_SkColorType != info.colorType());
50    if (kIndex_8_SkColorType == info.colorType()) {
51        return false;
52    }
53    return this->getPixels(info, pixels, rowBytes, nullptr, nullptr);
54}
55
56bool SkImageGenerator::queryYUV8(SkYUVSizeInfo* sizeInfo, SkYUVColorSpace* colorSpace) const {
57    SkASSERT(sizeInfo);
58
59    return this->onQueryYUV8(sizeInfo, colorSpace);
60}
61
62bool SkImageGenerator::getYUV8Planes(const SkYUVSizeInfo& sizeInfo, void* planes[3]) {
63    SkASSERT(sizeInfo.fSizes[SkYUVSizeInfo::kY].fWidth >= 0);
64    SkASSERT(sizeInfo.fSizes[SkYUVSizeInfo::kY].fHeight >= 0);
65    SkASSERT(sizeInfo.fSizes[SkYUVSizeInfo::kU].fWidth >= 0);
66    SkASSERT(sizeInfo.fSizes[SkYUVSizeInfo::kU].fHeight >= 0);
67    SkASSERT(sizeInfo.fSizes[SkYUVSizeInfo::kV].fWidth >= 0);
68    SkASSERT(sizeInfo.fSizes[SkYUVSizeInfo::kV].fHeight >= 0);
69    SkASSERT(sizeInfo.fWidthBytes[SkYUVSizeInfo::kY] >=
70            (size_t) sizeInfo.fSizes[SkYUVSizeInfo::kY].fWidth);
71    SkASSERT(sizeInfo.fWidthBytes[SkYUVSizeInfo::kU] >=
72            (size_t) sizeInfo.fSizes[SkYUVSizeInfo::kU].fWidth);
73    SkASSERT(sizeInfo.fWidthBytes[SkYUVSizeInfo::kV] >=
74            (size_t) sizeInfo.fSizes[SkYUVSizeInfo::kV].fWidth);
75    SkASSERT(planes && planes[0] && planes[1] && planes[2]);
76
77    return this->onGetYUV8Planes(sizeInfo, planes);
78}
79
80#if SK_SUPPORT_GPU
81#include "GrTextureProxy.h"
82
83sk_sp<GrTextureProxy> SkImageGenerator::generateTexture(GrContext* ctx, const SkImageInfo& info,
84                                                        const SkIPoint& origin) {
85    SkIRect srcRect = SkIRect::MakeXYWH(origin.x(), origin.y(), info.width(), info.height());
86    if (!SkIRect::MakeWH(fInfo.width(), fInfo.height()).contains(srcRect)) {
87        return nullptr;
88    }
89    return this->onGenerateTexture(ctx, info, origin);
90}
91
92sk_sp<GrTextureProxy> SkImageGenerator::onGenerateTexture(GrContext*, const SkImageInfo&,
93                                                          const SkIPoint&) {
94    return nullptr;
95}
96#endif
97
98/////////////////////////////////////////////////////////////////////////////////////////////
99
100SkData* SkImageGenerator::onRefEncodedData(GrContext* ctx) {
101    return nullptr;
102}
103
104bool SkImageGenerator::onGetPixels(const SkImageInfo& info, void* dst, size_t rb,
105                                   SkPMColor* colors, int* colorCount) {
106    return false;
107}
108
109///////////////////////////////////////////////////////////////////////////////////////////////////
110
111#include "SkBitmap.h"
112#include "SkColorTable.h"
113
114static bool reset_and_return_false(SkBitmap* bitmap) {
115    bitmap->reset();
116    return false;
117}
118
119bool SkImageGenerator::tryGenerateBitmap(SkBitmap* bitmap, const SkImageInfo& info,
120                                         SkBitmap::Allocator* allocator) {
121    if (0 == info.getSafeSize(info.minRowBytes())) {
122        return false;
123    }
124    if (!bitmap->setInfo(info)) {
125        return reset_and_return_false(bitmap);
126    }
127
128    SkPMColor ctStorage[256];
129    memset(ctStorage, 0xFF, sizeof(ctStorage)); // init with opaque-white for the moment
130    sk_sp<SkColorTable> ctable(new SkColorTable(ctStorage, 256));
131    if (!bitmap->tryAllocPixels(allocator, ctable.get())) {
132        // SkResourceCache's custom allcator can'thandle ctables, so it may fail on
133        // kIndex_8_SkColorTable.
134        // https://bug.skia.org/4355
135#if 1
136        // ignore the allocator, and see if we can succeed without it
137        if (!bitmap->tryAllocPixels(nullptr, ctable.get())) {
138            return reset_and_return_false(bitmap);
139        }
140#else
141        // this is the up-scale technique, not fully debugged, but we keep it here at the moment
142        // to remind ourselves that this might be better than ignoring the allocator.
143
144        info = SkImageInfo::MakeN32(info.width(), info.height(), info.alphaType());
145        if (!bitmap->setInfo(info)) {
146            return reset_and_return_false(bitmap);
147        }
148        // we pass nullptr for the ctable arg, since we are now explicitly N32
149        if (!bitmap->tryAllocPixels(allocator, nullptr)) {
150            return reset_and_return_false(bitmap);
151        }
152#endif
153    }
154
155    bitmap->lockPixels();
156    if (!bitmap->getPixels()) {
157        return reset_and_return_false(bitmap);
158    }
159
160    int ctCount = 0;
161    if (!this->getPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(),
162                         ctStorage, &ctCount)) {
163        return reset_and_return_false(bitmap);
164    }
165
166    if (ctCount > 0) {
167        SkASSERT(kIndex_8_SkColorType == bitmap->colorType());
168        // we and bitmap should be owners
169        SkASSERT(!ctable->unique());
170
171        // Now we need to overwrite the ctable we built earlier, with the correct colors.
172        // This does mean that we may have made the table too big, but that cannot be avoided
173        // until we can change SkImageGenerator's API to return us the ctable *before* we have to
174        // allocate space for all the pixels.
175        ctable->dangerous_overwriteColors(ctStorage, ctCount);
176    } else {
177        SkASSERT(kIndex_8_SkColorType != bitmap->colorType());
178        // we should be the only owner
179        SkASSERT(ctable->unique());
180    }
181    return true;
182}
183
184#include "SkGraphics.h"
185
186static SkGraphics::ImageGeneratorFromEncodedDataFactory gFactory;
187
188SkGraphics::ImageGeneratorFromEncodedDataFactory
189SkGraphics::SetImageGeneratorFromEncodedDataFactory(ImageGeneratorFromEncodedDataFactory factory)
190{
191    ImageGeneratorFromEncodedDataFactory prev = gFactory;
192    gFactory = factory;
193    return prev;
194}
195
196std::unique_ptr<SkImageGenerator> SkImageGenerator::MakeFromEncoded(sk_sp<SkData> data) {
197    if (!data) {
198        return nullptr;
199    }
200    if (gFactory) {
201        if (std::unique_ptr<SkImageGenerator> generator = gFactory(data)) {
202            return generator;
203        }
204    }
205    return SkImageGenerator::MakeFromEncodedImpl(std::move(data));
206}
207