1 /*
2 * jccolext-neon.c - colorspace conversion (Arm NEON)
3 *
4 * Copyright 2020 The Chromium Authors. All Rights Reserved.
5 *
6 * This software is provided 'as-is', without any express or implied
7 * warranty. In no event will the authors be held liable for any damages
8 * arising from the use of this software.
9 *
10 * Permission is granted to anyone to use this software for any purpose,
11 * including commercial applications, and to alter it and redistribute it
12 * freely, subject to the following restrictions:
13 *
14 * 1. The origin of this software must not be misrepresented; you must not
15 * claim that you wrote the original software. If you use this software
16 * in a product, an acknowledgment in the product documentation would be
17 * appreciated but is not required.
18 * 2. Altered source versions must be plainly marked as such, and must not be
19 * misrepresented as being the original software.
20 * 3. This notice may not be removed or altered from any source distribution.
21 */
22
23 /* This file is included by jccolor-neon.c */
24
25 /*
26 * RGB -> YCbCr conversion is defined by the following equations:
27 * Y = 0.29900 * R + 0.58700 * G + 0.11400 * B
28 * Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + 128
29 * Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B + 128
30 *
31 * Avoid floating point arithmetic by using shifted integer constants:
32 * 0.29899597 = 19595 * 2^-16
33 * 0.58700561 = 38470 * 2^-16
34 * 0.11399841 = 7471 * 2^-16
35 * 0.16874695 = 11059 * 2^-16
36 * 0.33125305 = 21709 * 2^-16
37 * 0.50000000 = 32768 * 2^-16
38 * 0.41868592 = 27439 * 2^-16
39 * 0.08131409 = 5329 * 2^-16
40 * These constants are defined in jccolor-neon.c
41 *
42 * To ensure rounding gives correct values, we add 0.5 to Cb and Cr.
43 */
44
jsimd_rgb_ycc_convert_neon(JDIMENSION image_width,JSAMPARRAY input_buf,JSAMPIMAGE output_buf,JDIMENSION output_row,int num_rows)45 void jsimd_rgb_ycc_convert_neon(JDIMENSION image_width,
46 JSAMPARRAY input_buf,
47 JSAMPIMAGE output_buf,
48 JDIMENSION output_row,
49 int num_rows)
50 {
51 /* Pointer to RGB(X/A) input data. */
52 JSAMPROW inptr;
53 /* Pointers to Y, Cb and Cr output data. */
54 JSAMPROW outptr0, outptr1, outptr2;
55
56 /* Setup conversion constants. */
57 #if defined(__clang__)
58 const uint16x4x2_t consts = vld1_u16_x2(jsimd_rgb_ycc_neon_consts);
59 #else
60 /* GCC does not currently support the intrinsic vld1_<type>_x2(). */
61 const uint16x4_t consts1 = vld1_u16(jsimd_rgb_ycc_neon_consts);
62 const uint16x4_t consts2 = vld1_u16(jsimd_rgb_ycc_neon_consts + 4);
63 const uint16x4x2_t consts = { consts1, consts2 };
64 #endif
65 const uint32x4_t scaled_128_5 = vdupq_n_u32((128 << 16) + 32767);
66
67 while (--num_rows >= 0) {
68 inptr = *input_buf++;
69 outptr0 = output_buf[0][output_row];
70 outptr1 = output_buf[1][output_row];
71 outptr2 = output_buf[2][output_row];
72 output_row++;
73
74 int cols_remaining = image_width;
75 for (; cols_remaining > 0; cols_remaining -= 8) {
76
77 /* To prevent buffer overread by the vector load instructions, the */
78 /* last (image_width % 8) columns of data are first memcopied to a */
79 /* temporary buffer large enough to accommodate the vector load. */
80 if (cols_remaining < 8) {
81 ALIGN(16) uint8_t tmp_buf[8 * RGB_PIXELSIZE];
82 memcpy(tmp_buf, inptr, cols_remaining * RGB_PIXELSIZE);
83 inptr = tmp_buf;
84 }
85
86 #if RGB_PIXELSIZE == 4
87 uint8x8x4_t input_pixels = vld4_u8(inptr);
88 #else
89 uint8x8x3_t input_pixels = vld3_u8(inptr);
90 #endif
91 uint16x8_t r = vmovl_u8(input_pixels.val[RGB_RED]);
92 uint16x8_t g = vmovl_u8(input_pixels.val[RGB_GREEN]);
93 uint16x8_t b = vmovl_u8(input_pixels.val[RGB_BLUE]);
94
95 /* Compute Y = 0.29900 * R + 0.58700 * G + 0.11400 * B */
96 uint32x4_t y_low = vmull_lane_u16(vget_low_u16(r), consts.val[0], 0);
97 y_low = vmlal_lane_u16(y_low, vget_low_u16(g), consts.val[0], 1);
98 y_low = vmlal_lane_u16(y_low, vget_low_u16(b), consts.val[0], 2);
99 uint32x4_t y_high = vmull_lane_u16(vget_high_u16(r), consts.val[0], 0);
100 y_high = vmlal_lane_u16(y_high, vget_high_u16(g), consts.val[0], 1);
101 y_high = vmlal_lane_u16(y_high, vget_high_u16(b), consts.val[0], 2);
102
103 /* Compute Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + 128 */
104 uint32x4_t cb_low = scaled_128_5;
105 cb_low = vmlsl_lane_u16(cb_low, vget_low_u16(r), consts.val[0], 3);
106 cb_low = vmlsl_lane_u16(cb_low, vget_low_u16(g), consts.val[1], 0);
107 cb_low = vmlal_lane_u16(cb_low, vget_low_u16(b), consts.val[1], 1);
108 uint32x4_t cb_high = scaled_128_5;
109 cb_high = vmlsl_lane_u16(cb_high, vget_high_u16(r), consts.val[0], 3);
110 cb_high = vmlsl_lane_u16(cb_high, vget_high_u16(g), consts.val[1], 0);
111 cb_high = vmlal_lane_u16(cb_high, vget_high_u16(b), consts.val[1], 1);
112
113 /* Compute Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B + 128 */
114 uint32x4_t cr_low = scaled_128_5;
115 cr_low = vmlal_lane_u16(cr_low, vget_low_u16(r), consts.val[1], 1);
116 cr_low = vmlsl_lane_u16(cr_low, vget_low_u16(g), consts.val[1], 2);
117 cr_low = vmlsl_lane_u16(cr_low, vget_low_u16(b), consts.val[1], 3);
118 uint32x4_t cr_high = scaled_128_5;
119 cr_high = vmlal_lane_u16(cr_high, vget_high_u16(r), consts.val[1], 1);
120 cr_high = vmlsl_lane_u16(cr_high, vget_high_u16(g), consts.val[1], 2);
121 cr_high = vmlsl_lane_u16(cr_high, vget_high_u16(b), consts.val[1], 3);
122
123 /* Descale Y values (rounding right shift) and narrow to 16-bit. */
124 uint16x8_t y_u16 = vcombine_u16(vrshrn_n_u32(y_low, 16),
125 vrshrn_n_u32(y_high, 16));
126 /* Descale Cb values (right shift) and narrow to 16-bit. */
127 uint16x8_t cb_u16 = vcombine_u16(vshrn_n_u32(cb_low, 16),
128 vshrn_n_u32(cb_high, 16));
129 /* Descale Cr values (right shift) and narrow to 16-bit. */
130 uint16x8_t cr_u16 = vcombine_u16(vshrn_n_u32(cr_low, 16),
131 vshrn_n_u32(cr_high, 16));
132 /* Narrow Y, Cb and Cr values to 8-bit and store to memory. Buffer */
133 /* overwrite is permitted up to the next multiple of ALIGN_SIZE bytes. */
134 vst1_u8(outptr0, vmovn_u16(y_u16));
135 vst1_u8(outptr1, vmovn_u16(cb_u16));
136 vst1_u8(outptr2, vmovn_u16(cr_u16));
137
138 /* Increment pointers. */
139 inptr += (8 * RGB_PIXELSIZE);
140 outptr0 += 8;
141 outptr1 += 8;
142 outptr2 += 8;
143 }
144 }
145 }
146