1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
#include "cru/platform/graphics/quartz/ImageFactory.h"
#include "cru/base/Exception.h"
#include "cru/base/Osx.h"
#include "cru/platform/Check.h"
#include "cru/platform/graphics/Image.h"
#include "cru/platform/graphics/quartz/Convert.h"
#include "cru/platform/graphics/quartz/Image.h"
#include <ImageIO/ImageIO.h>
namespace cru::platform::graphics::quartz {
QuartzImageFactory::QuartzImageFactory(IGraphicsFactory* graphics_factory)
: OsxQuartzResource(graphics_factory) {}
QuartzImageFactory::~QuartzImageFactory() {}
std::unique_ptr<IImage> QuartzImageFactory::DecodeFromStream(
io::Stream* stream) {
CGDataProviderRef data_provider = ConvertStreamToCGDataProvider(stream);
CGImageSourceRef image_source =
CGImageSourceCreateWithDataProvider(data_provider, nullptr);
CGImageRef cg_image =
CGImageSourceCreateImageAtIndex(image_source, 0, nullptr);
CFRelease(image_source);
CGDataProviderRelease(data_provider);
return std::unique_ptr<IImage>(
new QuartzImage(GetGraphicsFactory(), this, cg_image, true));
}
static String GetImageFormatUniformTypeIdentifier(ImageFormat format) {
switch (format) {
case ImageFormat::Png:
return u"public.png";
case ImageFormat::Jpeg:
return u"public.jpeg";
case ImageFormat::Gif:
return u"com.compuserve.gif";
default:
throw Exception(u"Unknown image format.");
}
}
void QuartzImageFactory::EncodeToStream(IImage* image, io::Stream* stream,
ImageFormat format, float quality) {
if (quality <= 0 || quality > 1) {
throw Exception(u"Invalid quality value.");
}
auto quartz_image = CheckPlatform<QuartzImage>(image, GetPlatformId());
auto cg_image = quartz_image->GetCGImage();
auto uti = ToCFStringRef(GetImageFormatUniformTypeIdentifier(format));
CGDataConsumerRef data_consumer = ConvertStreamToCGDataConsumer(stream);
CGImageDestinationRef destination = CGImageDestinationCreateWithDataConsumer(
data_consumer, uti.ref, 1, nullptr);
CFMutableDictionaryRef properties =
CFDictionaryCreateMutable(nullptr, 0, nullptr, nullptr);
CFNumberRef quality_wrap =
CFNumberCreate(nullptr, kCFNumberFloatType, &quality);
CFDictionaryAddValue(properties, kCGImageDestinationLossyCompressionQuality,
quality_wrap);
CGImageDestinationAddImage(destination, cg_image, properties);
if (!CGImageDestinationFinalize(destination)) {
throw Exception(u"Failed to finalize image destination.");
}
CFRelease(quality_wrap);
CFRelease(properties);
CFRelease(destination);
CFRelease(data_consumer);
}
std::unique_ptr<IImage> QuartzImageFactory::CreateBitmap(int width,
int height) {
if (width <= 0) throw Exception(u"Image width should be greater than 0.");
if (height <= 0) throw Exception(u"Image height should be greater than 0.");
CGColorSpaceRef color_space = CGColorSpaceCreateDeviceRGB();
const auto buffer_size = width * height * 4;
auto buffer = new unsigned char[buffer_size]{0};
auto cg_data_provider = CGDataProviderCreateWithData(
nullptr, buffer, buffer_size,
[](void* info, const void* data, size_t size) {
delete[] static_cast<const unsigned char*>(data);
});
auto cg_image =
CGImageCreate(width, height, 8, 32, 4 * width, color_space,
kCGImageAlphaPremultipliedLast, cg_data_provider, nullptr,
true, kCGRenderingIntentDefault);
CGColorSpaceRelease(color_space);
CGDataProviderRelease(cg_data_provider);
return std::unique_ptr<IImage>(
new QuartzImage(GetGraphicsFactory(), this, cg_image, true, buffer));
}
} // namespace cru::platform::graphics::quartz
|
