| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| |
| |
| #include <machine/cpu-features.h> |
| #include <machine/asm.h> |
| |
| /* |
| r0 = base pointer |
| r1 = image stride |
| r2 = w |
| r3 = h |
| sp = float u |
| sp = float v |
| */ |
| |
| ENTRY(rsdCpuLinearClamp2D_RGBA_k2) |
| push {r4-r8, r10, r11, lr} |
| vpush {q4-q7} |
| |
| // Load uv |
| ldr r4, [sp, #32+64] |
| ldr r5, [sp, #32+64+4] |
| vmov d18, r4, r5 // d18 = float u, v |
| |
| |
| // float pixelU = (u * w) - 0.5f; |
| // float pixelV = (v * h) - 0.5f; |
| vmov d16, r2, r3 // d16 = int w, h |
| vcvt.f32.s32 d17, d16 // d17 = float w, h |
| vmul.f32 d20, d18, d17 // d20 = pixelUV (uv * wh) |
| |
| vld1.f32 d19, =0x3F000000 // 0.5 |
| vsub.f32 d20, d20, d19 // d20 = pixelUV (uv * wh) - 0.5f |
| |
| // int iu = pixelU; |
| // int iv = pixelV; |
| vcvt.s32.f32 d21, d20 // d21 = iPixelUV |
| |
| |
| //float fracU = pixelU - iu; |
| //float fracV = pixelV - iv; |
| vcvt.s32.f32 d19, d20 // |
| vcvt.f32.s32 d19, d19 // d19 = (float)iuv |
| vsub.f32 d0, d20, d19 // d0 = fract = pixelUV - iuv |
| |
| |
| //float oneMinusFracU = 1.0f - fracU; |
| //float oneMinusFracV = 1.0f - fracV; |
| vld1.f32 d22, =0x3F800000 // 0.5 |
| vsub.f32 d1, d22, d0 // d1 = oneMinusFrac |
| |
| |
| //float weightsX1 = oneMinusFracU * oneMinusFracV; |
| //float weightsY1 = fracU * oneMinusFracV; |
| //float weightsX2 = fracV * oneMinusFracU; |
| //float weightsY2 = fracU * fracV; |
| vmul.f32 d2, d1, d1[1] // d2 = 1mu * 1mv , 1mv * 1mv |
| vmul.f32 d3, d0, d1[1] // d3 = u * 1mv , v * 1mv |
| vmul.f32 d4, d1, d0[1] // d4 = v * 1mu , v * 1mv |
| vmul.f32 d5, d0, d0[1] // d5 = u * v, v * v |
| |
| //int nextX = rsMax(0, rsMin(iu + 1, w - 1)); |
| //int nextY = rsMax(0, rsMin(iv + 1, h - 1)); |
| //int locationX = rsMax(0, rsMin(iu, w - 1)); |
| //int locationY = rsMax(0, rsMin(iv, h - 1)); |
| vmov.u32 d6, #1 |
| vmov.u32 d8, #0 |
| vsub.s32 d16, d16, d6 // d16 = h -1, w -1 |
| vadd.s32 d7, d6, d21 // d7 = iuv + 1 |
| |
| vmin.s32 d7, d7, d16 |
| vmin.s32 d21, d21, d16 |
| vmax.s32 d7, d7, d8 // d7 = next |
| vmax.s32 d21, d21, d8 // d21 = location |
| |
| mov r2, #4 |
| vmov d6, r2, r1 // d6 = 4, stride |
| vmul.s32 d7, d6 // d7 = nextX*4, nextY * stride |
| vmul.s32 d21, d6 // d21 = locationX*4, locationY * stride |
| |
| //uchar4 *p0c = (uchar4*)&p[(locationY * stride) + (locationX * 4)]; |
| //uchar4 *p1c = (uchar4*)&p[(locationY * stride) + (nextX * 4)]; |
| //uchar4 *p2c = (uchar4*)&p[(nextY * stride) + (locationX * 4)]; |
| //uchar4 *p3c = (uchar4*)&p[(nextY * stride) + (nextX * 4)]; |
| vmov r2, r3, d7 // r2 = nextX*4, r3 = nextY *stride |
| vmov r4, r5, d21 // r4 = locX*4, r5 = locY*Stride |
| add r3, r3, r0 // r3 = p + nextY*stride |
| add r5, r5, r0 // r5 = p + locY*stride |
| |
| //float4 p0 = convert_float4(*p0c); |
| //float4 p1 = convert_float4(*p1c); |
| add r1, r5, r4 // *p0c |
| ldr r0, [r1] |
| add r1, r5, r2 // *p1c |
| ldr r1, [r1] |
| vmov d0, r0, r1 // d0 = p0, p1 |
| |
| //float4 p2 = convert_float4(*p2c); |
| //float4 p3 = convert_float4(*p3c); |
| add r1, r3, r4 // *p2c |
| ldr r0, [r1] |
| add r1, r3, r2 // *p3c |
| ldr r1, [r1] |
| vmov d1, r0, r1 // d1 = p0, p1 |
| |
| //return (p0 * weightsX1 + p1 * weightsY1 + p2 * weightsX2 + p3 * weightsY2) * 0.003921569f; |
| vmovl.u8 q3, d0 |
| vmovl.u8 q4, d1 |
| vmovl.u16 q3, d6 |
| vmovl.u16 q4, d7 |
| vmovl.u16 q5, d8 |
| vmovl.u16 q6, d9 |
| vcvt.f32.u32 q3, q3 |
| vcvt.f32.u32 q4, q4 |
| vcvt.f32.u32 q5, q5 |
| vcvt.f32.u32 q6, q6 |
| |
| //vmul.f32 q3, q3, d2[0] |
| //vmla.f32 q3, q4, d3[0] |
| //vmla.f32 q3, q5, d4[0] |
| //vmla.f32 q3, q6, d5[0] |
| |
| vld1.f32 d0, =0x3B808081 // 1.f / 255.f |
| vmul.f32 q3, q3, d0[0] |
| |
| vmov r0, r1, d6 |
| vmov r2, r3, d7 |
| |
| mov r3, #0x3F800000 |
| |
| /* We're done, bye! */ |
| vpop {q4-q7} |
| pop {r4-r8, r10, r11, lr} |
| bx lr |
| END(rsdCpuLinearClamp2D_RGBA_k2) |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| /* |
| r0 = base pointer |
| r1 = image stride |
| r2 = iu |
| r3 = iv |
| sp = w |
| sp = h |
| */ |
| |
| ENTRY(rsdCpuLinearClamp2D_RGBA_k) |
| push {r4-r8, r10, r11, lr} |
| vpush {q4-q7} |
| |
| vmov d2, r2, r3 |
| |
| add r4, sp, #32+64 |
| vld1.32 d3, [r4]! |
| vld1.32 {q0}, [r4]! |
| |
| |
| mov r2, #4 |
| vmov d6, r2, r1 // d6 = 4, stride |
| vmul.s32 d30, d6 // d30 = nextX*4, nextY * stride |
| vmul.s32 d31, d6 // d31 = locationX*4, locationY * stride |
| |
| //uchar4 *p0c = (uchar4*)&p[(locationY * stride) + (locationX * 4)]; |
| //uchar4 *p1c = (uchar4*)&p[(locationY * stride) + (nextX * 4)]; |
| //uchar4 *p2c = (uchar4*)&p[(nextY * stride) + (locationX * 4)]; |
| //uchar4 *p3c = (uchar4*)&p[(nextY * stride) + (nextX * 4)]; |
| vmov r2, r3, d30 // r2 = nextX*4, r3 = nextY *stride |
| vmov r4, r5, d31 // r4 = locX*4, r5 = locY*Stride |
| add r3, r3, r0 // r3 = p + nextY*stride |
| add r5, r5, r0 // r5 = p + locY*stride |
| |
| //float4 p0 = convert_float4(*p0c); |
| //float4 p1 = convert_float4(*p1c); |
| add r1, r5, r4 // *p0c |
| ldr r0, [r1] |
| add r1, r5, r2 // *p1c |
| ldr r1, [r1] |
| vmov d30, r0, r1 // d0 = p0, p1 |
| |
| //float4 p2 = convert_float4(*p2c); |
| //float4 p3 = convert_float4(*p3c); |
| add r1, r3, r4 // *p2c |
| ldr r0, [r1] |
| add r1, r3, r2 // *p3c |
| ldr r1, [r1] |
| vmov d31, r0, r1 // d1 = p0, p1 |
| |
| //return (p0 * weightsX1 + p1 * weightsY1 + p2 * weightsX2 + p3 * weightsY2) * 0.003921569f; |
| vmovl.u8 q2, d30 |
| vmovl.u8 q3, d31 |
| vmovl.u16 q8, d4 |
| vmovl.u16 q9, d5 |
| vmovl.u16 q10, d6 |
| vmovl.u16 q11, d7 |
| vcvt.f32.u32 q8, q8, #8 |
| vcvt.f32.u32 q9, q9, #8 |
| vcvt.f32.u32 q10, q10, #8 |
| vcvt.f32.u32 q11, q11, #8 |
| |
| vmul.f32 q3, q8, d0[0] |
| vmla.f32 q3, q9, d0[1] |
| vmla.f32 q3, q10, d1[0] |
| vmla.f32 q3, q11, d1[1] |
| |
| /// vld1.f32 d0, =0x3B808081 // 1.f / 255.f |
| // vmul.f32 q3, q3, d0[0] |
| |
| vmov r0, r1, d6 |
| vmov r2, r3, d7 |
| |
| mov r3, #0x3F800000 |
| |
| /* We're done, bye! */ |
| vpop {q4-q7} |
| pop {r4-r8, r10, r11, lr} |
| bx lr |
| END(rsdCpuLinearClamp2D_RGBA_k) |
| |
| |
| |
| /* |
| r0 = uint8_t *ptr |
| r1 = image stride |
| r2,r3 = iPixel |
| sp0,1 = next |
| q0 = weights |
| */ |
| |
| ENTRY(rsdCpuGetSample2D_RGBA_k) |
| push {r4-r8, lr} |
| |
| ldr r4, [sp, #24] // next.x |
| ldr r5, [sp, #24+4] // next.y |
| |
| mul r3, r3, r1 // iPixel.y * stride |
| mul r5, r5, r1 // next.y * stride |
| |
| add r2, r0, r2, LSL #2 |
| add r4, r0, r4, LSL #2 |
| |
| ldr r0, [r2, r3] // r0 = p[(locationY * stride) + (locationX * 4)] |
| ldr r1, [r4, r3] // r1 = p[(locationY * stride) + (nextX * 4)] |
| ldr r2, [r2, r5] // r2 = p[(nextY * stride) + (locationX * 4)] |
| ldr r3, [r4, r5] // r3 = p[(nextY * stride) + (nextX * 4)] |
| |
| vmov d30, r0, r1 // d30 = p0, p1 |
| vmov d31, r2, r3 // d31 = p2, p3 |
| |
| vcvt.u32.f32 q0, q0, #8 |
| vmovn.u32 d0, q0 |
| |
| //return (p0 * weightsX1 + p1 * weightsY1 + p2 * weightsX2 + p3 * weightsY2) * 0.003921569f; |
| vmovl.u8 q2, d30 |
| vmovl.u8 q3, d31 |
| |
| vmull.u16 q8, d4, d0[0] |
| vmlal.u16 q8, d5, d0[1] |
| vmlal.u16 q8, d6, d0[2] |
| vmlal.u16 q8, d7, d0[3] |
| |
| vcvt.f32.u32 q3, q8, #8 |
| |
| ldr r1, =0x3B808081 // 1.f / 255.f |
| vmov.32 d0[0], r1 |
| vmul.f32 q0, q3, d0[0] |
| |
| /* We're done, bye! */ |
| pop {r4-r8, lr} |
| bx lr |
| END(rsdCpuGetSample2D_RGBA_k) |
| |
