opencv

1

2
/* palette_neon_intrinsics.c - NEON optimised palette expansion functions
3
 *
4
 * Copyright (c) 2018-2019 Cosmin Truta
5
 * Copyright (c) 2017-2018 Arm Holdings. All rights reserved.
6
 * Written by Richard Townsend <Richard.Townsend@arm.com>, February 2017.
7
 *
8
 * This code is released under the libpng license.
9
 * For conditions of distribution and use, see the disclaimer
10
 * and license in png.h
11
 */
12

13
#include "../pngpriv.h"
14

15
#if PNG_ARM_NEON_IMPLEMENTATION == 1
16

17
#if defined(_MSC_VER) && !defined(__clang__) && defined(_M_ARM64)
18
#  include <arm64_neon.h>
19
#else
20
#  include <arm_neon.h>
21
#endif
22

23
/* Build an RGBA8 palette from the separate RGB and alpha palettes. */
24
void
25
png_riffle_palette_neon(png_structrp png_ptr)
26
{
27
   png_const_colorp palette = png_ptr->palette;
28
   png_bytep riffled_palette = png_ptr->riffled_palette;
29
   png_const_bytep trans_alpha = png_ptr->trans_alpha;
30
   int num_trans = png_ptr->num_trans;
31
   int i;
32

33
   /* Initially black, opaque. */
34
   uint8x16x4_t w = {{
35
      vdupq_n_u8(0x00),
36
      vdupq_n_u8(0x00),
37
      vdupq_n_u8(0x00),
38
      vdupq_n_u8(0xff),
39
   }};
40

41
   png_debug(1, "in png_riffle_palette_neon");
42

43
   /* First, riffle the RGB colours into an RGBA8 palette.
44
    * The alpha component is set to opaque for now.
45
    */
46
   for (i = 0; i < 256; i += 16)
47
   {
48
      uint8x16x3_t v = vld3q_u8((png_const_bytep)(palette + i));
49
      w.val[0] = v.val[0];
50
      w.val[1] = v.val[1];
51
      w.val[2] = v.val[2];
52
      vst4q_u8(riffled_palette + (i << 2), w);
53
   }
54

55
   /* Fix up the missing transparency values. */
56
   for (i = 0; i < num_trans; i++)
57
      riffled_palette[(i << 2) + 3] = trans_alpha[i];
58
}
59

60
/* Expands a palettized row into RGBA8. */
61
int
62
png_do_expand_palette_rgba8_neon(png_structrp png_ptr, png_row_infop row_info,
63
    png_const_bytep row, png_bytepp ssp, png_bytepp ddp)
64
{
65
   png_uint_32 row_width = row_info->width;
66
   const png_uint_32 *riffled_palette =
67
      (const png_uint_32 *)png_ptr->riffled_palette;
68
   const png_uint_32 pixels_per_chunk = 4;
69
   png_uint_32 i;
70

71
   png_debug(1, "in png_do_expand_palette_rgba8_neon");
72

73
   PNG_UNUSED(row)
74
   if (row_width < pixels_per_chunk)
75
      return 0;
76

77
   /* This function originally gets the last byte of the output row.
78
    * The NEON part writes forward from a given position, so we have
79
    * to seek this back by 4 pixels x 4 bytes.
80
    */
81
   *ddp = *ddp - ((pixels_per_chunk * sizeof(png_uint_32)) - 1);
82

83
   for (i = 0; i < row_width; i += pixels_per_chunk)
84
   {
85
      uint32x4_t cur;
86
      png_bytep sp = *ssp - i, dp = *ddp - (i << 2);
87
      cur = vld1q_dup_u32 (riffled_palette + *(sp - 3));
88
      cur = vld1q_lane_u32(riffled_palette + *(sp - 2), cur, 1);
89
      cur = vld1q_lane_u32(riffled_palette + *(sp - 1), cur, 2);
90
      cur = vld1q_lane_u32(riffled_palette + *(sp - 0), cur, 3);
91
      vst1q_u32((void *)dp, cur);
92
   }
93
   if (i != row_width)
94
   {
95
      /* Remove the amount that wasn't processed. */
96
      i -= pixels_per_chunk;
97
   }
98

99
   /* Decrement output pointers. */
100
   *ssp = *ssp - i;
101
   *ddp = *ddp - (i << 2);
102
   return i;
103
}
104

105
/* Expands a palettized row into RGB8. */
106
int
107
png_do_expand_palette_rgb8_neon(png_structrp png_ptr, png_row_infop row_info,
108
    png_const_bytep row, png_bytepp ssp, png_bytepp ddp)
109
{
110
   png_uint_32 row_width = row_info->width;
111
   png_const_bytep palette = (png_const_bytep)png_ptr->palette;
112
   const png_uint_32 pixels_per_chunk = 8;
113
   png_uint_32 i;
114

115
   png_debug(1, "in png_do_expand_palette_rgb8_neon");
116

117
   PNG_UNUSED(row)
118
   if (row_width <= pixels_per_chunk)
119
      return 0;
120

121
   /* Seeking this back by 8 pixels x 3 bytes. */
122
   *ddp = *ddp - ((pixels_per_chunk * sizeof(png_color)) - 1);
123

124
   for (i = 0; i < row_width; i += pixels_per_chunk)
125
   {
126
      uint8x8x3_t cur;
127
      png_bytep sp = *ssp - i, dp = *ddp - ((i << 1) + i);
128
      cur = vld3_dup_u8(palette + sizeof(png_color) * (*(sp - 7)));
129
      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 6)), cur, 1);
130
      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 5)), cur, 2);
131
      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 4)), cur, 3);
132
      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 3)), cur, 4);
133
      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 2)), cur, 5);
134
      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 1)), cur, 6);
135
      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 0)), cur, 7);
136
      vst3_u8((void *)dp, cur);
137
   }
138

139
   if (i != row_width)
140
   {
141
      /* Remove the amount that wasn't processed. */
142
      i -= pixels_per_chunk;
143
   }
144

145
   /* Decrement output pointers. */
146
   *ssp = *ssp - i;
147
   *ddp = *ddp - ((i << 1) + i);
148
   return i;
149
}
150

151
#endif /* PNG_ARM_NEON_IMPLEMENTATION */
152