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
14void 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
22const void* SkRBuffer::skip(size_t size)
23{
24    const void* result = fPos;
25    readNoSizeCheck(NULL, size);
26    return result;
27}
28
29size_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
37bool SkRBufferWithSizeCheck::read(void* buffer, size_t size) {
38    fError = fError || (fPos + size > fStop);
39    if (!fError && (size > 0)) {
40        readNoSizeCheck(buffer, size);
41    }
42    return !fError;
43}
44
45void* SkWBuffer::skip(size_t size)
46{
47    void* result = fPos;
48    writeNoSizeCheck(NULL, size);
49    return fData == NULL ? NULL : result;
50}
51
52void 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
60size_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
88void* 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
95void* 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
104const 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
112const 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
122void* sk_buffer_write_ptr(void* buffer, void* ptr)
123{
124    AssertBuffer32(buffer);
125    *(void**)buffer = ptr;
126    return (char*)buffer + sizeof(void*);
127}
128
129const 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