1 /*
2  * Copyright 2011 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 "SkData.h"
9 #include "SkOSFile.h"
10 #include "SkOnce.h"
11 #include "SkReadBuffer.h"
12 #include "SkStream.h"
13 #include "SkWriteBuffer.h"
14 
15 SkData::SkData(const void* ptr, size_t size, ReleaseProc proc, void* context) {
16     fPtr = const_cast<void*>(ptr);
17     fSize = size;
18     fReleaseProc = proc;
19     fReleaseProcContext = context;
20 }
21 
22 /** This constructor means we are inline with our fPtr's contents.
23  *  Thus we set fPtr to point right after this.
24  */
25 SkData::SkData(size_t size) {
26     fPtr = (char*)(this + 1);   // contents are immediately after this
27     fSize = size;
28     fReleaseProc = nullptr;
29     fReleaseProcContext = nullptr;
30 }
31 
32 SkData::~SkData() {
33     if (fReleaseProc) {
34         fReleaseProc(fPtr, fReleaseProcContext);
35     }
36 }
37 
38 bool SkData::equals(const SkData* other) const {
39     if (nullptr == other) {
40         return false;
41     }
42 
43     return fSize == other->fSize && !memcmp(fPtr, other->fPtr, fSize);
44 }
45 
46 size_t SkData::copyRange(size_t offset, size_t length, void* buffer) const {
47     size_t available = fSize;
48     if (offset >= available || 0 == length) {
49         return 0;
50     }
51     available -= offset;
52     if (length > available) {
53         length = available;
54     }
55     SkASSERT(length > 0);
56 
57     memcpy(buffer, this->bytes() + offset, length);
58     return length;
59 }
60 
61 sk_sp<SkData> SkData::PrivateNewWithCopy(const void* srcOrNull, size_t length) {
62     if (0 == length) {
63         return SkData::MakeEmpty();
64     }
65 
66     const size_t actualLength = length + sizeof(SkData);
67     SkASSERT_RELEASE(length < actualLength);  // Check for overflow.
68 
69     void* storage = ::operator new (actualLength);
70     sk_sp<SkData> data(new (storage) SkData(length));
71     if (srcOrNull) {
72         memcpy(data->writable_data(), srcOrNull, length);
73     }
74     return data;
75 }
76 
77 void SkData::DummyReleaseProc(const void*, void*) {}
78 
79 ///////////////////////////////////////////////////////////////////////////////
80 
81 sk_sp<SkData> SkData::MakeEmpty() {
82     static SkOnce once;
83     static SkData* empty;
84 
85     once([]{ empty = new SkData(nullptr, 0, nullptr, nullptr); });
86     return sk_ref_sp(empty);
87 }
88 
89 // assumes fPtr was allocated via sk_malloc
90 static void sk_free_releaseproc(const void* ptr, void*) {
91     sk_free((void*)ptr);
92 }
93 
94 sk_sp<SkData> SkData::MakeFromMalloc(const void* data, size_t length) {
95     return sk_sp<SkData>(new SkData(data, length, sk_free_releaseproc, nullptr));
96 }
97 
98 sk_sp<SkData> SkData::MakeWithCopy(const void* src, size_t length) {
99     SkASSERT(src);
100     return PrivateNewWithCopy(src, length);
101 }
102 
103 sk_sp<SkData> SkData::MakeUninitialized(size_t length) {
104     return PrivateNewWithCopy(nullptr, length);
105 }
106 
107 sk_sp<SkData> SkData::MakeWithProc(const void* ptr, size_t length, ReleaseProc proc, void* ctx) {
108     return sk_sp<SkData>(new SkData(ptr, length, proc, ctx));
109 }
110 
111 // assumes fPtr was allocated with sk_fmmap
112 static void sk_mmap_releaseproc(const void* addr, void* ctx) {
113     size_t length = reinterpret_cast<size_t>(ctx);
114     sk_fmunmap(addr, length);
115 }
116 
117 sk_sp<SkData> SkData::MakeFromFILE(FILE* f) {
118     size_t size;
119     void* addr = sk_fmmap(f, &size);
120     if (nullptr == addr) {
121         return nullptr;
122     }
123 
124     return SkData::MakeWithProc(addr, size, sk_mmap_releaseproc, reinterpret_cast<void*>(size));
125 }
126 
127 sk_sp<SkData> SkData::MakeFromFileName(const char path[]) {
128     FILE* f = path ? sk_fopen(path, kRead_SkFILE_Flag) : nullptr;
129     if (nullptr == f) {
130         return nullptr;
131     }
132     auto data = MakeFromFILE(f);
133     sk_fclose(f);
134     return data;
135 }
136 
137 sk_sp<SkData> SkData::MakeFromFD(int fd) {
138     size_t size;
139     void* addr = sk_fdmmap(fd, &size);
140     if (nullptr == addr) {
141         return nullptr;
142     }
143     return SkData::MakeWithProc(addr, size, sk_mmap_releaseproc, reinterpret_cast<void*>(size));
144 }
145 
146 // assumes context is a SkData
147 static void sk_dataref_releaseproc(const void*, void* context) {
148     SkData* src = reinterpret_cast<SkData*>(context);
149     src->unref();
150 }
151 
152 sk_sp<SkData> SkData::MakeSubset(const SkData* src, size_t offset, size_t length) {
153     /*
154         We could, if we wanted/need to, just make a deep copy of src's data,
155         rather than referencing it. This would duplicate the storage (of the
156         subset amount) but would possibly allow src to go out of scope sooner.
157      */
158 
159     size_t available = src->size();
160     if (offset >= available || 0 == length) {
161         return SkData::MakeEmpty();
162     }
163     available -= offset;
164     if (length > available) {
165         length = available;
166     }
167     SkASSERT(length > 0);
168 
169     src->ref(); // this will be balanced in sk_dataref_releaseproc
170     return sk_sp<SkData>(new SkData(src->bytes() + offset, length, sk_dataref_releaseproc,
171                                     const_cast<SkData*>(src)));
172 }
173 
174 sk_sp<SkData> SkData::MakeWithCString(const char cstr[]) {
175     size_t size;
176     if (nullptr == cstr) {
177         cstr = "";
178         size = 1;
179     } else {
180         size = strlen(cstr) + 1;
181     }
182     return MakeWithCopy(cstr, size);
183 }
184 
185 ///////////////////////////////////////////////////////////////////////////////
186 
187 sk_sp<SkData> SkData::MakeFromStream(SkStream* stream, size_t size) {
188     sk_sp<SkData> data(SkData::MakeUninitialized(size));
189     if (stream->read(data->writable_data(), size) != size) {
190         return nullptr;
191     }
192     return data;
193 }
194