OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkDiscardablePixelRef.h" | 8 #include "SkDiscardablePixelRef.h" |
9 #include "SkDiscardableMemory.h" | 9 #include "SkDiscardableMemory.h" |
10 #include "SkImageGenerator.h" | 10 #include "SkImageGenerator.h" |
11 | 11 |
12 SkDiscardablePixelRef::SkDiscardablePixelRef(SkImageGenerator* generator, | 12 SkDiscardablePixelRef::SkDiscardablePixelRef(const SkImageInfo& info, |
13 const SkImageInfo& info, | 13 SkImageGenerator* generator, |
14 size_t size, | |
15 size_t rowBytes, | 14 size_t rowBytes, |
16 SkDiscardableMemory::Factory* fact) | 15 SkDiscardableMemory::Factory* fact) |
17 : fGenerator(generator) | 16 : INHERITED(info) |
| 17 , fGenerator(generator) |
18 , fDMFactory(fact) | 18 , fDMFactory(fact) |
19 , fInfo(info) | |
20 , fSize(size) | |
21 , fRowBytes(rowBytes) | 19 , fRowBytes(rowBytes) |
22 , fDiscardableMemory(NULL) { | 20 , fDiscardableMemory(NULL) |
| 21 { |
23 SkASSERT(fGenerator != NULL); | 22 SkASSERT(fGenerator != NULL); |
24 SkASSERT(fSize > 0); | |
25 SkASSERT(fRowBytes > 0); | 23 SkASSERT(fRowBytes > 0); |
26 // The SkImageGenerator contract requires fGenerator to always | 24 // The SkImageGenerator contract requires fGenerator to always |
27 // decode the same image on each call to getPixels(). | 25 // decode the same image on each call to getPixels(). |
28 this->setImmutable(); | 26 this->setImmutable(); |
29 SkSafeRef(fDMFactory); | 27 SkSafeRef(fDMFactory); |
30 } | 28 } |
31 | 29 |
32 SkDiscardablePixelRef::~SkDiscardablePixelRef() { | 30 SkDiscardablePixelRef::~SkDiscardablePixelRef() { |
33 if (this->isLocked()) { | 31 if (this->isLocked()) { |
34 fDiscardableMemory->unlock(); | 32 fDiscardableMemory->unlock(); |
35 } | 33 } |
36 SkDELETE(fDiscardableMemory); | 34 SkDELETE(fDiscardableMemory); |
37 SkSafeUnref(fDMFactory); | 35 SkSafeUnref(fDMFactory); |
38 SkDELETE(fGenerator); | 36 SkDELETE(fGenerator); |
39 } | 37 } |
40 | 38 |
41 void* SkDiscardablePixelRef::onLockPixels(SkColorTable**) { | 39 void* SkDiscardablePixelRef::onLockPixels(SkColorTable**) { |
42 if (fDiscardableMemory != NULL) { | 40 if (fDiscardableMemory != NULL) { |
43 if (fDiscardableMemory->lock()) { | 41 if (fDiscardableMemory->lock()) { |
44 return fDiscardableMemory->data(); | 42 return fDiscardableMemory->data(); |
45 } | 43 } |
46 SkDELETE(fDiscardableMemory); | 44 SkDELETE(fDiscardableMemory); |
47 fDiscardableMemory = NULL; | 45 fDiscardableMemory = NULL; |
48 } | 46 } |
| 47 |
| 48 const size_t size = this->info().getSafeSize(fRowBytes); |
| 49 |
49 if (fDMFactory != NULL) { | 50 if (fDMFactory != NULL) { |
50 fDiscardableMemory = fDMFactory->create(fSize); | 51 fDiscardableMemory = fDMFactory->create(size); |
51 } else { | 52 } else { |
52 fDiscardableMemory = SkDiscardableMemory::Create(fSize); | 53 fDiscardableMemory = SkDiscardableMemory::Create(size); |
53 } | 54 } |
54 if (NULL == fDiscardableMemory) { | 55 if (NULL == fDiscardableMemory) { |
55 return NULL; // Memory allocation failed. | 56 return NULL; // Memory allocation failed. |
56 } | 57 } |
57 void* pixels = fDiscardableMemory->data(); | 58 void* pixels = fDiscardableMemory->data(); |
58 if (!fGenerator->getPixels(fInfo, pixels, fRowBytes)) { | 59 if (!fGenerator->getPixels(this->info(), pixels, fRowBytes)) { |
59 fDiscardableMemory->unlock(); | 60 fDiscardableMemory->unlock(); |
60 SkDELETE(fDiscardableMemory); | 61 SkDELETE(fDiscardableMemory); |
61 fDiscardableMemory = NULL; | 62 fDiscardableMemory = NULL; |
62 return NULL; | 63 return NULL; |
63 } | 64 } |
64 return pixels; | 65 return pixels; |
65 } | 66 } |
66 void SkDiscardablePixelRef::onUnlockPixels() { | 67 void SkDiscardablePixelRef::onUnlockPixels() { |
67 fDiscardableMemory->unlock(); | 68 fDiscardableMemory->unlock(); |
68 } | 69 } |
69 | 70 |
70 bool SkInstallDiscardablePixelRef(SkImageGenerator* generator, | 71 bool SkInstallDiscardablePixelRef(SkImageGenerator* generator, |
71 SkBitmap* dst, | 72 SkBitmap* dst, |
72 SkDiscardableMemory::Factory* factory) { | 73 SkDiscardableMemory::Factory* factory) { |
73 SkImageInfo info; | 74 SkImageInfo info; |
74 SkASSERT(generator != NULL); | 75 SkASSERT(generator != NULL); |
75 if ((NULL == generator) | 76 if ((NULL == generator) |
76 || (!generator->getInfo(&info)) | 77 || (!generator->getInfo(&info)) |
77 || (!dst->setConfig(info, 0))) { | 78 || (!dst->setConfig(info, 0))) { |
78 SkDELETE(generator); | 79 SkDELETE(generator); |
79 return false; | 80 return false; |
80 } | 81 } |
81 SkASSERT(dst->config() != SkBitmap::kNo_Config); | 82 SkASSERT(dst->config() != SkBitmap::kNo_Config); |
82 if (dst->empty()) { // Use a normal pixelref. | 83 if (dst->empty()) { // Use a normal pixelref. |
83 SkDELETE(generator); // Do not need this anymore. | 84 SkDELETE(generator); // Do not need this anymore. |
84 return dst->allocPixels(NULL, NULL); | 85 return dst->allocPixels(NULL, NULL); |
85 } | 86 } |
86 SkAutoTUnref<SkDiscardablePixelRef> ref(SkNEW_ARGS(SkDiscardablePixelRef, | 87 SkAutoTUnref<SkDiscardablePixelRef> ref(SkNEW_ARGS(SkDiscardablePixelRef, |
87 (generator, info, | 88 (info, generator, dst->rowBytes(), factory))); |
88 dst->getSize(), | |
89 dst->rowBytes(), | |
90 factory))); | |
91 dst->setPixelRef(ref); | 89 dst->setPixelRef(ref); |
92 return true; | 90 return true; |
93 } | 91 } |
OLD | NEW |