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