OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2008 The Android Open Source Project | 2 * Copyright 2008 The Android Open Source Project |
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 "SkCGUtils.h" | 8 #include "SkCGUtils.h" |
9 #include "SkColorPriv.h" | 9 #include "SkColorPriv.h" |
10 #include "SkImageDecoder.h" | 10 #include "SkImageDecoder.h" |
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
160 *addr = SkUnPreMultiply::UnPreMultiplyPreservingByteOrder(*addr)
; | 160 *addr = SkUnPreMultiply::UnPreMultiplyPreservingByteOrder(*addr)
; |
161 } | 161 } |
162 } | 162 } |
163 bm->setAlphaType(kUnpremul_SkAlphaType); | 163 bm->setAlphaType(kUnpremul_SkAlphaType); |
164 } | 164 } |
165 return true; | 165 return true; |
166 } | 166 } |
167 | 167 |
168 /////////////////////////////////////////////////////////////////////////////// | 168 /////////////////////////////////////////////////////////////////////////////// |
169 | 169 |
170 extern SkImageDecoder* image_decoder_from_stream(SkStreamRewindable*); | |
171 | |
172 SkImageDecoder* SkImageDecoder::Factory(SkStreamRewindable* stream) { | |
173 SkImageDecoder* decoder = image_decoder_from_stream(stream); | |
174 if (NULL == decoder) { | |
175 // If no image decoder specific to the stream exists, use SkImageDecoder
_CG. | |
176 return SkNEW(SkImageDecoder_CG); | |
177 } else { | |
178 return decoder; | |
179 } | |
180 } | |
181 | |
182 ///////////////////////////////////////////////////////////////////////// | |
183 | |
184 SkMovie* SkMovie::DecodeStream(SkStreamRewindable* stream) { | |
185 return NULL; | |
186 } | |
187 | |
188 ///////////////////////////////////////////////////////////////////////// | |
189 | 170 |
190 static size_t consumer_put(void* info, const void* buffer, size_t count) { | 171 static size_t consumer_put(void* info, const void* buffer, size_t count) { |
191 SkWStream* stream = reinterpret_cast<SkWStream*>(info); | 172 SkWStream* stream = reinterpret_cast<SkWStream*>(info); |
192 return stream->write(buffer, count) ? count : 0; | 173 return stream->write(buffer, count) ? count : 0; |
193 } | 174 } |
194 | 175 |
195 static void consumer_release(void* info) { | 176 static void consumer_release(void* info) { |
196 // we do nothing, since by design we don't "own" the stream (i.e. info) | 177 // we do nothing, since by design we don't "own" the stream (i.e. info) |
197 } | 178 } |
198 | 179 |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
276 CGImageRef image = SkCreateCGImageRef(*bmPtr); | 257 CGImageRef image = SkCreateCGImageRef(*bmPtr); |
277 if (NULL == image) { | 258 if (NULL == image) { |
278 return false; | 259 return false; |
279 } | 260 } |
280 SkAutoTCallVProc<CGImage, CGImageRelease> agimage(image); | 261 SkAutoTCallVProc<CGImage, CGImageRelease> agimage(image); |
281 | 262 |
282 CGImageDestinationAddImage(dst, image, NULL); | 263 CGImageDestinationAddImage(dst, image, NULL); |
283 return CGImageDestinationFinalize(dst); | 264 return CGImageDestinationFinalize(dst); |
284 } | 265 } |
285 | 266 |
286 /////////////////////////////////////////////////////////////////////////////// | 267 SkImageEncoder* SkCreateImageEncoder_CG(Type t) { |
287 | 268 SkImageEncoder* codec = NULL; |
288 static SkImageEncoder* sk_imageencoder_cg_factory(SkImageEncoder::Type t) { | 269 if ((codec = CreateUserEncoder(t))) { |
| 270 return codec; |
| 271 } |
289 switch (t) { | 272 switch (t) { |
| 273 #ifndef SK_BUILD_FOR_IOS |
290 case SkImageEncoder::kICO_Type: | 274 case SkImageEncoder::kICO_Type: |
291 case SkImageEncoder::kBMP_Type: | 275 case SkImageEncoder::kBMP_Type: |
292 case SkImageEncoder::kGIF_Type: | 276 case SkImageEncoder::kGIF_Type: |
293 case SkImageEncoder::kJPEG_Type: | 277 case SkImageEncoder::kJPEG_Type: |
| 278 #endif |
294 case SkImageEncoder::kPNG_Type: | 279 case SkImageEncoder::kPNG_Type: |
295 break; | 280 break; |
296 default: | 281 default: |
297 return NULL; | 282 return NULL; |
298 } | 283 } |
299 return SkNEW_ARGS(SkImageEncoder_CG, (t)); | 284 return SkNEW_ARGS(SkImageEncoder_CG, (t)); |
300 } | 285 } |
301 | 286 |
302 static SkImageEncoder_EncodeReg gEReg(sk_imageencoder_cg_factory); | |
303 | |
304 #ifdef SK_BUILD_FOR_IOS | |
305 class SkPNGImageEncoder_IOS : public SkImageEncoder_CG { | |
306 public: | |
307 SkPNGImageEncoder_IOS() | |
308 : SkImageEncoder_CG(kPNG_Type) { | |
309 } | |
310 }; | |
311 | |
312 DEFINE_ENCODER_CREATOR(PNGImageEncoder_IOS); | |
313 #endif | |
314 | |
315 struct FormatConversion { | 287 struct FormatConversion { |
316 CFStringRef fUTType; | 288 CFStringRef fUTType; |
317 SkImageDecoder::Format fFormat; | 289 SkImageDecoder::Format fFormat; |
318 }; | 290 }; |
319 | 291 |
320 // Array of the types supported by the decoder. | 292 // Array of the types supported by the decoder. |
321 static const FormatConversion gFormatConversions[] = { | 293 static const FormatConversion gFormatConversions[] = { |
322 { kUTTypeBMP, SkImageDecoder::kBMP_Format }, | 294 { kUTTypeBMP, SkImageDecoder::kBMP_Format }, |
323 { kUTTypeGIF, SkImageDecoder::kGIF_Format }, | 295 { kUTTypeGIF, SkImageDecoder::kGIF_Format }, |
324 { kUTTypeICO, SkImageDecoder::kICO_Format }, | 296 { kUTTypeICO, SkImageDecoder::kICO_Format }, |
325 { kUTTypeJPEG, SkImageDecoder::kJPEG_Format }, | 297 { kUTTypeJPEG, SkImageDecoder::kJPEG_Format }, |
326 // Also include JPEG2000 | 298 // Also include JPEG2000 |
327 { kUTTypeJPEG2000, SkImageDecoder::kJPEG_Format }, | 299 { kUTTypeJPEG2000, SkImageDecoder::kJPEG_Format }, |
328 { kUTTypePNG, SkImageDecoder::kPNG_Format }, | 300 { kUTTypePNG, SkImageDecoder::kPNG_Format }, |
329 }; | 301 }; |
330 | 302 |
331 static SkImageDecoder::Format UTType_to_Format(const CFStringRef uttype) { | 303 static SkImageDecoder::Format UTType_to_Format(const CFStringRef uttype) { |
332 for (size_t i = 0; i < SK_ARRAY_COUNT(gFormatConversions); i++) { | 304 for (size_t i = 0; i < SK_ARRAY_COUNT(gFormatConversions); i++) { |
333 if (CFStringCompare(uttype, gFormatConversions[i].fUTType, 0) == kCFComp
areEqualTo) { | 305 if (CFStringCompare(uttype, gFormatConversions[i].fUTType, 0) == kCFComp
areEqualTo) { |
334 return gFormatConversions[i].fFormat; | 306 return gFormatConversions[i].fFormat; |
335 } | 307 } |
336 } | 308 } |
337 return SkImageDecoder::kUnknown_Format; | 309 return SkImageDecoder::kUnknown_Format; |
338 } | 310 } |
339 | 311 |
340 static SkImageDecoder::Format get_format_cg(SkStreamRewindable* stream) { | 312 SkImageDecoder::Format SkDetectFormatImageDecoder_CG(SkStreamRewindable* stream)
{ |
341 CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream); | 313 CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream); |
342 | 314 |
343 if (NULL == imageSrc) { | 315 if (NULL == imageSrc) { |
344 return SkImageDecoder::kUnknown_Format; | 316 return SkImageDecoder::kUnknown_Format; |
345 } | 317 } |
346 | 318 |
347 SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc); | 319 SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc); |
348 const CFStringRef name = CGImageSourceGetType(imageSrc); | 320 const CFStringRef name = CGImageSourceGetType(imageSrc); |
349 if (NULL == name) { | 321 if (NULL == name) { |
350 return SkImageDecoder::kUnknown_Format; | 322 return SkImageDecoder::kUnknown_Format; |
351 } | 323 } |
352 return UTType_to_Format(name); | 324 return UTType_to_Format(name); |
353 } | 325 } |
354 | 326 |
355 static SkImageDecoder_FormatReg gFormatReg(get_format_cg); | 327 SkImageDecoder* SkCreateImageDecoder_CG(SkStreamRewindable* stream) { |
| 328 if (SkDetectFormatImageDecoder_CG(stream) != SkImageDecoder::kUnknown_Format
) { |
| 329 return SkNEW(SkImageDecoder_CG); |
| 330 } |
| 331 return NULL; |
| 332 } |
OLD | NEW |