1 /*
2 * Copyright 2006 The Android Open Source Project
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 "SkBuffer.h"
9
10 #include <string.h>
11
12 ////////////////////////////////////////////////////////////////////////////////////////
13
readNoSizeCheck(void * buffer,size_t size)14 void SkRBuffer::readNoSizeCheck(void* buffer, size_t size)
15 {
16 SkASSERT((fData != 0 && fStop == 0) || fPos + size <= fStop);
17 if (buffer)
18 memcpy(buffer, fPos, size);
19 fPos += size;
20 }
21
skip(size_t size)22 const void* SkRBuffer::skip(size_t size)
23 {
24 const void* result = fPos;
25 readNoSizeCheck(nullptr, size);
26 return result;
27 }
28
skipToAlign4()29 size_t SkRBuffer::skipToAlign4()
30 {
31 size_t pos = this->pos();
32 size_t n = SkAlign4(pos) - pos;
33 fPos += n;
34 return n;
35 }
36
read(void * buffer,size_t size)37 bool SkRBufferWithSizeCheck::read(void* buffer, size_t size) {
38 fError = fError || (size > static_cast<size_t>(fStop - fPos));
39 if (!fError && (size > 0)) {
40 readNoSizeCheck(buffer, size);
41 }
42 return !fError;
43 }
44
skip(size_t size)45 void* SkWBuffer::skip(size_t size)
46 {
47 void* result = fPos;
48 writeNoSizeCheck(nullptr, size);
49 return fData == nullptr ? nullptr : result;
50 }
51
writeNoSizeCheck(const void * buffer,size_t size)52 void SkWBuffer::writeNoSizeCheck(const void* buffer, size_t size)
53 {
54 SkASSERT(fData == 0 || fStop == 0 || fPos + size <= fStop);
55 if (fData && buffer)
56 memcpy(fPos, buffer, size);
57 fPos += size;
58 }
59
padToAlign4()60 size_t SkWBuffer::padToAlign4()
61 {
62 size_t pos = this->pos();
63 size_t n = SkAlign4(pos) - pos;
64
65 if (n && fData)
66 {
67 char* p = fPos;
68 char* stop = p + n;
69 do {
70 *p++ = 0;
71 } while (p < stop);
72 }
73 fPos += n;
74 return n;
75 }
76
77 #if 0
78 #ifdef SK_DEBUG
79 static void AssertBuffer32(const void* buffer)
80 {
81 SkASSERT(buffer);
82 SkASSERT(((size_t)buffer & 3) == 0);
83 }
84 #else
85 #define AssertBuffer32(buffer)
86 #endif
87
88 void* sk_buffer_write_int32(void* buffer, int32_t value)
89 {
90 AssertBuffer32(buffer);
91 *(int32_t*)buffer = value;
92 return (char*)buffer + sizeof(int32_t);
93 }
94
95 void* sk_buffer_write_int32(void* buffer, const int32_t values[], int count)
96 {
97 AssertBuffer32(buffer);
98 SkASSERT(count >= 0);
99
100 memcpy((int32_t*)buffer, values, count * sizeof(int32_t));
101 return (char*)buffer + count * sizeof(int32_t);
102 }
103
104 const void* sk_buffer_read_int32(const void* buffer, int32_t* value)
105 {
106 AssertBuffer32(buffer);
107 if (value)
108 *value = *(const int32_t*)buffer;
109 return (const char*)buffer + sizeof(int32_t);
110 }
111
112 const void* sk_buffer_read_int32(const void* buffer, int32_t values[], int count)
113 {
114 AssertBuffer32(buffer);
115 SkASSERT(count >= 0);
116
117 if (values)
118 memcpy(values, (const int32_t*)buffer, count * sizeof(int32_t));
119 return (const char*)buffer + count * sizeof(int32_t);
120 }
121
122 void* sk_buffer_write_ptr(void* buffer, void* ptr)
123 {
124 AssertBuffer32(buffer);
125 *(void**)buffer = ptr;
126 return (char*)buffer + sizeof(void*);
127 }
128
129 const void* sk_buffer_read_ptr(const void* buffer, void** ptr)
130 {
131 AssertBuffer32(buffer);
132 if (ptr)
133 *ptr = *(void**)buffer;
134 return (const char*)buffer + sizeof(void*);
135 }
136
137 #endif
138