1/*
2 * Copyright 2013 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 "GrGLBufferImpl.h"
9#include "GrGpuGL.h"
10
11#define GL_CALL(GPU, X) GR_GL_CALL(GPU->glInterface(), X)
12
13#ifdef SK_DEBUG
14#define VALIDATE() this->validate()
15#else
16#define VALIDATE() do {} while(false)
17#endif
18
19// GL_STREAM_DRAW triggers an optimization in Chromium's GPU process where a client's vertex buffer
20// objects are implemented as client-side-arrays on tile-deferred architectures.
21#define DYNAMIC_USAGE_PARAM GR_GL_STREAM_DRAW
22
23GrGLBufferImpl::GrGLBufferImpl(GrGpuGL* gpu, const Desc& desc, GrGLenum bufferType)
24    : fDesc(desc)
25    , fBufferType(bufferType)
26    , fMapPtr(NULL) {
27    if (0 == desc.fID) {
28        fCPUData = sk_malloc_flags(desc.fSizeInBytes, SK_MALLOC_THROW);
29        fGLSizeInBytes = 0;
30    } else {
31        fCPUData = NULL;
32        // We assume that the GL buffer was created at the desc's size initially.
33        fGLSizeInBytes = fDesc.fSizeInBytes;
34    }
35    VALIDATE();
36}
37
38void GrGLBufferImpl::release(GrGpuGL* gpu) {
39    VALIDATE();
40    // make sure we've not been abandoned or already released
41    if (fCPUData) {
42        sk_free(fCPUData);
43        fCPUData = NULL;
44    } else if (fDesc.fID && !fDesc.fIsWrapped) {
45        GL_CALL(gpu, DeleteBuffers(1, &fDesc.fID));
46        if (GR_GL_ARRAY_BUFFER == fBufferType) {
47            gpu->notifyVertexBufferDelete(fDesc.fID);
48        } else {
49            SkASSERT(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
50            gpu->notifyIndexBufferDelete(fDesc.fID);
51        }
52        fDesc.fID = 0;
53        fGLSizeInBytes = 0;
54    }
55    fMapPtr = NULL;
56    VALIDATE();
57}
58
59void GrGLBufferImpl::abandon() {
60    fDesc.fID = 0;
61    fGLSizeInBytes = 0;
62    fMapPtr = NULL;
63    sk_free(fCPUData);
64    fCPUData = NULL;
65    VALIDATE();
66}
67
68void GrGLBufferImpl::bind(GrGpuGL* gpu) const {
69    VALIDATE();
70    if (GR_GL_ARRAY_BUFFER == fBufferType) {
71        gpu->bindVertexBuffer(fDesc.fID);
72    } else {
73        SkASSERT(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
74        gpu->bindIndexBufferAndDefaultVertexArray(fDesc.fID);
75    }
76    VALIDATE();
77}
78
79void* GrGLBufferImpl::map(GrGpuGL* gpu) {
80    VALIDATE();
81    SkASSERT(!this->isMapped());
82    if (0 == fDesc.fID) {
83        fMapPtr = fCPUData;
84    } else {
85        switch (gpu->glCaps().mapBufferType()) {
86            case GrGLCaps::kNone_MapBufferType:
87                VALIDATE();
88                return NULL;
89            case GrGLCaps::kMapBuffer_MapBufferType:
90                this->bind(gpu);
91                // Let driver know it can discard the old data
92                if (GR_GL_USE_BUFFER_DATA_NULL_HINT || fDesc.fSizeInBytes != fGLSizeInBytes) {
93                    fGLSizeInBytes = fDesc.fSizeInBytes;
94                    GL_CALL(gpu,
95                            BufferData(fBufferType, fGLSizeInBytes, NULL,
96                                       fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW));
97                }
98                GR_GL_CALL_RET(gpu->glInterface(), fMapPtr,
99                               MapBuffer(fBufferType, GR_GL_WRITE_ONLY));
100                break;
101            case GrGLCaps::kMapBufferRange_MapBufferType: {
102                this->bind(gpu);
103                // Make sure the GL buffer size agrees with fDesc before mapping.
104                if (fDesc.fSizeInBytes != fGLSizeInBytes) {
105                    fGLSizeInBytes = fDesc.fSizeInBytes;
106                    GL_CALL(gpu,
107                            BufferData(fBufferType, fGLSizeInBytes, NULL,
108                                       fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW));
109                }
110                static const GrGLbitfield kAccess = GR_GL_MAP_INVALIDATE_BUFFER_BIT |
111                                                    GR_GL_MAP_WRITE_BIT;
112                GR_GL_CALL_RET(gpu->glInterface(),
113                               fMapPtr,
114                               MapBufferRange(fBufferType, 0, fGLSizeInBytes, kAccess));
115                break;
116            }
117            case GrGLCaps::kChromium_MapBufferType:
118                this->bind(gpu);
119                // Make sure the GL buffer size agrees with fDesc before mapping.
120                if (fDesc.fSizeInBytes != fGLSizeInBytes) {
121                    fGLSizeInBytes = fDesc.fSizeInBytes;
122                    GL_CALL(gpu,
123                            BufferData(fBufferType, fGLSizeInBytes, NULL,
124                                       fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW));
125                }
126                GR_GL_CALL_RET(gpu->glInterface(),
127                               fMapPtr,
128                               MapBufferSubData(fBufferType, 0, fGLSizeInBytes, GR_GL_WRITE_ONLY));
129                break;
130        }
131    }
132    VALIDATE();
133    return fMapPtr;
134}
135
136void GrGLBufferImpl::unmap(GrGpuGL* gpu) {
137    VALIDATE();
138    SkASSERT(this->isMapped());
139    if (0 != fDesc.fID) {
140        switch (gpu->glCaps().mapBufferType()) {
141            case GrGLCaps::kNone_MapBufferType:
142                SkDEBUGFAIL("Shouldn't get here.");
143                return;
144            case GrGLCaps::kMapBuffer_MapBufferType: // fall through
145            case GrGLCaps::kMapBufferRange_MapBufferType:
146                this->bind(gpu);
147                GL_CALL(gpu, UnmapBuffer(fBufferType));
148                break;
149            case GrGLCaps::kChromium_MapBufferType:
150                this->bind(gpu);
151                GR_GL_CALL(gpu->glInterface(), UnmapBufferSubData(fMapPtr));
152                break;
153        }
154    }
155    fMapPtr = NULL;
156}
157
158bool GrGLBufferImpl::isMapped() const {
159    VALIDATE();
160    return SkToBool(fMapPtr);
161}
162
163bool GrGLBufferImpl::updateData(GrGpuGL* gpu, const void* src, size_t srcSizeInBytes) {
164    SkASSERT(!this->isMapped());
165    VALIDATE();
166    if (srcSizeInBytes > fDesc.fSizeInBytes) {
167        return false;
168    }
169    if (0 == fDesc.fID) {
170        memcpy(fCPUData, src, srcSizeInBytes);
171        return true;
172    }
173    this->bind(gpu);
174    GrGLenum usage = fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW;
175
176#if GR_GL_USE_BUFFER_DATA_NULL_HINT
177    if (fDesc.fSizeInBytes == srcSizeInBytes) {
178        GL_CALL(gpu, BufferData(fBufferType, (GrGLsizeiptr) srcSizeInBytes, src, usage));
179    } else {
180        // Before we call glBufferSubData we give the driver a hint using
181        // glBufferData with NULL. This makes the old buffer contents
182        // inaccessible to future draws. The GPU may still be processing
183        // draws that reference the old contents. With this hint it can
184        // assign a different allocation for the new contents to avoid
185        // flushing the gpu past draws consuming the old contents.
186        fGLSizeInBytes = fDesc.fSizeInBytes;
187        GL_CALL(gpu, BufferData(fBufferType, fGLSizeInBytes, NULL, usage));
188        GL_CALL(gpu, BufferSubData(fBufferType, 0, (GrGLsizeiptr) srcSizeInBytes, src));
189    }
190#else
191    // Note that we're cheating on the size here. Currently no methods
192    // allow a partial update that preserves contents of non-updated
193    // portions of the buffer (map() does a glBufferData(..size, NULL..))
194    bool doSubData = false;
195#if GR_GL_MAC_BUFFER_OBJECT_PERFOMANCE_WORKAROUND
196    static int N = 0;
197    // 128 was chosen experimentally. At 256 a slight hitchiness was noticed
198    // when dragging a Chromium window around with a canvas tab backgrounded.
199    doSubData = 0 == (N % 128);
200    ++N;
201#endif
202    if (doSubData) {
203        // The workaround is to do a glBufferData followed by glBufferSubData.
204        // Chromium's command buffer may turn a glBufferSubData where the size
205        // exactly matches the buffer size into a glBufferData. So we tack 1
206        // extra byte onto the glBufferData.
207        fGLSizeInBytes = srcSizeInBytes + 1;
208        GL_CALL(gpu, BufferData(fBufferType, fGLSizeInBytes, NULL, usage));
209        GL_CALL(gpu, BufferSubData(fBufferType, 0, srcSizeInBytes, src));
210    } else {
211        fGLSizeInBytes = srcSizeInBytes;
212        GL_CALL(gpu, BufferData(fBufferType, fGLSizeInBytes, src, usage));
213    }
214#endif
215    return true;
216}
217
218void GrGLBufferImpl::validate() const {
219    SkASSERT(GR_GL_ARRAY_BUFFER == fBufferType || GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
220    // The following assert isn't valid when the buffer has been abandoned:
221    // SkASSERT((0 == fDesc.fID) == (fCPUData));
222    SkASSERT(0 != fDesc.fID || !fDesc.fIsWrapped);
223    SkASSERT(NULL == fCPUData || 0 == fGLSizeInBytes);
224    SkASSERT(NULL == fMapPtr || fCPUData || fGLSizeInBytes == fDesc.fSizeInBytes);
225    SkASSERT(NULL == fCPUData || NULL == fMapPtr || fCPUData == fMapPtr);
226}
227