1/*
2 * Copyright (C) 2013 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 "rsCpuIntrinsic.h"
19#include "rsCpuIntrinsicInlines.h"
20
21#ifdef RS_COMPATIBILITY_LIB
22#include "rsCompatibilityLib.h"
23#endif
24
25#ifndef RS_COMPATIBILITY_LIB
26#include "hardware/gralloc.h"
27#endif
28
29using namespace android;
30using namespace android::renderscript;
31
32namespace android {
33namespace renderscript {
34
35
36class RsdCpuScriptIntrinsicYuvToRGB : public RsdCpuScriptIntrinsic {
37public:
38    void populateScript(Script *) override;
39    void invokeFreeChildren() override;
40
41    void setGlobalObj(uint32_t slot, ObjectBase *data) override;
42
43    ~RsdCpuScriptIntrinsicYuvToRGB() override;
44    RsdCpuScriptIntrinsicYuvToRGB(RsdCpuReferenceImpl *ctx, const Script *s, const Element *e);
45
46protected:
47    ObjectBaseRef<Allocation> alloc;
48
49    static void kernel(const RsExpandKernelDriverInfo *info,
50                       uint32_t xstart, uint32_t xend,
51                       uint32_t outstep);
52};
53
54}
55}
56
57
58void RsdCpuScriptIntrinsicYuvToRGB::setGlobalObj(uint32_t slot, ObjectBase *data) {
59    rsAssert(slot == 0);
60    alloc.set(static_cast<Allocation *>(data));
61}
62
63
64
65
66static uchar4 rsYuvToRGBA_uchar4(uchar y, uchar u, uchar v) {
67    short Y = ((short)y) - 16;
68    short U = ((short)u) - 128;
69    short V = ((short)v) - 128;
70
71    short4 p;
72    p.x = (Y * 298 + V * 409 + 128) >> 8;
73    p.y = (Y * 298 - U * 100 - V * 208 + 128) >> 8;
74    p.z = (Y * 298 + U * 516 + 128) >> 8;
75    p.w = 255;
76    if(p.x < 0) {
77        p.x = 0;
78    }
79    if(p.x > 255) {
80        p.x = 255;
81    }
82    if(p.y < 0) {
83        p.y = 0;
84    }
85    if(p.y > 255) {
86        p.y = 255;
87    }
88    if(p.z < 0) {
89        p.z = 0;
90    }
91    if(p.z > 255) {
92        p.z = 255;
93    }
94
95    return (uchar4){static_cast<uchar>(p.x), static_cast<uchar>(p.y),
96                    static_cast<uchar>(p.z), static_cast<uchar>(p.w)};
97}
98
99
100extern "C" void rsdIntrinsicYuv_K(void *dst, const uchar *Y, const uchar *uv, uint32_t xstart, size_t xend);
101extern "C" void rsdIntrinsicYuvR_K(void *dst, const uchar *Y, const uchar *uv, uint32_t xstart, size_t xend);
102extern "C" void rsdIntrinsicYuv2_K(void *dst, const uchar *Y, const uchar *u, const uchar *v, size_t xstart, size_t xend);
103
104void RsdCpuScriptIntrinsicYuvToRGB::kernel(const RsExpandKernelDriverInfo *info,
105                                           uint32_t xstart, uint32_t xend,
106                                           uint32_t outstep) {
107    RsdCpuScriptIntrinsicYuvToRGB *cp = (RsdCpuScriptIntrinsicYuvToRGB *)info->usr;
108    if (!cp->alloc.get()) {
109        ALOGE("YuvToRGB executed without input, skipping");
110        return;
111    }
112    const uchar *pinY = (const uchar *)cp->alloc->mHal.drvState.lod[0].mallocPtr;
113    if (pinY == nullptr) {
114        ALOGE("YuvToRGB executed without data, skipping");
115        return;
116    }
117
118    size_t strideY = cp->alloc->mHal.drvState.lod[0].stride;
119
120    // calculate correct stride in legacy case
121    if (cp->alloc->mHal.drvState.lod[0].dimY == 0) {
122        strideY = info->dim.x;
123    }
124    const uchar *Y = pinY + (info->current.y * strideY);
125
126    uchar4 *out = (uchar4 *)info->outPtr[0] + xstart;
127    uint32_t x1 = xstart;
128    uint32_t x2 = xend;
129
130    size_t cstep = cp->alloc->mHal.drvState.yuv.step;
131
132    const uchar *pinU = (const uchar *)cp->alloc->mHal.drvState.lod[1].mallocPtr;
133    const size_t strideU = cp->alloc->mHal.drvState.lod[1].stride;
134    const uchar *u = pinU + ((info->current.y >> 1) * strideU);
135
136    const uchar *pinV = (const uchar *)cp->alloc->mHal.drvState.lod[2].mallocPtr;
137    const size_t strideV = cp->alloc->mHal.drvState.lod[2].stride;
138    const uchar *v = pinV + ((info->current.y >> 1) * strideV);
139
140    //ALOGE("pinY, %p, Y, %p, info->current.y, %d, strideY, %d", pinY, Y, info->current.y, strideY);
141    //ALOGE("pinU, %p, U, %p, info->current.y, %d, strideU, %d", pinU, u, info->current.y, strideU);
142    //ALOGE("pinV, %p, V, %p, info->current.y, %d, strideV, %d", pinV, v, info->current.y, strideV);
143    //ALOGE("dimX, %d, dimY, %d", cp->alloc->mHal.drvState.lod[0].dimX, cp->alloc->mHal.drvState.lod[0].dimY);
144    //ALOGE("info->dim.x, %d, info->dim.y, %d", info->dim.x, info->dim.y);
145
146    if (pinU == nullptr) {
147        // Legacy yuv support didn't fill in uv
148        v = ((uint8_t *)cp->alloc->mHal.drvState.lod[0].mallocPtr) +
149            (strideY * info->dim.y) +
150            ((info->current.y >> 1) * strideY);
151        u = v + 1;
152        cstep = 2;
153    }
154
155    /* If we start on an odd pixel then deal with it here and bump things along
156     * so that subsequent code can carry on with even-odd pairing assumptions.
157     */
158    if((x1 & 1) && (x2 > x1)) {
159        int cx = (x1 >> 1) * cstep;
160        *out = rsYuvToRGBA_uchar4(Y[x1], u[cx], v[cx]);
161        out++;
162        x1++;
163    }
164
165#if defined(ARCH_ARM_USE_INTRINSICS)
166    if((x2 > x1) && gArchUseSIMD) {
167        int32_t len = x2 - x1;
168        if (cstep == 1) {
169            rsdIntrinsicYuv2_K(info->outPtr[0], Y, u, v, x1, x2);
170            x1 += len;
171            out += len;
172        } else if (cstep == 2) {
173            // Check for proper interleave
174            intptr_t ipu = (intptr_t)u;
175            intptr_t ipv = (intptr_t)v;
176
177            if (ipu == (ipv + 1)) {
178                rsdIntrinsicYuv_K(info->outPtr[0], Y, v, x1, x2);
179                x1 += len;
180                out += len;
181            } else if (ipu == (ipv - 1)) {
182                rsdIntrinsicYuvR_K(info->outPtr[0], Y, u, x1, x2);
183                x1 += len;
184                out += len;
185            }
186        }
187    }
188#endif
189
190    if(x2 > x1) {
191       // ALOGE("y %i  %i  %i", info->current.y, x1, x2);
192        while(x1 < x2) {
193            int cx = (x1 >> 1) * cstep;
194            *out = rsYuvToRGBA_uchar4(Y[x1], u[cx], v[cx]);
195            out++;
196            x1++;
197            *out = rsYuvToRGBA_uchar4(Y[x1], u[cx], v[cx]);
198            out++;
199            x1++;
200        }
201    }
202
203}
204
205RsdCpuScriptIntrinsicYuvToRGB::RsdCpuScriptIntrinsicYuvToRGB(
206            RsdCpuReferenceImpl *ctx, const Script *s, const Element *e)
207            : RsdCpuScriptIntrinsic(ctx, s, e, RS_SCRIPT_INTRINSIC_ID_YUV_TO_RGB) {
208
209    mRootPtr = &kernel;
210}
211
212RsdCpuScriptIntrinsicYuvToRGB::~RsdCpuScriptIntrinsicYuvToRGB() {
213}
214
215void RsdCpuScriptIntrinsicYuvToRGB::populateScript(Script *s) {
216    s->mHal.info.exportedVariableCount = 1;
217}
218
219void RsdCpuScriptIntrinsicYuvToRGB::invokeFreeChildren() {
220    alloc.clear();
221}
222
223
224RsdCpuScriptImpl * rsdIntrinsic_YuvToRGB(RsdCpuReferenceImpl *ctx,
225                                         const Script *s, const Element *e) {
226    return new RsdCpuScriptIntrinsicYuvToRGB(ctx, s, e);
227}
228