rsdAllocation.cpp revision dbe66d6783c1e53cd1572de0ef6ef6fdf6f76f48 
1/*
2 * Copyright (C) 2011-2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17
18#include "rsdCore.h"
19#include "rsdRuntime.h"
20#include "rsdAllocation.h"
21#include "rsdFrameBufferObj.h"
22
23#include "rsAllocation.h"
24
25#include "system/window.h"
26#include "hardware/gralloc.h"
27#include "ui/Rect.h"
28#include "ui/GraphicBufferMapper.h"
29#include "gui/SurfaceTexture.h"
30
31#include <GLES/gl.h>
32#include <GLES2/gl2.h>
33#include <GLES/glext.h>
34
35using namespace android;
36using namespace android::renderscript;
37
38
39
40const static GLenum gFaceOrder[] = {
41    GL_TEXTURE_CUBE_MAP_POSITIVE_X,
42    GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
43    GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
44    GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
45    GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
46    GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
47};
48
49
50GLenum rsdTypeToGLType(RsDataType t) {
51    switch (t) {
52    case RS_TYPE_UNSIGNED_5_6_5:    return GL_UNSIGNED_SHORT_5_6_5;
53    case RS_TYPE_UNSIGNED_5_5_5_1:  return GL_UNSIGNED_SHORT_5_5_5_1;
54    case RS_TYPE_UNSIGNED_4_4_4_4:  return GL_UNSIGNED_SHORT_4_4_4_4;
55
56    //case RS_TYPE_FLOAT_16:      return GL_HALF_FLOAT;
57    case RS_TYPE_FLOAT_32:      return GL_FLOAT;
58    case RS_TYPE_UNSIGNED_8:    return GL_UNSIGNED_BYTE;
59    case RS_TYPE_UNSIGNED_16:   return GL_UNSIGNED_SHORT;
60    case RS_TYPE_SIGNED_8:      return GL_BYTE;
61    case RS_TYPE_SIGNED_16:     return GL_SHORT;
62    default:    break;
63    }
64    return 0;
65}
66
67GLenum rsdKindToGLFormat(RsDataKind k) {
68    switch (k) {
69    case RS_KIND_PIXEL_L: return GL_LUMINANCE;
70    case RS_KIND_PIXEL_A: return GL_ALPHA;
71    case RS_KIND_PIXEL_LA: return GL_LUMINANCE_ALPHA;
72    case RS_KIND_PIXEL_RGB: return GL_RGB;
73    case RS_KIND_PIXEL_RGBA: return GL_RGBA;
74    case RS_KIND_PIXEL_DEPTH: return GL_DEPTH_COMPONENT16;
75    default: break;
76    }
77    return 0;
78}
79
80uint8_t *GetOffsetPtr(const android::renderscript::Allocation *alloc,
81                      uint32_t xoff, uint32_t yoff, uint32_t lod,
82                      RsAllocationCubemapFace face) {
83    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
84    uint8_t *ptr = (uint8_t *)drv->lod[lod].mallocPtr;
85    ptr += face * drv->faceOffset;
86    ptr += yoff * drv->lod[lod].stride;
87    ptr += xoff * alloc->mHal.state.elementSizeBytes;
88    return ptr;
89}
90
91
92static void Update2DTexture(const Context *rsc, const Allocation *alloc, const void *ptr,
93                            uint32_t xoff, uint32_t yoff, uint32_t lod,
94                            RsAllocationCubemapFace face, uint32_t w, uint32_t h) {
95    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
96
97    rsAssert(drv->textureID);
98    RSD_CALL_GL(glBindTexture, drv->glTarget, drv->textureID);
99    RSD_CALL_GL(glPixelStorei, GL_UNPACK_ALIGNMENT, 1);
100    GLenum t = GL_TEXTURE_2D;
101    if (alloc->mHal.state.hasFaces) {
102        t = gFaceOrder[face];
103    }
104    RSD_CALL_GL(glTexSubImage2D, t, lod, xoff, yoff, w, h, drv->glFormat, drv->glType, ptr);
105}
106
107
108static void Upload2DTexture(const Context *rsc, const Allocation *alloc, bool isFirstUpload) {
109    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
110
111    RSD_CALL_GL(glBindTexture, drv->glTarget, drv->textureID);
112    RSD_CALL_GL(glPixelStorei, GL_UNPACK_ALIGNMENT, 1);
113
114    uint32_t faceCount = 1;
115    if (alloc->mHal.state.hasFaces) {
116        faceCount = 6;
117    }
118
119    rsdGLCheckError(rsc, "Upload2DTexture 1 ");
120    for (uint32_t face = 0; face < faceCount; face ++) {
121        for (uint32_t lod = 0; lod < alloc->mHal.state.type->getLODCount(); lod++) {
122            const uint8_t *p = GetOffsetPtr(alloc, 0, 0, lod, (RsAllocationCubemapFace)face);
123
124            GLenum t = GL_TEXTURE_2D;
125            if (alloc->mHal.state.hasFaces) {
126                t = gFaceOrder[face];
127            }
128
129            if (isFirstUpload) {
130                RSD_CALL_GL(glTexImage2D, t, lod, drv->glFormat,
131                             alloc->mHal.state.type->getLODDimX(lod),
132                             alloc->mHal.state.type->getLODDimY(lod),
133                             0, drv->glFormat, drv->glType, p);
134            } else {
135                RSD_CALL_GL(glTexSubImage2D, t, lod, 0, 0,
136                                alloc->mHal.state.type->getLODDimX(lod),
137                                alloc->mHal.state.type->getLODDimY(lod),
138                                drv->glFormat, drv->glType, p);
139            }
140        }
141    }
142
143    if (alloc->mHal.state.mipmapControl == RS_ALLOCATION_MIPMAP_ON_SYNC_TO_TEXTURE) {
144        RSD_CALL_GL(glGenerateMipmap, drv->glTarget);
145    }
146    rsdGLCheckError(rsc, "Upload2DTexture");
147}
148
149static void UploadToTexture(const Context *rsc, const Allocation *alloc) {
150    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
151
152    if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_INPUT) {
153        if (!drv->textureID) {
154            RSD_CALL_GL(glGenTextures, 1, &drv->textureID);
155        }
156        return;
157    }
158
159    if (!drv->glType || !drv->glFormat) {
160        return;
161    }
162
163    if (!drv->lod[0].mallocPtr) {
164        return;
165    }
166
167    bool isFirstUpload = false;
168
169    if (!drv->textureID) {
170        RSD_CALL_GL(glGenTextures, 1, &drv->textureID);
171        isFirstUpload = true;
172    }
173
174    Upload2DTexture(rsc, alloc, isFirstUpload);
175
176    if (!(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT)) {
177        if (alloc->mHal.drvState.mallocPtrLOD0) {
178            free(alloc->mHal.drvState.mallocPtrLOD0);
179            alloc->mHal.drvState.mallocPtrLOD0 = NULL;
180            drv->lod[0].mallocPtr = NULL;
181        }
182    }
183    rsdGLCheckError(rsc, "UploadToTexture");
184}
185
186static void AllocateRenderTarget(const Context *rsc, const Allocation *alloc) {
187    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
188
189    if (!drv->glFormat) {
190        return;
191    }
192
193    if (!drv->renderTargetID) {
194        RSD_CALL_GL(glGenRenderbuffers, 1, &drv->renderTargetID);
195
196        if (!drv->renderTargetID) {
197            // This should generally not happen
198            ALOGE("allocateRenderTarget failed to gen mRenderTargetID");
199            rsc->dumpDebug();
200            return;
201        }
202        RSD_CALL_GL(glBindRenderbuffer, GL_RENDERBUFFER, drv->renderTargetID);
203        RSD_CALL_GL(glRenderbufferStorage, GL_RENDERBUFFER, drv->glFormat,
204                              alloc->mHal.state.dimensionX, alloc->mHal.state.dimensionY);
205    }
206    rsdGLCheckError(rsc, "AllocateRenderTarget");
207}
208
209static void UploadToBufferObject(const Context *rsc, const Allocation *alloc) {
210    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
211
212    rsAssert(!alloc->mHal.state.type->getDimY());
213    rsAssert(!alloc->mHal.state.type->getDimZ());
214
215    //alloc->mHal.state.usageFlags |= RS_ALLOCATION_USAGE_GRAPHICS_VERTEX;
216
217    if (!drv->bufferID) {
218        RSD_CALL_GL(glGenBuffers, 1, &drv->bufferID);
219    }
220    if (!drv->bufferID) {
221        ALOGE("Upload to buffer object failed");
222        drv->uploadDeferred = true;
223        return;
224    }
225    RSD_CALL_GL(glBindBuffer, drv->glTarget, drv->bufferID);
226    RSD_CALL_GL(glBufferData, drv->glTarget, alloc->mHal.state.type->getSizeBytes(),
227                 alloc->mHal.drvState.mallocPtrLOD0, GL_DYNAMIC_DRAW);
228    RSD_CALL_GL(glBindBuffer, drv->glTarget, 0);
229    rsdGLCheckError(rsc, "UploadToBufferObject");
230}
231
232static size_t AllocationBuildPointerTable(const Context *rsc, const Allocation *alloc,
233        const Type *type, uint8_t *ptr) {
234
235    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
236
237    drv->lod[0].dimX = type->getDimX();
238    drv->lod[0].dimY = type->getDimY();
239    drv->lod[0].mallocPtr = 0;
240    drv->lod[0].stride = drv->lod[0].dimX * type->getElementSizeBytes();
241    drv->lodCount = type->getLODCount();
242    drv->faceCount = type->getDimFaces();
243
244    size_t offsets[Allocation::MAX_LOD];
245    memset(offsets, 0, sizeof(offsets));
246
247    size_t o = drv->lod[0].stride * rsMax(drv->lod[0].dimY, 1u) * rsMax(drv->lod[0].dimZ, 1u);
248    if(drv->lodCount > 1) {
249        uint32_t tx = drv->lod[0].dimX;
250        uint32_t ty = drv->lod[0].dimY;
251        uint32_t tz = drv->lod[0].dimZ;
252        for (uint32_t lod=1; lod < drv->lodCount; lod++) {
253            drv->lod[lod].dimX = tx;
254            drv->lod[lod].dimY = ty;
255            drv->lod[lod].dimZ = tz;
256            drv->lod[lod].stride = tx * type->getElementSizeBytes();
257            offsets[lod] = o;
258            o += drv->lod[lod].stride * rsMax(ty, 1u) * rsMax(tz, 1u);
259            if (tx > 1) tx >>= 1;
260            if (ty > 1) ty >>= 1;
261            if (tz > 1) tz >>= 1;
262        }
263    }
264    drv->faceOffset = o;
265
266    drv->lod[0].mallocPtr = ptr;
267    for (uint32_t lod=1; lod < drv->lodCount; lod++) {
268        drv->lod[lod].mallocPtr = ptr + offsets[lod];
269    }
270    alloc->mHal.drvState.strideLOD0 = drv->lod[0].stride;
271    alloc->mHal.drvState.mallocPtrLOD0 = ptr;
272
273    size_t allocSize = drv->faceOffset;
274    if(drv->faceCount) {
275        allocSize *= 6;
276    }
277
278    return allocSize;
279}
280
281bool rsdAllocationInit(const Context *rsc, Allocation *alloc, bool forceZero) {
282    DrvAllocation *drv = (DrvAllocation *)calloc(1, sizeof(DrvAllocation));
283    if (!drv) {
284        return false;
285    }
286    alloc->mHal.drv = drv;
287
288    // Calculate the object size.
289    size_t allocSize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), NULL);
290
291    uint8_t * ptr = NULL;
292    if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT) {
293    } else {
294
295        ptr = (uint8_t *)malloc(allocSize);
296        if (!ptr) {
297            free(drv);
298            return false;
299        }
300    }
301    // Build the pointer tables
302    size_t verifySize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), ptr);
303    if(allocSize != verifySize) {
304        rsAssert(!"Size mismatch");
305    }
306
307    drv->glTarget = GL_NONE;
308    if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) {
309        if (alloc->mHal.state.hasFaces) {
310            drv->glTarget = GL_TEXTURE_CUBE_MAP;
311        } else {
312            drv->glTarget = GL_TEXTURE_2D;
313        }
314    } else {
315        if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) {
316            drv->glTarget = GL_ARRAY_BUFFER;
317        }
318    }
319
320    drv->glType = rsdTypeToGLType(alloc->mHal.state.type->getElement()->getComponent().getType());
321    drv->glFormat = rsdKindToGLFormat(alloc->mHal.state.type->getElement()->getComponent().getKind());
322
323    if (forceZero && ptr) {
324        memset(ptr, 0, alloc->mHal.state.type->getSizeBytes());
325    }
326
327    if (alloc->mHal.state.usageFlags & ~RS_ALLOCATION_USAGE_SCRIPT) {
328        drv->uploadDeferred = true;
329    }
330
331
332    drv->readBackFBO = NULL;
333
334    return true;
335}
336
337void rsdAllocationDestroy(const Context *rsc, Allocation *alloc) {
338    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
339
340    if (drv->bufferID) {
341        // Causes a SW crash....
342        //ALOGV(" mBufferID %i", mBufferID);
343        //glDeleteBuffers(1, &mBufferID);
344        //mBufferID = 0;
345    }
346    if (drv->textureID) {
347        RSD_CALL_GL(glDeleteTextures, 1, &drv->textureID);
348        drv->textureID = 0;
349    }
350    if (drv->renderTargetID) {
351        RSD_CALL_GL(glDeleteRenderbuffers, 1, &drv->renderTargetID);
352        drv->renderTargetID = 0;
353    }
354
355    if (alloc->mHal.drvState.mallocPtrLOD0) {
356        free(alloc->mHal.drvState.mallocPtrLOD0);
357        alloc->mHal.drvState.mallocPtrLOD0 = NULL;
358    }
359    if (drv->readBackFBO != NULL) {
360        delete drv->readBackFBO;
361        drv->readBackFBO = NULL;
362    }
363    free(drv);
364    alloc->mHal.drv = NULL;
365}
366
367void rsdAllocationResize(const Context *rsc, const Allocation *alloc,
368                         const Type *newType, bool zeroNew) {
369    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
370
371    void * oldPtr = drv->lod[0].mallocPtr;
372    // Calculate the object size
373    size_t s = AllocationBuildPointerTable(rsc, alloc, newType, NULL);
374    uint8_t *ptr = (uint8_t *)realloc(oldPtr, s);
375    // Build the relative pointer tables.
376    size_t verifySize = AllocationBuildPointerTable(rsc, alloc, newType, ptr);
377    if(s != verifySize) {
378        rsAssert(!"Size mismatch");
379    }
380
381    const uint32_t oldDimX = alloc->mHal.state.dimensionX;
382    const uint32_t dimX = newType->getDimX();
383
384    if (dimX > oldDimX) {
385        uint32_t stride = alloc->mHal.state.elementSizeBytes;
386        memset(((uint8_t *)alloc->mHal.drvState.mallocPtrLOD0) + stride * oldDimX,
387                 0, stride * (dimX - oldDimX));
388    }
389}
390
391static void rsdAllocationSyncFromFBO(const Context *rsc, const Allocation *alloc) {
392    if (!alloc->getIsScript()) {
393        return; // nothing to sync
394    }
395
396    RsdHal *dc = (RsdHal *)rsc->mHal.drv;
397    RsdFrameBufferObj *lastFbo = dc->gl.currentFrameBuffer;
398
399    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
400    if (!drv->textureID && !drv->renderTargetID) {
401        return; // nothing was rendered here yet, so nothing to sync
402    }
403    if (drv->readBackFBO == NULL) {
404        drv->readBackFBO = new RsdFrameBufferObj();
405        drv->readBackFBO->setColorTarget(drv, 0);
406        drv->readBackFBO->setDimensions(alloc->getType()->getDimX(),
407                                        alloc->getType()->getDimY());
408    }
409
410    // Bind the framebuffer object so we can read back from it
411    drv->readBackFBO->setActive(rsc);
412
413    // Do the readback
414    RSD_CALL_GL(glReadPixels, 0, 0, drv->lod[0].dimX, drv->lod[0].dimY,
415                drv->glFormat, drv->glType, drv->lod[0].mallocPtr);
416
417    // Revert framebuffer to its original
418    lastFbo->setActive(rsc);
419}
420
421
422void rsdAllocationSyncAll(const Context *rsc, const Allocation *alloc,
423                         RsAllocationUsageType src) {
424    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
425
426    if (src == RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) {
427        if(!alloc->getIsRenderTarget()) {
428            rsc->setError(RS_ERROR_FATAL_DRIVER,
429                          "Attempting to sync allocation from render target, "
430                          "for non-render target allocation");
431        } else if (alloc->getType()->getElement()->getKind() != RS_KIND_PIXEL_RGBA) {
432            rsc->setError(RS_ERROR_FATAL_DRIVER, "Cannot only sync from RGBA"
433                                                 "render target");
434        } else {
435            rsdAllocationSyncFromFBO(rsc, alloc);
436        }
437        return;
438    }
439
440    rsAssert(src == RS_ALLOCATION_USAGE_SCRIPT);
441
442    if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) {
443        UploadToTexture(rsc, alloc);
444    } else {
445        if ((alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) &&
446            !(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT)) {
447            AllocateRenderTarget(rsc, alloc);
448        }
449    }
450    if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) {
451        UploadToBufferObject(rsc, alloc);
452    }
453
454    drv->uploadDeferred = false;
455}
456
457void rsdAllocationMarkDirty(const Context *rsc, const Allocation *alloc) {
458    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
459    drv->uploadDeferred = true;
460}
461
462int32_t rsdAllocationInitSurfaceTexture(const Context *rsc, const Allocation *alloc) {
463    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
464    UploadToTexture(rsc, alloc);
465    return drv->textureID;
466}
467
468static bool IoGetBuffer(const Context *rsc, Allocation *alloc, ANativeWindow *nw) {
469    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
470
471    int32_t r = native_window_dequeue_buffer_and_wait(nw, &drv->wndBuffer);
472    if (r) {
473        rsc->setError(RS_ERROR_DRIVER, "Error getting next IO output buffer.");
474        return false;
475    }
476
477    // Must lock the whole surface
478    GraphicBufferMapper &mapper = GraphicBufferMapper::get();
479    Rect bounds(drv->wndBuffer->width, drv->wndBuffer->height);
480
481    void *dst = NULL;
482    mapper.lock(drv->wndBuffer->handle,
483            GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_OFTEN,
484            bounds, &dst);
485    drv->lod[0].mallocPtr = dst;
486    alloc->mHal.drvState.mallocPtrLOD0 = dst;
487    drv->lod[0].stride = drv->wndBuffer->stride * alloc->mHal.state.elementSizeBytes;
488
489    return true;
490}
491
492void rsdAllocationSetSurfaceTexture(const Context *rsc, Allocation *alloc, ANativeWindow *nw) {
493    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
494
495    //ALOGE("rsdAllocationSetSurfaceTexture %p  %p", alloc, nw);
496
497    if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) {
498        //TODO finish support for render target + script
499        drv->wnd = nw;
500        return;
501    }
502
503
504    // Cleanup old surface if there is one.
505    if (alloc->mHal.state.wndSurface) {
506        ANativeWindow *old = alloc->mHal.state.wndSurface;
507        GraphicBufferMapper &mapper = GraphicBufferMapper::get();
508        mapper.unlock(drv->wndBuffer->handle);
509        old->queueBuffer(old, drv->wndBuffer, -1);
510    }
511
512    if (nw != NULL) {
513        int32_t r;
514        uint32_t flags = 0;
515        if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) {
516            flags |= GRALLOC_USAGE_SW_READ_RARELY | GRALLOC_USAGE_SW_WRITE_OFTEN;
517        }
518        if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) {
519            flags |= GRALLOC_USAGE_HW_RENDER;
520        }
521
522        r = native_window_set_usage(nw, flags);
523        if (r) {
524            rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer usage.");
525            return;
526        }
527
528        r = native_window_set_buffers_dimensions(nw, alloc->mHal.state.dimensionX,
529                                                 alloc->mHal.state.dimensionY);
530        if (r) {
531            rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer dimensions.");
532            return;
533        }
534
535        r = native_window_set_buffer_count(nw, 3);
536        if (r) {
537            rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer count.");
538            return;
539        }
540
541        IoGetBuffer(rsc, alloc, nw);
542    }
543}
544
545void rsdAllocationIoSend(const Context *rsc, Allocation *alloc) {
546    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
547    ANativeWindow *nw = alloc->mHal.state.wndSurface;
548
549    if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) {
550        RsdHal *dc = (RsdHal *)rsc->mHal.drv;
551        RSD_CALL_GL(eglSwapBuffers, dc->gl.egl.display, dc->gl.egl.surface);
552        return;
553    }
554
555    if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) {
556        GraphicBufferMapper &mapper = GraphicBufferMapper::get();
557        mapper.unlock(drv->wndBuffer->handle);
558        int32_t r = nw->queueBuffer(nw, drv->wndBuffer, -1);
559        if (r) {
560            rsc->setError(RS_ERROR_DRIVER, "Error sending IO output buffer.");
561            return;
562        }
563
564        IoGetBuffer(rsc, alloc, nw);
565    }
566}
567
568void rsdAllocationIoReceive(const Context *rsc, Allocation *alloc) {
569    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
570    alloc->mHal.state.surfaceTexture->updateTexImage();
571}
572
573
574void rsdAllocationData1D(const Context *rsc, const Allocation *alloc,
575                         uint32_t xoff, uint32_t lod, uint32_t count,
576                         const void *data, size_t sizeBytes) {
577    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
578
579    const uint32_t eSize = alloc->mHal.state.type->getElementSizeBytes();
580    uint8_t * ptr = GetOffsetPtr(alloc, xoff, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X);
581    uint32_t size = count * eSize;
582
583    if (alloc->mHal.state.hasReferences) {
584        alloc->incRefs(data, count);
585        alloc->decRefs(ptr, count);
586    }
587
588    memcpy(ptr, data, size);
589    drv->uploadDeferred = true;
590}
591
592void rsdAllocationData2D(const Context *rsc, const Allocation *alloc,
593                         uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face,
594                         uint32_t w, uint32_t h, const void *data, size_t sizeBytes) {
595    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
596
597    uint32_t eSize = alloc->mHal.state.elementSizeBytes;
598    uint32_t lineSize = eSize * w;
599
600    if (drv->lod[0].mallocPtr) {
601        const uint8_t *src = static_cast<const uint8_t *>(data);
602        uint8_t *dst = GetOffsetPtr(alloc, xoff, yoff, lod, face);
603
604        for (uint32_t line=yoff; line < (yoff+h); line++) {
605            if (alloc->mHal.state.hasReferences) {
606                alloc->incRefs(src, w);
607                alloc->decRefs(dst, w);
608            }
609            memcpy(dst, src, lineSize);
610            src += lineSize;
611            dst += drv->lod[lod].stride;
612        }
613        drv->uploadDeferred = true;
614    } else {
615        Update2DTexture(rsc, alloc, data, xoff, yoff, lod, face, w, h);
616    }
617}
618
619void rsdAllocationData3D(const Context *rsc, const Allocation *alloc,
620                         uint32_t xoff, uint32_t yoff, uint32_t zoff,
621                         uint32_t lod, RsAllocationCubemapFace face,
622                         uint32_t w, uint32_t h, uint32_t d, const void *data, uint32_t sizeBytes) {
623
624}
625
626void rsdAllocationRead1D(const Context *rsc, const Allocation *alloc,
627                         uint32_t xoff, uint32_t lod, uint32_t count,
628                         void *data, size_t sizeBytes) {
629    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
630
631    const uint32_t eSize = alloc->mHal.state.type->getElementSizeBytes();
632    const uint8_t * ptr = GetOffsetPtr(alloc, xoff, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X);
633    memcpy(data, ptr, count * eSize);
634}
635
636void rsdAllocationRead2D(const Context *rsc, const Allocation *alloc,
637                         uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face,
638                         uint32_t w, uint32_t h, void *data, size_t sizeBytes) {
639    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
640
641    uint32_t eSize = alloc->mHal.state.elementSizeBytes;
642    uint32_t lineSize = eSize * w;
643
644    if (drv->lod[0].mallocPtr) {
645        uint8_t *dst = static_cast<uint8_t *>(data);
646        const uint8_t *src = GetOffsetPtr(alloc, xoff, yoff, lod, face);
647
648        for (uint32_t line=yoff; line < (yoff+h); line++) {
649            memcpy(dst, src, lineSize);
650            dst += lineSize;
651            src += drv->lod[lod].stride;
652        }
653    } else {
654        ALOGE("Add code to readback from non-script memory");
655    }
656}
657
658void rsdAllocationRead3D(const Context *rsc, const Allocation *alloc,
659                         uint32_t xoff, uint32_t yoff, uint32_t zoff,
660                         uint32_t lod, RsAllocationCubemapFace face,
661                         uint32_t w, uint32_t h, uint32_t d, void *data, uint32_t sizeBytes) {
662
663}
664
665void * rsdAllocationLock1D(const android::renderscript::Context *rsc,
666                          const android::renderscript::Allocation *alloc) {
667    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
668    return drv->lod[0].mallocPtr;
669}
670
671void rsdAllocationUnlock1D(const android::renderscript::Context *rsc,
672                          const android::renderscript::Allocation *alloc) {
673
674}
675
676void rsdAllocationData1D_alloc(const android::renderscript::Context *rsc,
677                               const android::renderscript::Allocation *dstAlloc,
678                               uint32_t dstXoff, uint32_t dstLod, uint32_t count,
679                               const android::renderscript::Allocation *srcAlloc,
680                               uint32_t srcXoff, uint32_t srcLod) {
681}
682
683
684void rsdAllocationData2D_alloc_script(const android::renderscript::Context *rsc,
685                                      const android::renderscript::Allocation *dstAlloc,
686                                      uint32_t dstXoff, uint32_t dstYoff, uint32_t dstLod,
687                                      RsAllocationCubemapFace dstFace, uint32_t w, uint32_t h,
688                                      const android::renderscript::Allocation *srcAlloc,
689                                      uint32_t srcXoff, uint32_t srcYoff, uint32_t srcLod,
690                                      RsAllocationCubemapFace srcFace) {
691    uint32_t elementSize = dstAlloc->getType()->getElementSizeBytes();
692    for (uint32_t i = 0; i < h; i ++) {
693        uint8_t *dstPtr = GetOffsetPtr(dstAlloc, dstXoff, dstYoff + i, dstLod, dstFace);
694        uint8_t *srcPtr = GetOffsetPtr(srcAlloc, srcXoff, srcYoff + i, srcLod, srcFace);
695        memcpy(dstPtr, srcPtr, w * elementSize);
696
697        //ALOGE("COPIED dstXoff(%u), dstYoff(%u), dstLod(%u), dstFace(%u), w(%u), h(%u), srcXoff(%u), srcYoff(%u), srcLod(%u), srcFace(%u)",
698        //     dstXoff, dstYoff, dstLod, dstFace, w, h, srcXoff, srcYoff, srcLod, srcFace);
699    }
700}
701
702void rsdAllocationData2D_alloc(const android::renderscript::Context *rsc,
703                               const android::renderscript::Allocation *dstAlloc,
704                               uint32_t dstXoff, uint32_t dstYoff, uint32_t dstLod,
705                               RsAllocationCubemapFace dstFace, uint32_t w, uint32_t h,
706                               const android::renderscript::Allocation *srcAlloc,
707                               uint32_t srcXoff, uint32_t srcYoff, uint32_t srcLod,
708                               RsAllocationCubemapFace srcFace) {
709    if (!dstAlloc->getIsScript() && !srcAlloc->getIsScript()) {
710        rsc->setError(RS_ERROR_FATAL_DRIVER, "Non-script allocation copies not "
711                                             "yet implemented.");
712        return;
713    }
714    rsdAllocationData2D_alloc_script(rsc, dstAlloc, dstXoff, dstYoff,
715                                     dstLod, dstFace, w, h, srcAlloc,
716                                     srcXoff, srcYoff, srcLod, srcFace);
717}
718
719void rsdAllocationData3D_alloc(const android::renderscript::Context *rsc,
720                               const android::renderscript::Allocation *dstAlloc,
721                               uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff,
722                               uint32_t dstLod, RsAllocationCubemapFace dstFace,
723                               uint32_t w, uint32_t h, uint32_t d,
724                               const android::renderscript::Allocation *srcAlloc,
725                               uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff,
726                               uint32_t srcLod, RsAllocationCubemapFace srcFace) {
727}
728
729void rsdAllocationElementData1D(const Context *rsc, const Allocation *alloc,
730                                uint32_t x,
731                                const void *data, uint32_t cIdx, uint32_t sizeBytes) {
732    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
733
734    uint32_t eSize = alloc->mHal.state.elementSizeBytes;
735    uint8_t * ptr = GetOffsetPtr(alloc, x, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X);
736
737    const Element * e = alloc->mHal.state.type->getElement()->getField(cIdx);
738    ptr += alloc->mHal.state.type->getElement()->getFieldOffsetBytes(cIdx);
739
740    if (alloc->mHal.state.hasReferences) {
741        e->incRefs(data);
742        e->decRefs(ptr);
743    }
744
745    memcpy(ptr, data, sizeBytes);
746    drv->uploadDeferred = true;
747}
748
749void rsdAllocationElementData2D(const Context *rsc, const Allocation *alloc,
750                                uint32_t x, uint32_t y,
751                                const void *data, uint32_t cIdx, uint32_t sizeBytes) {
752    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
753
754    uint32_t eSize = alloc->mHal.state.elementSizeBytes;
755    uint8_t * ptr = GetOffsetPtr(alloc, x, y, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X);
756
757    const Element * e = alloc->mHal.state.type->getElement()->getField(cIdx);
758    ptr += alloc->mHal.state.type->getElement()->getFieldOffsetBytes(cIdx);
759
760    if (alloc->mHal.state.hasReferences) {
761        e->incRefs(data);
762        e->decRefs(ptr);
763    }
764
765    memcpy(ptr, data, sizeBytes);
766    drv->uploadDeferred = true;
767}
768
769static void mip565(const Allocation *alloc, int lod, RsAllocationCubemapFace face) {
770    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
771    uint32_t w = drv->lod[lod + 1].dimX;
772    uint32_t h = drv->lod[lod + 1].dimY;
773
774    for (uint32_t y=0; y < h; y++) {
775        uint16_t *oPtr = (uint16_t *)GetOffsetPtr(alloc, 0, y, lod + 1, face);
776        const uint16_t *i1 = (uint16_t *)GetOffsetPtr(alloc, 0, y*2, lod, face);
777        const uint16_t *i2 = (uint16_t *)GetOffsetPtr(alloc, 0, y*2+1, lod, face);
778
779        for (uint32_t x=0; x < w; x++) {
780            *oPtr = rsBoxFilter565(i1[0], i1[1], i2[0], i2[1]);
781            oPtr ++;
782            i1 += 2;
783            i2 += 2;
784        }
785    }
786}
787
788static void mip8888(const Allocation *alloc, int lod, RsAllocationCubemapFace face) {
789    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
790    uint32_t w = drv->lod[lod + 1].dimX;
791    uint32_t h = drv->lod[lod + 1].dimY;
792
793    for (uint32_t y=0; y < h; y++) {
794        uint32_t *oPtr = (uint32_t *)GetOffsetPtr(alloc, 0, y, lod + 1, face);
795        const uint32_t *i1 = (uint32_t *)GetOffsetPtr(alloc, 0, y*2, lod, face);
796        const uint32_t *i2 = (uint32_t *)GetOffsetPtr(alloc, 0, y*2+1, lod, face);
797
798        for (uint32_t x=0; x < w; x++) {
799            *oPtr = rsBoxFilter8888(i1[0], i1[1], i2[0], i2[1]);
800            oPtr ++;
801            i1 += 2;
802            i2 += 2;
803        }
804    }
805}
806
807static void mip8(const Allocation *alloc, int lod, RsAllocationCubemapFace face) {
808    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
809    uint32_t w = drv->lod[lod + 1].dimX;
810    uint32_t h = drv->lod[lod + 1].dimY;
811
812    for (uint32_t y=0; y < h; y++) {
813        uint8_t *oPtr = GetOffsetPtr(alloc, 0, y, lod + 1, face);
814        const uint8_t *i1 = GetOffsetPtr(alloc, 0, y*2, lod, face);
815        const uint8_t *i2 = GetOffsetPtr(alloc, 0, y*2+1, lod, face);
816
817        for (uint32_t x=0; x < w; x++) {
818            *oPtr = (uint8_t)(((uint32_t)i1[0] + i1[1] + i2[0] + i2[1]) * 0.25f);
819            oPtr ++;
820            i1 += 2;
821            i2 += 2;
822        }
823    }
824}
825
826void rsdAllocationGenerateMipmaps(const Context *rsc, const Allocation *alloc) {
827    DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv;
828    if(!drv->lod[0].mallocPtr) {
829        return;
830    }
831    uint32_t numFaces = alloc->getType()->getDimFaces() ? 6 : 1;
832    for (uint32_t face = 0; face < numFaces; face ++) {
833        for (uint32_t lod=0; lod < (alloc->getType()->getLODCount() -1); lod++) {
834            switch (alloc->getType()->getElement()->getSizeBits()) {
835            case 32:
836                mip8888(alloc, lod, (RsAllocationCubemapFace)face);
837                break;
838            case 16:
839                mip565(alloc, lod, (RsAllocationCubemapFace)face);
840                break;
841            case 8:
842                mip8(alloc, lod, (RsAllocationCubemapFace)face);
843                break;
844            }
845        }
846    }
847}
848
849
850