Ocean
FrameConverterRGB24.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) Meta Platforms, Inc. and affiliates.
3  *
4  * This source code is licensed under the MIT license found in the
5  * LICENSE file in the root directory of this source tree.
6  */
7 
8 #ifndef META_OCEAN_CV_FRAME_CONVERTER_RGB_24_H
9 #define META_OCEAN_CV_FRAME_CONVERTER_RGB_24_H
10 
11 #include "ocean/cv/CV.h"
12 #include "ocean/cv/FrameConverter.h"
13 #include "ocean/cv/FrameChannels.h"
14 
15 #include "ocean/base/Worker.h"
16 
17 namespace Ocean
18 {
19 
20 namespace CV
21 {
22 
23 /**
24  * This class provides functions to convert or to change frames with RGB pixel format.
25  * @ingroup cv
26  */
27 class OCEAN_CV_EXPORT FrameConverterRGB24 : public FrameConverter
28 {
29  public:
30 
31  /**
32  * Converts a RGB 24 bit frame to a ARGB 32 bit frame.
33  * @param source The source frame buffer, must be valid
34  * @param target The target frame buffer, must be valid
35  * @param width The width of the frame in pixel, with range (0, infinity)
36  * @param height The height of the frame in pixel, with range (0, infinity)
37  * @param flag Determining the type of conversion
38  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
39  * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
40  * @param alphaValue The value of the alpha channel to be set, with range [0, 255]
41  * @param worker Optional worker object to distribute the computational load
42  */
43  static inline void convertRGB24ToARGB32(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const uint8_t alphaValue = 0xFF, Worker* worker = nullptr);
44 
45  /**
46  * Converts a RGB 24 bit frame to a BGR 24 bit frame.
47  * @param source The source frame buffer, must be valid
48  * @param target The target frame buffer, must be valid
49  * @param width The width of the frame in pixel, with range (0, infinity)
50  * @param height The height of the frame in pixel, with range (0, infinity)
51  * @param flag Determining the type of conversion
52  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
53  * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
54  * @param worker Optional worker object to distribute the computational load
55  */
56  static inline void convertRGB24ToBGR24(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker = nullptr);
57 
58  /**
59  * Converts a RGB 24 bit frame to a BGR 32 bit frame.
60  * @param source The source frame buffer, must be valid
61  * @param target The target frame buffer, must be valid
62  * @param width The width of the frame in pixel, with range (0, infinity)
63  * @param height The height of the frame in pixel, with range (0, infinity)
64  * @param flag Determining the type of conversion
65  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
66  * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
67  * @param worker Optional worker object to distribute the computational load
68  * @remarks The unused last channel of each pixel in target frame is set to zero.
69  */
70  static inline void convertRGB24ToBGR32(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker);
71  /**
72  * Converts a RGB 24 bit frame to a BGRA 32 bit frame.
73  * @param source The source frame buffer, must be valid
74  * @param target The target frame buffer, must be valid
75  * @param width The width of the frame in pixel, with range (0, infinity)
76  * @param height The height of the frame in pixel, with range (0, infinity)
77  * @param flag Determining the type of conversion
78  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
79  * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
80  * @param alphaValue The value of the alpha channel to be set, with range [0, 255]
81  * @param worker Optional worker object to distribute the computational load
82  */
83  static inline void convertRGB24ToBGRA32(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const uint8_t alphaValue = 0xFF, Worker* worker = nullptr);
84 
85  /**
86  * Changes a RGB 24 bit frame to a BGR 24 bit frame in place.
87  * @param frame The frame buffer to be changed, must be valid
88  * @param width The width of the frame in pixel, with range (0, infinity)
89  * @param height The height of the frame in pixel, with range (0, infinity)
90  * @param worker Optional worker object to distribute the computational load
91  */
92  static inline void changeRGB24ToBGR24(uint8_t* frame, const unsigned int width, const unsigned int height, Worker* worker = nullptr);
93 
94  /**
95  * Converts a RGB 24 bit frame to a RGB 24 bit frame.
96  * @param source The source frame buffer, must be valid
97  * @param target The target frame buffer, must be valid
98  * @param width The width of the frame in pixel, with range (0, infinity)
99  * @param height The height of the frame in pixel, with range (0, infinity)
100  * @param flag Determining the type of conversion
101  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
102  * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
103  * @param worker Optional worker object to distribute the computational load
104  */
105  static inline void convertRGB24ToRGB24(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker = nullptr);
106 
107  /**
108  * Converts a RGB 24 bit frame to a RGB 32 bit frame.
109  * @param source The source frame buffer, must be valid
110  * @param target The target frame buffer, must be valid
111  * @param width The width of the frame in pixel, with range (0, infinity)
112  * @param height The height of the frame in pixel, with range (0, infinity)
113  * @param flag Determining the type of conversion
114  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
115  * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
116  * @param worker Optional worker object to distribute the computational load
117  * @remarks The unused last channel of each pixel in target frame is set to zero.
118  */
119  static inline void convertRGB24ToRGB32(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker = nullptr);
120 
121  /**
122  * Converts a RGB 24 bit frame to a RGBA 32 bit frame.
123  * @param source The source frame buffer, must be valid
124  * @param target The target frame buffer, must be valid
125  * @param width The width of the frame in pixel, with range (0, infinity)
126  * @param height The height of the frame in pixel, with range (0, infinity)
127  * @param flag Determining the type of conversion
128  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
129  * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
130  * @param alphaValue The value of the alpha channel to be set, with range [0, 255]
131  * @param worker Optional worker object to distribute the computational load
132  */
133  static inline void convertRGB24ToRGBA32(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const uint8_t alphaValue = 0xFF, Worker* worker = nullptr);
134 
135  /**
136  * Converts a RGB frame to a gray scale frame.
137  * Gray = Red * 0.299 + Green * 0.587 + Blue * 0.114
138  * @param source The source frame buffer, must be valid
139  * @param target The target frame buffer, must be valid
140  * @param width The width of the frame in pixel, with range (0, infinity)
141  * @param height The height of the frame in pixel, with range (0, infinity)
142  * @param flag Determining the type of conversion
143  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
144  * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
145  * @param worker Optional worker object to distribute the computational load
146  */
147  static inline void convertRGB24ToY8(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker = nullptr);
148 
149  /**
150  * Converts a RGB 24 bit frame to a YUV 24 bit frame by the exact conversion.
151  * @param source The source frame buffer, must be valid
152  * @param target The target frame buffer, must be valid
153  * @param width The width of the frame in pixel, with range (0, infinity)
154  * @param height The height of the frame in pixel, with range (0, infinity)
155  * @param flag Determining the type of conversion
156  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
157  * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
158  * @param worker Optional worker object to distribute the computational load
159  */
160  static inline void convertRGB24ToYUV24(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker = nullptr);
161 
162  /**
163  * Converts a full range RGB24 frame to a limited range Y_UV12 frame with 7-bit precision using BT.601.
164  * <pre>
165  * RGB input value range: [ 0, 255]x[ 0, 255]x[ 0, 255]
166  * YUV input value range: [16, 235]x[16, 240]x[16, 240]
167  * </pre>
168  * @param source The source frame plane, must be valid
169  * @param yTarget The y-target frame plane, must be valid
170  * @param uvTarget The uv-target frame plane, must be valid
171  * @param width The width of the frame in pixel, with range [2, infinity), must be a multiple of 2
172  * @param height The height of the frame in pixel, with range [2, infinity), must be a multiple of 2
173  * @param flag Determining the type of conversion
174  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
175  * @param yTargetPaddingElements Optional number of padding elements at the end of each y-target row, in (uint8_t) elements, with range [0, infinity)
176  * @param uvTargetPaddingElements Optional number of padding elements at the end of each uv-target row, in (uint8_t) elements, with range [0, infinity)
177  * @param worker Optional worker object to distribute the computational load
178  */
179  static inline void convertRGB24FullRangeToY_UV12LimitedRange(const uint8_t* source, uint8_t* yTarget, uint8_t* uvTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uvTargetPaddingElements, Worker* worker = nullptr);
180 
181  /**
182  * Converts a full range RGB24 frame to a limited range Y_VU12 frame with 7-bit precision using BT.601.
183  * <pre>
184  * RGB input value range: [ 0, 255]x[ 0, 255]x[ 0, 255]
185  * YVU input value range: [16, 235]x[16, 240]x[16, 240]
186  * </pre>
187  * @param source The source frame plane, must be valid
188  * @param yTarget The y-target frame plane, must be valid
189  * @param vuTarget The vu-target frame plane, must be valid
190  * @param width The width of the frame in pixel, with range [2, infinity), must be a multiple of 2
191  * @param height The height of the frame in pixel, with range [2, infinity), must be a multiple of 2
192  * @param flag Determining the type of conversion
193  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
194  * @param yTargetPaddingElements Optional number of padding elements at the end of each y-target row, in (uint8_t) elements, with range [0, infinity)
195  * @param vuTargetPaddingElements Optional number of padding elements at the end of each vu-target row, in (uint8_t) elements, with range [0, infinity)
196  * @param worker Optional worker object to distribute the computational load
197  */
198  static inline void convertRGB24FullRangeToY_VU12LimitedRange(const uint8_t* source, uint8_t* yTarget, uint8_t* vuTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vuTargetPaddingElements, Worker* worker = nullptr);
199 
200  /**
201  * Converts a full range RGB24 frame to a full range Y_UV12 frame with 7-bit precision using BT.601.
202  * <pre>
203  * RGB input value range: [0, 255]x[0, 255]x[0, 255]
204  * YUV output value range: [0, 255]x[0, 255]x[0, 255]
205  * </pre>
206  * @param source The source frame plane, must be valid
207  * @param yTarget The y-target frame plane, must be valid
208  * @param uvTarget The uv-target frame plane, must be valid
209  * @param width The width of the frame in pixel, with range [2, infinity), must be a multiple of 2
210  * @param height The height of the frame in pixel, with range [2, infinity), must be a multiple of 2
211  * @param flag Determining the type of conversion
212  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
213  * @param yTargetPaddingElements Optional number of padding elements at the end of each y-target row, in (uint8_t) elements, with range [0, infinity)
214  * @param uvTargetPaddingElements Optional number of padding elements at the end of each uv-target row, in (uint8_t) elements, with range [0, infinity)
215  * @param worker Optional worker object to distribute the computational load
216  */
217  static inline void convertRGB24FullRangeToY_UV12FullRange(const uint8_t* source, uint8_t* yTarget, uint8_t* uvTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uvTargetPaddingElements, Worker* worker = nullptr);
218 
219  /**
220  * Converts a full range RGB24 frame to a full range Y_VU12 frame with 7-bit precision using BT.601.
221  * <pre>
222  * RGB input value range: [0, 255]x[0, 255]x[0, 255]
223  * YVU output value range: [0, 255]x[0, 255]x[0, 255]
224  * </pre>
225  * @param source The source frame plane, must be valid
226  * @param yTarget The y-target frame plane, must be valid
227  * @param vuTarget The vu-target frame plane, must be valid
228  * @param width The width of the frame in pixel, with range [2, infinity), must be a multiple of 2
229  * @param height The height of the frame in pixel, with range [2, infinity), must be a multiple of 2
230  * @param flag Determining the type of conversion
231  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
232  * @param yTargetPaddingElements Optional number of padding elements at the end of each y-target row, in (uint8_t) elements, with range [0, infinity)
233  * @param vuTargetPaddingElements Optional number of padding elements at the end of each vu-target row, in (uint8_t) elements, with range [0, infinity)
234  * @param worker Optional worker object to distribute the computational load
235  */
236  static inline void convertRGB24FullRangeToY_VU12FullRange(const uint8_t* source, uint8_t* yTarget, uint8_t* vuTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vuTargetPaddingElements, Worker* worker = nullptr);
237 
238  /**
239  * Converts a full range RGB24 frame to a limited range Y_U_V12 frame with 7-bit precision using BT.601.
240  * <pre>
241  * RGB input value range: [ 0, 255]x[ 0, 255]x[ 0, 255]
242  * YUV input value range: [16, 235]x[16, 240]x[16, 240]
243  * </pre>
244  * @param source The source frame plane, must be valid
245  * @param yTarget The y-target frame plane, must be valid
246  * @param uTarget The u-target frame plane, must be valid
247  * @param vTarget The v-target frame plane, must be valid
248  * @param width The width of the frame in pixel, with range [2, infinity), must be a multiple of 2
249  * @param height The height of the frame in pixel, with range [2, infinity), must be a multiple of 2
250  * @param flag Determining the type of conversion
251  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
252  * @param yTargetPaddingElements Optional number of padding elements at the end of each y-target row, in (uint8_t) elements, with range [0, infinity)
253  * @param uTargetPaddingElements Optional number of padding elements at the end of each u-target row, in (uint8_t) elements, with range [0, infinity)
254  * @param vTargetPaddingElements Optional number of padding elements at the end of each v-target row, in (uint8_t) elements, with range [0, infinity)
255  * @param worker Optional worker object to distribute the computational load
256  */
257  static inline void convertRGB24FullRangeToY_U_V12LimitedRange(const uint8_t* source, uint8_t* yTarget, uint8_t* uTarget, uint8_t* vTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uTargetPaddingElements, const unsigned int vTargetPaddingElements, Worker* worker = nullptr);
258 
259  /**
260  * Converts a full range RGB24 frame to a limited range Y_V_U12 frame with 7-bit precision using BT.601.
261  * <pre>
262  * RGB input value range: [ 0, 255]x[ 0, 255]x[0 , 255]
263  * YVU input value range: [16, 235]x[16, 240]x[16, 240]
264  * </pre>
265  * @param source The source frame plane, must be valid
266  * @param yTarget The y-target frame plane, must be valid
267  * @param vTarget The v-target frame plane, must be valid
268  * @param uTarget The u-target frame plane, must be valid
269  * @param width The width of the frame in pixel, with range [2, infinity), must be a multiple of 2
270  * @param height The height of the frame in pixel, with range [2, infinity), must be a multiple of 2
271  * @param flag Determining the type of conversion
272  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
273  * @param yTargetPaddingElements Optional number of padding elements at the end of each y-target row, in (uint8_t) elements, with range [0, infinity)
274  * @param vTargetPaddingElements Optional number of padding elements at the end of each v-target row, in (uint8_t) elements, with range [0, infinity)
275  * @param uTargetPaddingElements Optional number of padding elements at the end of each u-target row, in (uint8_t) elements, with range [0, infinity)
276  * @param worker Optional worker object to distribute the computational load
277  */
278  static inline void convertRGB24FullRangeToY_V_U12LimitedRange(const uint8_t* source, uint8_t* yTarget, uint8_t* vTarget, uint8_t* uTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vTargetPaddingElements, const unsigned int uTargetPaddingElements, Worker* worker = nullptr);
279 
280  /**
281  * Converts a full range RGB24 frame to a full range Y_U_V12 frame with 7-bit precision using BT.601.
282  * <pre>
283  * RGB input value range: [0, 255]x[0, 255]x[0, 255]
284  * YUV output value range: [0, 255]x[0, 255]x[0, 255]
285  * </pre>
286  * @param source The source frame plane, must be valid
287  * @param yTarget The y-target frame plane, must be valid
288  * @param uTarget The u-target frame plane, must be valid
289  * @param vTarget The v-target frame plane, must be valid
290  * @param width The width of the frame in pixel, with range [2, infinity), must be a multiple of 2
291  * @param height The height of the frame in pixel, with range [2, infinity), must be a multiple of 2
292  * @param flag Determining the type of conversion
293  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
294  * @param yTargetPaddingElements Optional number of padding elements at the end of each y-target row, in (uint8_t) elements, with range [0, infinity)
295  * @param uTargetPaddingElements Optional number of padding elements at the end of each u-target row, in (uint8_t) elements, with range [0, infinity)
296  * @param vTargetPaddingElements Optional number of padding elements at the end of each v-target row, in (uint8_t) elements, with range [0, infinity)
297  * @param worker Optional worker object to distribute the computational load
298  */
299  static inline void convertRGB24FullRangeToY_U_V12FullRange(const uint8_t* source, uint8_t* yTarget, uint8_t* uTarget, uint8_t* vTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uTargetPaddingElements, const unsigned int vTargetPaddingElements, Worker* worker = nullptr);
300 
301  /**
302  * Converts a full range RGB24 frame to a full range Y_V_U12 frame with 7-bit precision using BT.601.
303  * <pre>
304  * RGB input value range: [0, 255]x[0, 255]x[0, 255]
305  * YVU output value range: [0, 255]x[0, 255]x[0, 255]
306  * </pre>
307  * @param source The source frame plane, must be valid
308  * @param yTarget The y-target frame plane, must be valid
309  * @param vTarget The v-target frame plane, must be valid
310  * @param uTarget The u-target frame plane, must be valid
311  * @param width The width of the frame in pixel, with range [2, infinity), must be a multiple of 2
312  * @param height The height of the frame in pixel, with range [2, infinity), must be a multiple of 2
313  * @param flag Determining the type of conversion
314  * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
315  * @param yTargetPaddingElements Optional number of padding elements at the end of each y-target row, in (uint8_t) elements, with range [0, infinity)
316  * @param vTargetPaddingElements Optional number of padding elements at the end of each v-target row, in (uint8_t) elements, with range [0, infinity)
317  * @param uTargetPaddingElements Optional number of padding elements at the end of each u-target row, in (uint8_t) elements, with range [0, infinity)
318  * @param worker Optional worker object to distribute the computational load
319  */
320  static inline void convertRGB24FullRangeToY_V_U12FullRange(const uint8_t* source, uint8_t* yTarget, uint8_t* vTarget, uint8_t* uTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vTargetPaddingElements, const unsigned int uTargetPaddingElements, Worker* worker = nullptr);
321 
322  /**
323  * Changes a RGB 24 bit frame to a YUV 24 bit frame by the exact conversion in place.
324  * @param frame The frame buffer to be changed, must be valid
325  * @param width The width of the frame in pixel, with range (0, infinity)
326  * @param height The height of the frame in pixel, with range (0, infinity)
327  * @param worker Optional worker object to distribute the computational load
328  */
329  static inline void changeRGB24ToYUV24(uint8_t* frame, const unsigned int width, const unsigned int height, Worker* worker = nullptr);
330 
331  /**
332  * Converts one RGB 24 bit pixel to one YUV 24 bit pixel.
333  * As this implementation uses a right shift the result may differ from the correct value by 1.
334  * @param rgb The source pixel value to convert, must be valid and must provided the three channel values
335  * @param yuv The target pixel value, must be valid and must be large enough for three channel values
336  */
337  static inline void convertRGB24ToYUV24Pixel(const uint8_t* rgb, uint8_t* yuv);
338 
339  /**
340  * Converts a RGB 24 bit frame to a R_G_B 24 bit frame.
341  * @param source The source frame buffer, with (width * 3 + targetPaddingElements) * height elements, must be valid
342  * @param rTarget The r target frame buffer, with (width + rPaddingElements) * height elements, must be valid
343  * @param gTarget The g target frame buffer, with (width + gPaddingElements) * height elements, must be valid
344  * @param bTarget The b target frame buffer, with (width + bPaddingElements) * height elements, must be valid
345  * @param width The width of the frame in pixel, with range [2, infinity)
346  * @param height The height of the frame in pixel, with range [2, infinity)
347  * @param flag Determining the type of conversion
348  * @param sourcePaddingElements The number of padding elements at the end of each source row, in (uint8_t) elements, with range [0, infinity)
349  * @param rTargetPaddingElements The number of padding elements at the end of each r-target row, in (uint8_t) elements, with range [0, infinity)
350  * @param gTargetPaddingElements The number of padding elements at the end of each g-target row, in (uint8_t) elements, with range [0, infinity)
351  * @param bTargetPaddingElements The number of padding elements at the end of each b-target row, in (uint8_t) elements, with range [0, infinity)
352  * @param worker Optional worker object to distribute the computation
353  */
354  static inline void convertRGB24ToR_G_B24(const uint8_t* source, uint8_t* rTarget, uint8_t* gTarget, uint8_t* bTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int rTargetPaddingElements, const unsigned int gTargetPaddingElements, const unsigned int bTargetPaddingElements, Worker* worker = nullptr);
355 
356  protected:
357 
358  /**
359  * Changes a subset of RGB 24 bit frame to a BGR 24 bit frame.
360  * @param frame The frame buffer to be changed, must be valid
361  * @param width The width of the frame in pixel, with range (0, infinity)
362  * @param firstRow First (including) row to convert, with range [0, height)
363  * @param numberRows Number of rows to convert, with range [1, height]
364  */
365  static void changeRGB24ToBGR24Subset(uint8_t* frame, const unsigned int width, const unsigned int firstRow, const unsigned int numberRows);
366 
367  /**
368  * Changes a subset of a RGB 24 bit frame to a YUV 24 bit frame by exact conversion.
369  * @param frame The frame buffer to be changed, must be valid
370  * @param width The width of the frame in pixel, with range (0, infinity)
371  * @param firstRow First (including) row to convert, with range [0, height)
372  * @param numberRows Number of rows to convert, with range [1, height]
373  */
374  static void changeRGB24ToYUV24Subset(uint8_t* frame, const unsigned int width, const unsigned int firstRow, const unsigned int numberRows);
375 
376 #if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
377 
378  /**
379  * Converts a RGB 24 bit row to a YUV 24 bit row by using NEON instructions.
380  * Beware: This function uses hard-coded conversion parameters which improves execution performance while also increases binary size when used.
381  * @param source The pointer to the source pixels, must be valid
382  * @param target The pointer to the target pixels receiving the converted pixel data, must be valid
383  * @param size The number of source (and target pixels) to convert, with range [1, infinity)
384  * @param parameters Unused parameters, must be nullptr
385  */
386  static void convertRGB24ToYUV24RowPrecision7BitNEON(const uint8_t* source, uint8_t* target, const size_t size, const void* parameters);
387 
388  /**
389  * Converts 16 RGB24 pixels to 16 YUV24 pixels by using NEON instructions.
390  * Beware: This function uses hard-coded conversion parameters which improves execution performance while also increases binary size when used.
391  * @param source The pointer to the 16 source pixels (with 3 channels = 48 bytes) to convert, must be valid
392  * @param target The pointer to the 16 target pixels (with 3 channels = 48 bytes) receiving the converted pixel data, must be valid
393  */
394  static OCEAN_FORCE_INLINE void convert16PixelsRGB24ToYUV24Precision7BitNEON(const uint8_t* const source, uint8_t* const target);
395 
396 #endif // OCEAN_HARDWARE_NEON_VERSION >= 10
397 };
398 
399 inline void FrameConverterRGB24::convertRGB24ToARGB32(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const uint8_t alphaValue, Worker* worker)
400 {
401  ocean_assert(source != nullptr && target != nullptr);
402  ocean_assert(width >= 1u && height >= 1u);
403 
404  FrameChannels::addFirstChannelValue<uint8_t, 3u>(source, alphaValue, target, width, height, flag, sourcePaddingElements, targetPaddingElements, worker);
405 }
406 
407 inline void FrameConverterRGB24::convertRGB24ToBGR24(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker)
408 {
409  ocean_assert(source != nullptr && target != nullptr);
410  ocean_assert(width >= 1u && height >= 1u);
411 
412  FrameChannels::reverseChannelOrder<uint8_t, 3u>(source, target, width, height, flag, sourcePaddingElements, targetPaddingElements, worker);
413 }
414 
415 inline void FrameConverterRGB24::changeRGB24ToBGR24(uint8_t* frame, const unsigned int width, const unsigned int height, Worker* worker)
416 {
417  ocean_assert(frame);
418  ocean_assert(width != 0u && height != 0u);
419 
420  if (worker)
421  {
422  worker->executeFunction(Worker::Function::createStatic(&FrameConverterRGB24::changeRGB24ToBGR24Subset, frame, width, 0u, 0u), 0u, height, 2u, 3u, 100u);
423  }
424  else
425  {
426  changeRGB24ToBGR24Subset(frame, width, 0u, height);
427  }
428 }
429 
430 inline void FrameConverterRGB24::convertRGB24ToBGR32(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker)
431 {
432  ocean_assert(source != nullptr && target != nullptr);
433  ocean_assert(width >= 1u && height >= 1u);
434 
435  // source frame R G B
436  // 0 1 2
437  // target frame B G R -
438  // pattern 2 1 0
439  constexpr unsigned int shufflePattern = 0x012u;
440 
441  FrameChannels::shuffleChannelsAndSetLastChannelValue<uint8_t, 3u, 4u, shufflePattern>(source, 0u, target, width, height, flag, sourcePaddingElements, targetPaddingElements, worker);
442 }
443 
444 inline void FrameConverterRGB24::convertRGB24ToBGRA32(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const uint8_t alphaValue, Worker* worker)
445 {
446  ocean_assert(source != nullptr && target != nullptr);
447  ocean_assert(width >= 1u && height >= 1u);
448 
449  // source frame R G B
450  // 0 1 2
451  // target frame B G R A
452  // pattern 2 1 0
453  constexpr unsigned int shufflePattern = 0x012u;
454 
455  FrameChannels::shuffleChannelsAndSetLastChannelValue<uint8_t, 3u, 4u, shufflePattern>(source, alphaValue, target, width, height, flag, sourcePaddingElements, targetPaddingElements, worker);
456 }
457 
458 inline void FrameConverterRGB24::convertRGB24ToRGB24(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker)
459 {
460  ocean_assert(source != nullptr && target != nullptr);
461  ocean_assert(width >= 1u && height >= 1u);
462 
463  FrameChannels::transformGeneric<uint8_t, 3u>(source, target, width, height, flag, sourcePaddingElements, targetPaddingElements, worker);
464 }
465 
466 inline void FrameConverterRGB24::convertRGB24ToRGB32(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker)
467 {
468  ocean_assert(source != nullptr && target != nullptr);
469  ocean_assert(width >= 1u && height >= 1u);
470 
471  FrameChannels::addLastChannelValue<uint8_t, 3u>(source, 0u, target, width, height, flag, sourcePaddingElements, targetPaddingElements, worker);
472 }
473 
474 inline void FrameConverterRGB24::convertRGB24ToRGBA32(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const uint8_t alphaValue, Worker* worker)
475 {
476  ocean_assert(source != nullptr && target != nullptr);
477  ocean_assert(width >= 1u && height >= 1u);
478 
479  FrameChannels::addLastChannelValue<uint8_t, 3u>(source, alphaValue, target, width, height, flag, sourcePaddingElements, targetPaddingElements, worker);
480 }
481 
482 inline void FrameConverterRGB24::convertRGB24ToY8(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker)
483 {
484  ocean_assert(source != nullptr && target != nullptr);
485  ocean_assert(width >= 1u && height >= 1u);
486 
487  const unsigned int sourceStrideElements = width * 3u + sourcePaddingElements;
488  const unsigned int targetStrideElements = width + targetPaddingElements;
489 
490  constexpr unsigned int channelFactors[3] = {38u, 75u, 15u}; // 38/128 ~ 0.299, 75/128 ~ 0.587, 15/128 ~ 0.114
491 
492  static_assert(channelFactors[0] + channelFactors[1] + channelFactors[2] == 128u, "Invalid factors!");
493 
494  constexpr bool useFactorChannel0 = channelFactors[0] != 0u;
495  constexpr bool useFactorChannel1 = channelFactors[1] != 0u;
496  constexpr bool useFactorChannel2 = channelFactors[2] != 0u;
497 
498  const bool areContinuous = sourcePaddingElements == 0u && targetPaddingElements == 0u;
499 
500  FrameConverter::convertGenericPixelFormat(source, target, width, height, sourceStrideElements, targetStrideElements, flag, CV::FrameChannels::convertRow3ChannelsTo1Channel8BitPerChannel7BitPrecision<useFactorChannel0, useFactorChannel1, useFactorChannel2>, CV::FrameChannels::reverseRowPixelOrderInPlace<uint8_t, 1u>, areContinuous, channelFactors, worker);
501 }
502 
503 inline void FrameConverterRGB24::convertRGB24ToYUV24(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker)
504 {
505  ocean_assert(source != nullptr && target != nullptr);
506  ocean_assert(width >= 1u && height >= 1u);
507 
508  const unsigned int sourceStrideElements = width * 3u + sourcePaddingElements;
509  const unsigned int targetStrideElements = width * 3u + targetPaddingElements;
510 
511 #if defined(OCEAN_USE_HARDCODED_RGB24_TO_YUV24_CONVERTER) && OCEAN_HARDWARE_NEON_VERSION >= 10
512 
513  // we keep this function mainly to show the performance difference between the hard-coded implementation and a variable implementation
514 
515  FrameConverter::convertGenericPixelFormat(source, target, width, height, sourceStrideElements, targetStrideElements, flag, FrameConverterRGB24::convertRGB24ToYUV24RowPrecision7BitNEON, CV::FrameChannels::reverseRowPixelOrderInPlace<uint8_t, 3u>, nullptr, worker);
516 
517 #else
518 
519  // approximation:
520  // Y = ( 33 * R + 64 * G + 13 * B) / 128 + 16
521  // U = (-19 * R - 37 * G + 56 * B) / 128 + 128
522  // V = ( 56 * R - 47 * G - 9 * B) / 128 + 128
523 
524  const int parameters[12] = {33, -19, 56, 64, -37, -47, 13, 56, -9, 16, 128, 128};
525 
526  const bool areContinuous = sourcePaddingElements == 0u && targetPaddingElements == 0u;
527 
528  FrameConverter::convertGenericPixelFormat(source, target, width, height, sourceStrideElements, targetStrideElements, flag, CV::FrameChannels::convertRow3ChannelsTo3Channels8BitPerChannel7BitPrecision, CV::FrameChannels::reverseRowPixelOrderInPlace<uint8_t, 3u>, areContinuous, parameters, worker);
529 
530 #endif
531 }
532 
533 inline void FrameConverterRGB24::convertRGB24FullRangeToY_UV12LimitedRange(const uint8_t* source, uint8_t* yTarget, uint8_t* uvTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uvTargetPaddingElements, Worker* worker)
534 {
535  ocean_assert(source != nullptr && yTarget != nullptr && uvTarget != nullptr);
536 
537  ocean_assert(width >= 2u && width % 2u == 0u);
538  ocean_assert(height >= 2u && height % 2u == 0u);
539 
540  if (width < 2u || height < 2u || width % 2u != 0u || height % 2u != 0u)
541  {
542  return;
543  }
544 
545  /*
546  * RGB input value range: [ 0, 255]x[ 0, 255]x[ 0, 255]
547  * YUV output value range: [16, 235]x[16, 240]x[16, 240]
548  *
549  * | Y | | 0.2578125 0.5039063 0.09765625 16.0 | | R |
550  * | U | = | -0.1484375 -0.2890625 0.4375 128.0 | * | G |
551  * | V | | 0.4375 -0.3671875 -0.0703125 128.0 | | B |
552  * | 1 |
553  * Approximation with 7 bit precision:
554  * | Y | | 33 64 13 16 * 128 | | R |
555  * 128 * | U | = | -19 -37 56 128 * 128 | * | G |
556  * | V | | 56 -47 -9 128 * 128 | | B |
557  * | 1 |
558  */
559 
560  const int options[3 + 9 + 3] =
561  {
562  // padding parameters
563  int(sourcePaddingElements), int(yTargetPaddingElements), int(uvTargetPaddingElements),
564 
565  // multiplication parameters
566  33, -19, 56, 64, -37, -47, 13, 56, -9,
567 
568  // bias/translation parameters
569  16, 128, 128
570  };
571 
572  void* target[2] =
573  {
574  yTarget,
575  uvTarget,
576  };
577 
578  FrameConverter::convertArbitraryPixelFormat((const void**)(&source), target, width, height, flag, 2u, FrameConverter::convertTwoRows_1Plane3Channels_To_1Plane1ChannelAnd1Plane2ChannelsDownsampled2x2_8BitPerChannel_Precision7Bit, options, worker);
579 }
580 
581 inline void FrameConverterRGB24::convertRGB24FullRangeToY_VU12LimitedRange(const uint8_t* source, uint8_t* yTarget, uint8_t* vuTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vuTargetPaddingElements, Worker* worker)
582 {
583  ocean_assert(source != nullptr && yTarget != nullptr && vuTarget != nullptr);
584 
585  ocean_assert(width >= 2u && width % 2u == 0u);
586  ocean_assert(height >= 2u && height % 2u == 0u);
587 
588  if (width < 2u || height < 2u || width % 2u != 0u || height % 2u != 0u)
589  {
590  return;
591  }
592 
593  /*
594  * RGB input value range: [ 0, 255]x[ 0, 255]x[ 0, 255]
595  * YVU output value range: [16, 235]x[16, 240]x[16, 240]
596  *
597  * | Y | | 0.2578125 0.5039063 0.09765625 16.0 | | R |
598  * | V | = | 0.4375 -0.3671875 -0.0703125 128.0 | * | G |
599  * | U | | -0.1484375 -0.2890625 0.4375 128.0 | | B |
600  * | 1 |
601  * Approximation with 7 bit precision:
602  * | Y | | 33 64 13 16 * 128 | | R |
603  * 128 * | V | = | 56 -47 -9 128 * 128 | * | G |
604  * | U | | -19 -37 56 128 * 128 | | B |
605  * | 1 |
606  */
607 
608  const int options[3 + 9 + 3] =
609  {
610  // padding parameters
611  int(sourcePaddingElements), int(yTargetPaddingElements), int(vuTargetPaddingElements),
612 
613  // multiplication parameters
614  33, 56, -19, 64, -47, -37, 13, -9, 56,
615 
616  // bias/translation parameters
617  16, 128, 128
618  };
619 
620  void* target[2] =
621  {
622  yTarget,
623  vuTarget
624  };
625 
626  FrameConverter::convertArbitraryPixelFormat((const void**)(&source), target, width, height, flag, 2u, FrameConverter::convertTwoRows_1Plane3Channels_To_1Plane1ChannelAnd1Plane2ChannelsDownsampled2x2_8BitPerChannel_Precision7Bit, options, worker);
627 }
628 
629 inline void FrameConverterRGB24::convertRGB24FullRangeToY_UV12FullRange(const uint8_t* source, uint8_t* yTarget, uint8_t* uvTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uvTargetPaddingElements, Worker* worker)
630 {
631  ocean_assert(source != nullptr && yTarget != nullptr && uvTarget != nullptr);
632 
633  ocean_assert(width >= 2u && width % 2u == 0u);
634  ocean_assert(height >= 2u && height % 2u == 0u);
635 
636  if (width < 2u || height < 2u || width % 2u != 0u || height % 2u != 0u)
637  {
638  return;
639  }
640 
641  /*
642  * RGB input value range: [0, 255]x[0, 255]x[0, 255]
643  * YUV output value range: [0, 255]x[0, 255]x[0, 255]
644  *
645  * | Y | | 0.299 0.587 0.114 0 | | R |
646  * | U | = | -0.168736 -0.331264 0.5 128 | * | G |
647  * | V | | 0.5 -0.418688 -0.081312 128 | | B |
648  * | 1 |
649  * Approximation with 7 bit precision:
650  * | Y | | 38 75 15 0 * 128 | | R |
651  * 128 * | U | = | -22 -42 64 128 * 128 | * | G |
652  * | V | | 64 -54 -10 128 * 128 | | B |
653  * | 1 |
654  */
655 
656  const int options[3 + 9 + 3] =
657  {
658  // padding parameters
659  int(sourcePaddingElements), int(yTargetPaddingElements), int(uvTargetPaddingElements),
660 
661  // multiplication parameters
662  38, -22, 64, 75, -42, -54, 15, 64, -10,
663 
664  // bias/translation parameters
665  0, 128, 128
666  };
667 
668  void* target[2] =
669  {
670  yTarget,
671  uvTarget
672  };
673 
674  FrameConverter::convertArbitraryPixelFormat((const void**)(&source), target, width, height, flag, 2u, FrameConverter::convertTwoRows_1Plane3Channels_To_1Plane1ChannelAnd1Plane2ChannelsDownsampled2x2_8BitPerChannel_Precision7Bit, options, worker);
675 }
676 
677 inline void FrameConverterRGB24::convertRGB24FullRangeToY_VU12FullRange(const uint8_t* source, uint8_t* yTarget, uint8_t* vuTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vuTargetPaddingElements, Worker* worker)
678 {
679  ocean_assert(source != nullptr && yTarget != nullptr && vuTarget != nullptr);
680 
681  ocean_assert(width >= 2u && width % 2u == 0u);
682  ocean_assert(height >= 2u && height % 2u == 0u);
683 
684  if (width < 2u || height < 2u || width % 2u != 0u || height % 2u != 0u)
685  {
686  return;
687  }
688 
689  /*
690  * RGB input value range: [0, 255]x[0, 255]x[0, 255]
691  * YVU output value range: [0, 255]x[0, 255]x[0, 255]
692  *
693  * | Y | | 0.299 0.587 0.114 0 | | R |
694  * | V | = | 0.5 -0.418688 -0.081312 128 | * | G |
695  * | U | | -0.168736 -0.331264 0.5 128 | | B |
696  * | 1 |
697  * Approximation with 7 bit precision:
698  * | Y | | 38 75 15 0 * 128 | | R |
699  * 128 * | V | = | 64 -54 -10 128 * 128 | * | G |
700  * | U | | -22 -42 64 128 * 128 | | B |
701  * | 1 |
702  */
703 
704  const int options[3 + 9 + 3] =
705  {
706  // padding parameters
707  int(sourcePaddingElements), int(yTargetPaddingElements), int(vuTargetPaddingElements),
708 
709  // multiplication parameters
710  38, 64, -22, 75, -54, -42, 15, -10, 64,
711 
712  // bias/translation parameters
713  0, 128, 128
714  };
715 
716  void* target[2] =
717  {
718  yTarget,
719  vuTarget
720  };
721 
722  FrameConverter::convertArbitraryPixelFormat((const void**)(&source), target, width, height, flag, 2u, FrameConverter::convertTwoRows_1Plane3Channels_To_1Plane1ChannelAnd1Plane2ChannelsDownsampled2x2_8BitPerChannel_Precision7Bit, options, worker);
723 }
724 
725 inline void FrameConverterRGB24::convertRGB24FullRangeToY_U_V12LimitedRange(const uint8_t* source, uint8_t* yTarget, uint8_t* uTarget, uint8_t* vTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uTargetPaddingElements, const unsigned int vTargetPaddingElements, Worker* worker)
726 {
727  ocean_assert(source != nullptr && yTarget != nullptr && uTarget != nullptr && vTarget != nullptr);
728 
729  ocean_assert(width >= 2u && width % 2u == 0u);
730  ocean_assert(height >= 2u && height % 2u == 0u);
731 
732  if (width < 2u || height < 2u || width % 2u != 0u || height % 2u != 0u)
733  {
734  return;
735  }
736 
737  /*
738  * RGB input value range: [ 0, 255]x[ 0, 255]x[ 0, 255]
739  * YUV output value range: [16, 235]x[16, 240]x[16, 240]
740  *
741  * | Y | | 0.2578125 0.5039063 0.09765625 16.0 | | R |
742  * | U | = | -0.1484375 -0.2890625 0.4375 128.0 | * | G |
743  * | V | | 0.4375 -0.3671875 -0.0703125 128.0 | | B |
744  * | 1 |
745  * Approximation with 7 bit precision:
746  * | Y | | 33 64 13 16 * 128 | | R |
747  * 128 * | U | = | -19 -37 56 128 * 128 | * | G |
748  * | V | | 56 -47 -9 128 * 128 | | B |
749  * | 1 |
750  */
751 
752  const int options[4 + 9 + 3] =
753  {
754  // padding parameters
755  int(sourcePaddingElements), int(yTargetPaddingElements), int(uTargetPaddingElements), int(vTargetPaddingElements),
756 
757  // multiplication parameters
758  33, -19, 56, 64, -37, -47, 13, 56, -9,
759 
760  // bias/translation parameters
761  16, 128, 128
762  };
763 
764  void* target[3] =
765  {
766  yTarget,
767  uTarget,
768  vTarget
769  };
770 
771  FrameConverter::convertArbitraryPixelFormat((const void**)(&source), target, width, height, flag, 2u, FrameConverter::convertTwoRows_1Plane3Channels_To_1Plane1ChannelAnd2Planes1ChannelsDownsampled2x2_8BitPerChannel_Precision7Bit, options, worker);
772 }
773 
774 inline void FrameConverterRGB24::convertRGB24FullRangeToY_V_U12LimitedRange(const uint8_t* source, uint8_t* yTarget, uint8_t* vTarget, uint8_t* uTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vTargetPaddingElements, const unsigned int uTargetPaddingElements, Worker* worker)
775 {
776  // just swapping u- and v-plane, and calling converter to Y_U_V12
777 
778  convertRGB24FullRangeToY_U_V12LimitedRange(source, yTarget, uTarget, vTarget, width, height, flag, sourcePaddingElements, yTargetPaddingElements, uTargetPaddingElements, vTargetPaddingElements, worker);
779 }
780 
781 inline void FrameConverterRGB24::convertRGB24FullRangeToY_U_V12FullRange(const uint8_t* source, uint8_t* yTarget, uint8_t* uTarget, uint8_t* vTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uTargetPaddingElements, const unsigned int vTargetPaddingElements, Worker* worker)
782 {
783  ocean_assert(source != nullptr && yTarget != nullptr && uTarget != nullptr && vTarget != nullptr);
784 
785  ocean_assert(width >= 2u && width % 2u == 0u);
786  ocean_assert(height >= 2u && height % 2u == 0u);
787 
788  if (width < 2u || height < 2u || width % 2u != 0u || height % 2u != 0u)
789  {
790  return;
791  }
792 
793  /*
794  * RGB input value range: [0, 255]x[0, 255]x[0, 255]
795  * YUV output value range: [0, 255]x[0, 255]x[0, 255]
796  *
797  * | Y | | 0.299 0.587 0.114 0 | | R |
798  * | U | = | -0.168736 -0.331264 0.5 128 | * | G |
799  * | V | | 0.5 -0.418688 -0.081312 128 | | B |
800  * | 1 |
801  * Approximation with 7 bit precision:
802  * | Y | | 38 75 15 0 * 128 | | R |
803  * 128 * | U | = | -22 -42 64 128 * 128 | * | G |
804  * | V | | 64 -54 -10 128 * 128 | | B |
805  * | 1 |
806  */
807 
808  const int options[4 + 9 + 3] =
809  {
810  // padding parameters
811  int(sourcePaddingElements), int(yTargetPaddingElements), int(uTargetPaddingElements), int(vTargetPaddingElements),
812 
813  // multiplication parameters
814  38, -22, 64, 75, -42, -54, 15, 64, -10,
815 
816  // bias/translation parameters
817  0, 128, 128
818  };
819 
820  void* target[3] =
821  {
822  yTarget,
823  uTarget,
824  vTarget
825  };
826 
827  FrameConverter::convertArbitraryPixelFormat((const void**)(&source), target, width, height, flag, 2u, FrameConverter::convertTwoRows_1Plane3Channels_To_1Plane1ChannelAnd2Planes1ChannelsDownsampled2x2_8BitPerChannel_Precision7Bit, options, worker);
828 }
829 
830 inline void FrameConverterRGB24::convertRGB24FullRangeToY_V_U12FullRange(const uint8_t* source, uint8_t* yTarget, uint8_t* vTarget, uint8_t* uTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vTargetPaddingElements, const unsigned int uTargetPaddingElements, Worker* worker)
831 {
832  // just swapping u- and v-plane, and calling converter to Y_U_V12
833 
834  convertRGB24FullRangeToY_U_V12FullRange(source, yTarget, uTarget, vTarget, width, height, flag, sourcePaddingElements, yTargetPaddingElements, uTargetPaddingElements, vTargetPaddingElements, worker);
835 }
836 
837 inline void FrameConverterRGB24::changeRGB24ToYUV24(uint8_t* frame, const unsigned int width, const unsigned int height, Worker* worker)
838 {
839  ocean_assert(frame);
840 
841  if (worker)
842  {
843  worker->executeFunction(Worker::Function::createStatic(&FrameConverterRGB24::changeRGB24ToYUV24Subset, frame, width, 0u, 0u), 0u, height, 2u, 3u, 100u);
844  }
845  else
846  {
847  changeRGB24ToYUV24Subset(frame, width, 0u, height);
848  }
849 }
850 
851 inline void FrameConverterRGB24::convertRGB24ToYUV24Pixel(const uint8_t* rgb, uint8_t* yuv)
852 {
853  ocean_assert(rgb && yuv);
854 
855  yuv[0] = uint8_t(((rgb[0] * 66 + rgb[1] * 129 + rgb[2] * 25 + 128) >> 8) + 16);
856  yuv[1] = uint8_t(((rgb[0] * -38 - rgb[1] * 74 + rgb[2] * 112 + 128) >> 8) + 128);
857  yuv[2] = uint8_t(((rgb[0] * 112 - rgb[1] * 94 - rgb[2] * 18 + 128) >> 8) + 128);
858 
859  ocean_assert(abs(int(yuv[0]) - int(((rgb[0] * 66 + rgb[1] * 129 + rgb[2] * 25 + 128) / 256) + 16)) <= 1);
860  ocean_assert(abs(int(yuv[1]) - int(((rgb[0] * -38 - rgb[1] * 74 + rgb[2] * 112 + 128) / 256) + 128)) <= 1);
861  ocean_assert(abs(int(yuv[2]) - int(((rgb[0] * 112 - rgb[1] * 94 - rgb[2] * 18 + 128) / 256) + 128)) <= 1);
862 }
863 
864 inline void FrameConverterRGB24::convertRGB24ToR_G_B24(const uint8_t* source, uint8_t* rTarget, uint8_t* gTarget, uint8_t* bTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int rTargetPaddingElements, const unsigned int gTargetPaddingElements, const unsigned int bTargetPaddingElements, Worker* worker)
865 {
866  ocean_assert(source != nullptr && rTarget != nullptr && gTarget != nullptr && bTarget != nullptr);
867 
868  if (width < 1u || height < 1u)
869  {
870  return;
871  }
872 
873  const unsigned int options[4] = {sourcePaddingElements, rTargetPaddingElements, gTargetPaddingElements, bTargetPaddingElements};
874 
875  void* targets[3] =
876  {
877  rTarget,
878  gTarget,
879  bTarget
880  };
881 
882  FrameConverter::convertArbitraryPixelFormat((const void**)(&source), targets, width, height, flag, 1u, FrameConverter::mapOneRow_1Plane3Channels_To_3Plane1Channel_8BitPerChannel<0u, 1u, 2u>, options, worker);
883 }
884 
885 #if defined(OCEAN_HARDWARE_NEON_VERSION) && OCEAN_HARDWARE_NEON_VERSION >= 10
886 
887 OCEAN_FORCE_INLINE void FrameConverterRGB24::convert16PixelsRGB24ToYUV24Precision7BitNEON(const uint8_t* const source, uint8_t* const target)
888 {
889  ocean_assert(source != nullptr && target != nullptr);
890 
891  // the documentation of this function designed for RGB24 to YUV24 conversion
892 
893  // precise color space conversion:
894  // | Y | | 0.2578125 0.5039063 0.09765625 16.0 | | R |
895  // | U | = | -0.1484375 -0.2890625 0.4375 128.0 | * | G |
896  // | V | | 0.4375 -0.3671875 -0.0703125 128.0 | | B |
897  // | 1 |
898 
899  // approximation:
900  // Y = ( 33 * R + 64 * G + 13 * B) / 128 + 16
901  // U = (-19 * R - 37 * G + 56 * B) / 128 + 128
902  // V = ( 56 * R - 47 * G - 9 * B) / 128 + 128
903 
904  // we load 8 pixels (= 3 * 8 values) and directly deinterleave the 3 channels so that we receive the following patterns:
905  // source_u_8x8x3.val[0]: R R R R R R R R
906  // source_u_8x8x3.val[1]: G G G G G G G G
907  // source_u_8x8x3.val[2]: B B B B B B B B
908 
909  const uint8x16x3_t source_u_8x16x3 = vld3q_u8(source);
910 
911  const uint8x8_t source0_low_u_8x8 = vget_low_u8(source_u_8x16x3.val[0]);
912  const uint8x8_t source0_high_u_8x8 = vget_high_u8(source_u_8x16x3.val[0]);
913 
914  const uint8x8_t source1_low_u_8x8 = vget_low_u8(source_u_8x16x3.val[1]);
915  const uint8x8_t source1_high_u_8x8 = vget_high_u8(source_u_8x16x3.val[1]);
916 
917  const uint8x8_t source2_low_u_8x8 = vget_low_u8(source_u_8x16x3.val[2]);
918  const uint8x8_t source2_high_u_8x8 = vget_high_u8(source_u_8x16x3.val[2]);
919 
920 
921  const uint8x8_t constant33_u_8x8 = vdup_n_u8(33);
922  uint16x8_t intermediateResults0_low_u_16x8 = vmull_u8(source0_low_u_8x8, constant33_u_8x8);
923  uint16x8_t intermediateResults0_high_u_16x8 = vmull_u8(source0_high_u_8x8, constant33_u_8x8);
924 
925  const uint8x8_t constant64_u_8x8 = vdup_n_u8(64);
926  intermediateResults0_low_u_16x8 = vmlal_u8(intermediateResults0_low_u_16x8, source1_low_u_8x8, constant64_u_8x8);
927  intermediateResults0_high_u_16x8 = vmlal_u8(intermediateResults0_high_u_16x8, source1_high_u_8x8, constant64_u_8x8);
928 
929  const uint8x8_t constant13_u_8x8 = vdup_n_u8(13);
930  intermediateResults0_low_u_16x8 = vmlal_u8(intermediateResults0_low_u_16x8, source2_low_u_8x8, constant13_u_8x8);
931  intermediateResults0_high_u_16x8 = vmlal_u8(intermediateResults0_high_u_16x8, source2_high_u_8x8, constant13_u_8x8);
932 
933 
934  const uint8x8_t constant56_u_8x8 = vdup_n_u8(56);
935  uint16x8_t intermediateResults1_low_u_16x8 = vmull_u8(source2_low_u_8x8, constant56_u_8x8);
936  uint16x8_t intermediateResults1_high_u_16x8 = vmull_u8(source2_high_u_8x8, constant56_u_8x8);
937 
938  uint16x8_t intermediateResults2_low_u_16x8 = vmull_u8(source0_low_u_8x8, constant56_u_8x8);
939  uint16x8_t intermediateResults2_high_u_16x8 = vmull_u8(source0_high_u_8x8, constant56_u_8x8);
940 
941 
942  const uint8x8_t constant19_u_8x8 = vdup_n_u8(19);
943  intermediateResults1_low_u_16x8 = vmlsl_u8(intermediateResults1_low_u_16x8, source0_low_u_8x8, constant19_u_8x8);
944  intermediateResults1_high_u_16x8 = vmlsl_u8(intermediateResults1_high_u_16x8, source0_high_u_8x8, constant19_u_8x8);
945 
946  const uint8x8_t constant37_u_8x8 = vdup_n_u8(37);
947  intermediateResults1_low_u_16x8 = vmlsl_u8(intermediateResults1_low_u_16x8, source1_low_u_8x8, constant37_u_8x8);
948  intermediateResults1_high_u_16x8 = vmlsl_u8(intermediateResults1_high_u_16x8, source1_high_u_8x8, constant37_u_8x8);
949 
950 
951  const uint8x8_t constant47_u_8x8 = vdup_n_u8(47);
952  intermediateResults2_low_u_16x8 = vmlsl_u8(intermediateResults2_low_u_16x8, source1_low_u_8x8, constant47_u_8x8);
953  intermediateResults2_high_u_16x8 = vmlsl_u8(intermediateResults2_high_u_16x8, source1_high_u_8x8, constant47_u_8x8);
954 
955  const uint8x8_t constant9_u_8x8 = vdup_n_u8(9);
956  intermediateResults2_low_u_16x8 = vmlsl_u8(intermediateResults2_low_u_16x8, source2_low_u_8x8, constant9_u_8x8);
957  intermediateResults2_high_u_16x8 = vmlsl_u8(intermediateResults2_high_u_16x8, source2_high_u_8x8, constant9_u_8x8);
958 
959 
960  const int16x8_t constant16_s_16x8 = vdupq_n_s16(16 * 128);
961  const int16x8_t constant128_s_16x8 = vdupq_n_s16(128 * 128);
962 
963  const int16x8_t intermediateResults0_low_s_16x8 = vqaddq_s16(vreinterpretq_s16_u16(intermediateResults0_low_u_16x8), constant16_s_16x8);
964  const int16x8_t intermediateResults0_high_s_16x8 = vqaddq_s16(vreinterpretq_s16_u16(intermediateResults0_high_u_16x8), constant16_s_16x8);
965 
966  const int16x8_t intermediateResults1_low_s_16x8 = vqaddq_s16(vreinterpretq_s16_u16(intermediateResults1_low_u_16x8), constant128_s_16x8);
967  const int16x8_t intermediateResults1_high_s_16x8 = vqaddq_s16(vreinterpretq_s16_u16(intermediateResults1_high_u_16x8), constant128_s_16x8);
968 
969  const int16x8_t intermediateResults2_low_s_16x8 = vqaddq_s16(vreinterpretq_s16_u16(intermediateResults2_low_u_16x8), constant128_s_16x8);
970  const int16x8_t intermediateResults2_high_s_16x8 = vqaddq_s16(vreinterpretq_s16_u16(intermediateResults2_high_u_16x8), constant128_s_16x8);
971 
972  // saturated narrow signed to unsigned
973 
974  uint8x16x3_t results_u_8x16x3;
975  results_u_8x16x3.val[0] = vcombine_u8(vqrshrun_n_s16(intermediateResults0_low_s_16x8, 7), vqrshrun_n_s16(intermediateResults0_high_s_16x8, 7));
976  results_u_8x16x3.val[1] = vcombine_u8(vqrshrun_n_s16(intermediateResults1_low_s_16x8, 7), vqrshrun_n_s16(intermediateResults1_high_s_16x8, 7));
977  results_u_8x16x3.val[2] = vcombine_u8(vqrshrun_n_s16(intermediateResults2_low_s_16x8, 7), vqrshrun_n_s16(intermediateResults2_high_s_16x8, 7));
978 
979  // and we can store the result
980  vst3q_u8(target, results_u_8x16x3);
981 }
982 
983 #endif // OCEAN_HARDWARE_NEON_VERSION >= 10
984 
985 }
986 
987 }
988 
989 #endif // META_OCEAN_CV_FRAME_CONVERTER_RGB_24_H
Ocean::CV::FrameChannels::convertRow3ChannelsTo3Channels8BitPerChannel7BitPrecision
static void convertRow3ChannelsTo3Channels8BitPerChannel7BitPrecision(const uint8_t *source, uint8_t *target, const size_t size, const void *parameters)
Converts a row of pixels with 3 channels to pixels with 3 channels by a linear combination of the thr...
Ocean::CV::FrameConverter
This is the base class for all frame converter classes.
Definition: FrameConverter.h:32
Ocean::CV::FrameConverter::ConversionFlag
ConversionFlag
Definition of individual conversion flags.
Definition: FrameConverter.h:39
Ocean::CV::FrameConverter::convertGenericPixelFormat
static void convertGenericPixelFormat(const TSource *source, TTarget *target, const unsigned int width, const unsigned int height, const unsigned int sourceStrideElements, const unsigned int targetStrideElements, const ConversionFlag flag, const RowConversionFunction< TSource, TTarget > rowConversionFunction, const RowReversePixelOrderInPlaceFunction< TTarget > targetReversePixelOrderInPlaceFunction, const bool areContinuous, const void *options, Worker *worker)
Converts a frame with generic pixel format (e.g., RGBA32, BGR24, YUV24, ...) to a frame with generic ...
Definition: FrameConverter.h:3211
Ocean::CV::FrameConverter::convertTwoRows_1Plane3Channels_To_1Plane1ChannelAnd2Planes1ChannelsDownsampled2x2_8BitPerChannel_Precision7Bit
static void convertTwoRows_1Plane3Channels_To_1Plane1ChannelAnd2Planes1ChannelsDownsampled2x2_8BitPerChannel_Precision7Bit(const void **sources, void **targets, const unsigned int multipleRowIndex, const unsigned int width, const unsigned int height, const ConversionFlag conversionFlag, const void *options)
Converts two rows of an image with e.g., a RGB pixel format to two rows of an image with e....
Ocean::CV::FrameConverter::convertTwoRows_1Plane3Channels_To_1Plane1ChannelAnd1Plane2ChannelsDownsampled2x2_8BitPerChannel_Precision7Bit
static void convertTwoRows_1Plane3Channels_To_1Plane1ChannelAnd1Plane2ChannelsDownsampled2x2_8BitPerChannel_Precision7Bit(const void **sources, void **targets, const unsigned int multipleRowIndex, const unsigned int width, const unsigned int height, const ConversionFlag conversionFlag, const void *options)
Converts two rows of an image with e.g., a RGB pixel format to two rows of an image with e....
Ocean::CV::FrameConverter::convertArbitraryPixelFormat
static void convertArbitraryPixelFormat(const void **sources, void **targets, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int multipleRowsPerIteration, const MultipleRowsConversionFunction multipleRowsConversionFunction, const void *options, Worker *worker)
Converts a frame with arbitrary pixel format (e.g., Y_UV12, Y_VU12, YUYV16, ...) to a frame with arbi...
Definition: FrameConverter.h:3234
Ocean::CV::FrameConverterRGB24
This class provides functions to convert or to change frames with RGB pixel format.
Definition: FrameConverterRGB24.h:28
Ocean::CV::FrameConverterRGB24::convertRGB24FullRangeToY_VU12FullRange
static void convertRGB24FullRangeToY_VU12FullRange(const uint8_t *source, uint8_t *yTarget, uint8_t *vuTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vuTargetPaddingElements, Worker *worker=nullptr)
Converts a full range RGB24 frame to a full range Y_VU12 frame with 7-bit precision using BT....
Definition: FrameConverterRGB24.h:677
Ocean::CV::FrameConverterRGB24::changeRGB24ToBGR24
static void changeRGB24ToBGR24(uint8_t *frame, const unsigned int width, const unsigned int height, Worker *worker=nullptr)
Changes a RGB 24 bit frame to a BGR 24 bit frame in place.
Definition: FrameConverterRGB24.h:415
Ocean::CV::FrameConverterRGB24::convertRGB24ToRGB24
static void convertRGB24ToRGB24(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr)
Converts a RGB 24 bit frame to a RGB 24 bit frame.
Definition: FrameConverterRGB24.h:458
Ocean::CV::FrameConverterRGB24::convertRGB24FullRangeToY_VU12LimitedRange
static void convertRGB24FullRangeToY_VU12LimitedRange(const uint8_t *source, uint8_t *yTarget, uint8_t *vuTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vuTargetPaddingElements, Worker *worker=nullptr)
Converts a full range RGB24 frame to a limited range Y_VU12 frame with 7-bit precision using BT....
Definition: FrameConverterRGB24.h:581
Ocean::CV::FrameConverterRGB24::convertRGB24FullRangeToY_UV12FullRange
static void convertRGB24FullRangeToY_UV12FullRange(const uint8_t *source, uint8_t *yTarget, uint8_t *uvTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uvTargetPaddingElements, Worker *worker=nullptr)
Converts a full range RGB24 frame to a full range Y_UV12 frame with 7-bit precision using BT....
Definition: FrameConverterRGB24.h:629
Ocean::CV::FrameConverterRGB24::convert16PixelsRGB24ToYUV24Precision7BitNEON
static OCEAN_FORCE_INLINE void convert16PixelsRGB24ToYUV24Precision7BitNEON(const uint8_t *const source, uint8_t *const target)
Converts 16 RGB24 pixels to 16 YUV24 pixels by using NEON instructions.
Definition: FrameConverterRGB24.h:887
Ocean::CV::FrameConverterRGB24::convertRGB24FullRangeToY_V_U12LimitedRange
static void convertRGB24FullRangeToY_V_U12LimitedRange(const uint8_t *source, uint8_t *yTarget, uint8_t *vTarget, uint8_t *uTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vTargetPaddingElements, const unsigned int uTargetPaddingElements, Worker *worker=nullptr)
Converts a full range RGB24 frame to a limited range Y_V_U12 frame with 7-bit precision using BT....
Definition: FrameConverterRGB24.h:774
Ocean::CV::FrameConverterRGB24::convertRGB24ToARGB32
static void convertRGB24ToARGB32(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const uint8_t alphaValue=0xFF, Worker *worker=nullptr)
Converts a RGB 24 bit frame to a ARGB 32 bit frame.
Definition: FrameConverterRGB24.h:399
Ocean::CV::FrameConverterRGB24::convertRGB24ToR_G_B24
static void convertRGB24ToR_G_B24(const uint8_t *source, uint8_t *rTarget, uint8_t *gTarget, uint8_t *bTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int rTargetPaddingElements, const unsigned int gTargetPaddingElements, const unsigned int bTargetPaddingElements, Worker *worker=nullptr)
Converts a RGB 24 bit frame to a R_G_B 24 bit frame.
Definition: FrameConverterRGB24.h:864
Ocean::CV::FrameConverterRGB24::convertRGB24FullRangeToY_U_V12FullRange
static void convertRGB24FullRangeToY_U_V12FullRange(const uint8_t *source, uint8_t *yTarget, uint8_t *uTarget, uint8_t *vTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uTargetPaddingElements, const unsigned int vTargetPaddingElements, Worker *worker=nullptr)
Converts a full range RGB24 frame to a full range Y_U_V12 frame with 7-bit precision using BT....
Definition: FrameConverterRGB24.h:781
Ocean::CV::FrameConverterRGB24::convertRGB24ToBGR24
static void convertRGB24ToBGR24(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr)
Converts a RGB 24 bit frame to a BGR 24 bit frame.
Definition: FrameConverterRGB24.h:407
Ocean::CV::FrameConverterRGB24::convertRGB24FullRangeToY_UV12LimitedRange
static void convertRGB24FullRangeToY_UV12LimitedRange(const uint8_t *source, uint8_t *yTarget, uint8_t *uvTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uvTargetPaddingElements, Worker *worker=nullptr)
Converts a full range RGB24 frame to a limited range Y_UV12 frame with 7-bit precision using BT....
Definition: FrameConverterRGB24.h:533
Ocean::CV::FrameConverterRGB24::convertRGB24FullRangeToY_U_V12LimitedRange
static void convertRGB24FullRangeToY_U_V12LimitedRange(const uint8_t *source, uint8_t *yTarget, uint8_t *uTarget, uint8_t *vTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int uTargetPaddingElements, const unsigned int vTargetPaddingElements, Worker *worker=nullptr)
Converts a full range RGB24 frame to a limited range Y_U_V12 frame with 7-bit precision using BT....
Definition: FrameConverterRGB24.h:725
Ocean::CV::FrameConverterRGB24::changeRGB24ToBGR24Subset
static void changeRGB24ToBGR24Subset(uint8_t *frame, const unsigned int width, const unsigned int firstRow, const unsigned int numberRows)
Changes a subset of RGB 24 bit frame to a BGR 24 bit frame.
Ocean::CV::FrameConverterRGB24::convertRGB24ToBGR32
static void convertRGB24ToBGR32(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker)
Converts a RGB 24 bit frame to a BGR 32 bit frame.
Definition: FrameConverterRGB24.h:430
Ocean::CV::FrameConverterRGB24::convertRGB24ToYUV24
static void convertRGB24ToYUV24(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr)
Converts a RGB 24 bit frame to a YUV 24 bit frame by the exact conversion.
Definition: FrameConverterRGB24.h:503
Ocean::CV::FrameConverterRGB24::convertRGB24FullRangeToY_V_U12FullRange
static void convertRGB24FullRangeToY_V_U12FullRange(const uint8_t *source, uint8_t *yTarget, uint8_t *vTarget, uint8_t *uTarget, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int yTargetPaddingElements, const unsigned int vTargetPaddingElements, const unsigned int uTargetPaddingElements, Worker *worker=nullptr)
Converts a full range RGB24 frame to a full range Y_V_U12 frame with 7-bit precision using BT....
Definition: FrameConverterRGB24.h:830
Ocean::CV::FrameConverterRGB24::convertRGB24ToRGBA32
static void convertRGB24ToRGBA32(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const uint8_t alphaValue=0xFF, Worker *worker=nullptr)
Converts a RGB 24 bit frame to a RGBA 32 bit frame.
Definition: FrameConverterRGB24.h:474
Ocean::CV::FrameConverterRGB24::convertRGB24ToYUV24RowPrecision7BitNEON
static void convertRGB24ToYUV24RowPrecision7BitNEON(const uint8_t *source, uint8_t *target, const size_t size, const void *parameters)
Converts a RGB 24 bit row to a YUV 24 bit row by using NEON instructions.
Ocean::CV::FrameConverterRGB24::convertRGB24ToY8
static void convertRGB24ToY8(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr)
Converts a RGB frame to a gray scale frame.
Definition: FrameConverterRGB24.h:482
Ocean::CV::FrameConverterRGB24::convertRGB24ToRGB32
static void convertRGB24ToRGB32(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr)
Converts a RGB 24 bit frame to a RGB 32 bit frame.
Definition: FrameConverterRGB24.h:466
Ocean::CV::FrameConverterRGB24::changeRGB24ToYUV24
static void changeRGB24ToYUV24(uint8_t *frame, const unsigned int width, const unsigned int height, Worker *worker=nullptr)
Changes a RGB 24 bit frame to a YUV 24 bit frame by the exact conversion in place.
Definition: FrameConverterRGB24.h:837
Ocean::CV::FrameConverterRGB24::convertRGB24ToBGRA32
static void convertRGB24ToBGRA32(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const ConversionFlag flag, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const uint8_t alphaValue=0xFF, Worker *worker=nullptr)
Converts a RGB 24 bit frame to a BGRA 32 bit frame.
Definition: FrameConverterRGB24.h:444
Ocean::CV::FrameConverterRGB24::changeRGB24ToYUV24Subset
static void changeRGB24ToYUV24Subset(uint8_t *frame, const unsigned int width, const unsigned int firstRow, const unsigned int numberRows)
Changes a subset of a RGB 24 bit frame to a YUV 24 bit frame by exact conversion.
Ocean::CV::FrameConverterRGB24::convertRGB24ToYUV24Pixel
static void convertRGB24ToYUV24Pixel(const uint8_t *rgb, uint8_t *yuv)
Converts one RGB 24 bit pixel to one YUV 24 bit pixel.
Definition: FrameConverterRGB24.h:851
Ocean::Caller< void >::createStatic
static Caller< void > createStatic(typename StaticFunctionPointerMaker< void, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass, NullClass >::Type function)
Creates a new caller container for a static function with no function parameter.
Definition: Caller.h:2876
Ocean::Worker
This class implements a worker able to distribute function calls over different threads.
Definition: Worker.h:33
Ocean::Worker::executeFunction
bool executeFunction(const Function &function, const unsigned int first, const unsigned int size, const unsigned int firstIndex=(unsigned int)(-1), const unsigned int sizeIndex=(unsigned int)(-1), const unsigned int minimalIterations=1u, const unsigned int threadIndex=(unsigned int)(-1))
Executes a callback function separable by two function parameters.
Ocean
The namespace covering the entire Ocean framework.
Definition: Accessor.h:15