Ocean
Loading...
Searching...
No Matches
FrameEnlarger.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_ENLARGER_H
9#define META_OCEAN_CV_FRAME_ENLARGER_H
10
11#include "ocean/cv/CV.h"
12#include "ocean/cv/FrameBlender.h"
13
14#include "ocean/base/DataType.h"
15#include "ocean/base/Frame.h"
16#include "ocean/base/Worker.h"
17
18namespace Ocean
19{
20
21namespace CV
22{
23
24/**
25 * This class implements functions to enlarge/up-sample frames.
26 * @ingroup cv
27 */
28class OCEAN_CV_EXPORT FrameEnlarger
29{
30 public:
31
32 /**
33 * The following comfort class provides comfortable functions simplifying prototyping applications but also increasing binary size of the resulting applications.
34 * Best practice is to avoid using these functions if binary size matters,<br>
35 * as for every comfort function a corresponding function exists with specialized functionality not increasing binary size significantly.<br>
36 */
37 class OCEAN_CV_EXPORT Comfort
38 {
39 public:
40
41 /**
42 * Adds a border to the given frame while all new pixels will receive a specified border color.
43 * @param source The source frame to be extended with a border, must be valid
44 * @param target The target frame receiving the extended frame, will be set to the correct pixel format and frame dimension
45 * @param borderSizeLeft The size of the border at the left image boundary, in pixel, with range [0, infinity)
46 * @param borderSizeTop The size of the border at the top image boundary, in pixel, with range [0, infinity)
47 * @param borderSizeRight The size of the border at the right image boundary, in pixel, with range [0, infinity)
48 * @param borderSizeBottom The size of the border at the bottom image boundary, in pixel, with range [0, infinity)
49 * @param color The border color to be used for the new border pixels, one value for each channel, must be valid
50 * @return True, if succeeded
51 */
52 static bool addBorder(const Frame& source, Frame& target, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const void* color);
53
54 /**
55 * Adds a border to the given frame while all new pixels will receive a specified border color.
56 * @param frame The frame to be extended by a border, must be valid
57 * @param borderSizeLeft The size of the border at the left image boundary, in pixel, with range [0, infinity)
58 * @param borderSizeTop The size of the border at the top image boundary, in pixel, with range [0, infinity)
59 * @param borderSizeRight The size of the border at the right image boundary, in pixel, with range [0, infinity)
60 * @param borderSizeBottom The size of the border at the bottom image boundary, in pixel, with range [0, infinity)
61 * @param color The border color to be used for the new border pixels, one value for each channel, must be valid
62 * @return True, if succeeded
63 */
64 static inline bool addBorder(Frame& frame, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const void* color);
65
66 /**
67 * Adds a border to the given frame.
68 * The color of the border pixels are defined by the nearest pixels of the original frame.
69 * @param source The source frame to be extended with a border, must be valid
70 * @param target The target frame receiving the extended frame, will be set to the correct pixel format and frame dimension
71 * @param borderSizeLeft The size of the border at the left image boundary, in pixel, with range [0, infinity)
72 * @param borderSizeTop The size of the border at the top image boundary, in pixel, with range [0, infinity)
73 * @param borderSizeRight The size of the border at the right image boundary, in pixel, with range [0, infinity)
74 * @param borderSizeBottom The size of the border at the bottom image boundary, in pixel, with range [0, infinity)
75 * @return True, if succeeded
76 */
77 static bool addBorderNearestPixel(const Frame& source, Frame& target, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom);
78
79 /**
80 * Adds a border to the given frame.
81 * The color of the border pixels are defined by the nearest pixels of the original frame.
82 * @param frame The frame to be extended by a border, must be valid
83 * @param borderSizeLeft The size of the border at the left image boundary, in pixel, with range [0, infinity)
84 * @param borderSizeTop The size of the border at the top image boundary, in pixel, with range [0, infinity)
85 * @param borderSizeRight The size of the border at the right image boundary, in pixel, with range [0, infinity)
86 * @param borderSizeBottom The size of the border at the bottom image boundary, in pixel, with range [0, infinity)
87 * @return True, if succeeded
88 */
89 static inline bool addBorderNearestPixel(Frame& frame, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom);
90
91 /**
92 * Adds a border to the given frame by mirroring the frame border (and border neighbor) pixels.
93 * @param source The source frame to be extended with a border, must be valid
94 * @param target The target frame receiving the extended frame, will be set to the correct pixel format and frame dimension
95 * @param borderSizeLeft The size of the border at the left image boundary, in pixel, with range [0, frame.width()]
96 * @param borderSizeTop The size of the border at the top image boundary, in pixel, with range [0, frame.height()]
97 * @param borderSizeRight The size of the border at the right image boundary, in pixel, with range [0, frame.width()]
98 * @param borderSizeBottom The size of the border at the bottom image boundary, in pixel, with range [0, frame.height()]
99 * @return True, if succeeded
100 */
101 static bool addBorderMirrored(const Frame& source, Frame& target, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom);
102
103 /**
104 * Adds a border to the given frame by mirroring the frame border (and border neighbor) pixels.
105 * @param frame The frame to be extended by a border, must be valid
106 * @param borderSizeLeft The size of the border at the left image boundary, in pixel, with range [0, frame.width()]
107 * @param borderSizeTop The size of the border at the top image boundary, in pixel, with range [0, frame.height()]
108 * @param borderSizeRight The size of the border at the right image boundary, in pixel, with range [0, frame.width()]
109 * @param borderSizeBottom The size of the border at the bottom image boundary, in pixel, with range [0, frame.height()]
110 * @return True, if succeeded
111 */
112 static inline bool addBorderMirrored(Frame& frame, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom);
113
114 /**
115 * Doubles the size of a given frame by a pixel repeating upsampling.
116 * @param source The source (and untouched) frame to be upsized, must be valid
117 * @param target The target frame receiving the upsized frame, will be set to the correct pixel format and frame dimension
118 * @param worker Optional worker object to distribute the computation
119 * @return True, if succeeded
120 */
121 static bool multiplyByTwo(const Frame& source, Frame& target, Worker* worker = nullptr);
122
123 /**
124 * Adds a transparent border to a given frame.
125 * The color of the transparent border pixels are taken from the nearest image pixel.<br>
126 * @param source The source frame which will be extended with a transparent border
127 * @param target Resulting target frame with transparent border
128 * @param leftBorder Size of the left frame border in pixel, with range [0, infinity)
129 * @param topBorder Size of the top frame border in pixel, with range [0, infinity)
130 * @param rightBorder Size of the right frame border in pixel, with range [0, infinity)
131 * @param bottomBorder Size of the bottom frame border in pixel, with range [0, infinity)
132 * @return True, if succeeded
133 * @tparam tTransparentIs0xFF True, if 0xFF is interpreted as fully transparent
134 */
135 template <bool tTransparentIs0xFF>
136 static bool addTransparentBorder(const Frame& source, Frame& target, const unsigned int leftBorder, const unsigned int topBorder, const unsigned int rightBorder, const unsigned int bottomBorder);
137
138 /**
139 * Adds a transparent border to a given frame.
140 * The color of the transparent border pixels are taken from the nearest image pixel.<br>
141 * @param frame The frame which will be extended with a transparent border
142 * @param leftBorder Size of the left frame border in pixel, with range [0, infinity)
143 * @param topBorder Size of the top frame border in pixel, with range [0, infinity)
144 * @param rightBorder Size of the right frame border in pixel, with range [0, infinity)
145 * @param bottomBorder Size of the bottom frame border in pixel, with range [0, infinity)
146 * @return True, if succeeded
147 * @tparam tTransparentIs0xFF True, if 0xFF is interpreted as fully transparent
148 */
149 template <bool tTransparentIs0xFF>
150 static bool addTransparentBorder(Frame& frame, const unsigned int leftBorder, const unsigned int topBorder, const unsigned int rightBorder, const unsigned int bottomBorder);
151 };
152
153 /**
154 * Adds a transparent border to a given frame.
155 * The color of the transparent border pixels are taken from the nearest image pixel.<br>
156 * @param source The source frame which will be extended with a transparent border
157 * @param target Resulting target frame with transparent border
158 * @param width The width of the source frame in pixel, with range [1, infinity)
159 * @param height The height of the source frame in pixel, with range [1, infinity)
160 * @param leftBorder Size of the left frame border in pixel, with range [1, infinity)
161 * @param topBorder Size of the top frame border in pixel, with range [1, infinity)
162 * @param rightBorder Size of the right frame border in pixel, with range [1, infinity)
163 * @param bottomBorder Size of the bottom frame border in pixel, with range [1, infinity)
164 * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
165 * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
166 * @tparam tChannelsWithAlpha Number of channels in the source frame (including the alpha channel)
167 * @tparam tAlphaAtFront True, if the alpha channel is in the front of the data channels
168 * @tparam tSourceHasAlpha True, if not only the source frame holds an alpha channel but also the target frame, however values in a target alpha channel will be untouched
169 * @tparam tTransparentIs0xFF True, if 0xFF is interpreted as fully transparent
170 */
171 template <unsigned int tChannelsWithAlpha, bool tAlphaAtFront, bool tSourceHasAlpha, bool tTransparentIs0xFF>
172 static void addTransparentBorder8BitPerChannel(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const unsigned int leftBorder, const unsigned int topBorder, const unsigned int rightBorder, const unsigned int bottomBorder, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements);
173
174 /**
175 * Adds a border to a given frame while all new pixels will receive a specified border color/value.
176 * @param source The source image to be extended, must be valid
177 * @param target The target image receiving the extended frame, with resolution (sourceWidth + borderSizeLeft + borderSizeRight)x(sourceHeight + borderSizeTop + borderSizeBottom), must be valid
178 * @param sourceWidth Width of the original source image in pixel, with range [1, infinity)
179 * @param sourceHeight Height of the original source image in pixel, with range [1, infinity)
180 * @param borderSizeLeft The size of the border at the left image boundary, in pixel, with range [0, infinity)
181 * @param borderSizeTop The size of the border at the top image boundary, in pixel, with range [0, infinity)
182 * @param borderSizeRight The size of the border at the right image boundary, in pixel, with range [0, infinity)
183 * @param borderSizeBottom The size of the border at the bottom image boundary, in pixel, with range [0, infinity)
184 * @param color Border color/value to be used for the new border pixels, must be tChannels values
185 * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
186 * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
187 * @tparam T The data type of a pixel channel
188 * @tparam tChannels The number of data channels, with range [1, infinity)
189 */
190 template <typename T, unsigned int tChannels>
191 static void addBorder(const T* source, T* target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const T* color, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements);
192
193 /**
194 * Adds a border to a given frame while the color of the border pixels are defined by the nearest pixels of the original frame.
195 * @param source The source image to be extended, must be valid
196 * @param target The target image receiving the extended frame, with resolution (sourceWidth + borderSizeLeft + borderSizeRight)x(sourceHeight + borderSizeTop + borderSizeBottom), must be valid
197 * @param sourceWidth Width of the original source image in pixel, with range [1, infinity)
198 * @param sourceHeight Height of the original source image in pixel, with range [1, infinity)
199 * @param borderSizeLeft The size of the border at the left image boundary, in pixel, with range [0, infinity)
200 * @param borderSizeTop The size of the border at the top image boundary, in pixel, with range [0, infinity)
201 * @param borderSizeRight The size of the border at the right image boundary, in pixel, with range [0, infinity)
202 * @param borderSizeBottom The size of the border at the bottom image boundary, in pixel, with range [0, infinity)
203 * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
204 * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
205 * @tparam T The data type of a pixel channel
206 * @tparam tChannels The number of data channels, with range [1, infinity)
207 */
208 template <typename T, unsigned int tChannels>
209 static void addBorderNearestPixel(const T* source, T* target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements);
210
211 /**
212 * Adds a border to a given frame by mirroring the frame's content.
213 * @param source The source image to be extended, must be valid
214 * @param target The target image receiving the extended frame, with resolution (sourceWidth + borderSizeLeft + borderSizeRight)x(sourceHeight + borderSizeTop + borderSizeBottom), must be valid
215 * @param sourceWidth Width of the original source image in pixel, with range [1, infinity)
216 * @param sourceHeight Height of the original source image in pixel, with range [1, infinity)
217 * @param borderSizeLeft The size of the border at the left image boundary, in pixel, with range [0, sourceWidth]
218 * @param borderSizeTop The size of the border at the top image boundary, in pixel, with range [0, sourceHeight]
219 * @param borderSizeRight The size of the border at the right image boundary, in pixel, with range [0, sourceWidth]
220 * @param borderSizeBottom The size of the border at the bottom image boundary, in pixel, with range [0, sourceHeight]
221 * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
222 * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
223 * @tparam T The data type of a pixel channel
224 * @tparam tChannels The number of data channels, with range [1, infinity)
225 */
226 template <typename T, unsigned int tChannels>
227 static void addBorderMirrored(const T* source, T* target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements);
228
229 /**
230 * Doubles the size of a given frame by a pixel repeating upsampling.
231 * @param source Buffer of the source frame to be upsampled
232 * @param target Buffer of the target frame receiving the upsampled frame
233 * @param targetWidth Width of the target buffer in pixel, with range [2, infinity) and targetWidth / 2 == sourceWidth
234 * @param targetHeight Height of the target buffer in pixel, with range [2, infinity) and targetHeight / 2 == sourceHeight
235 * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
236 * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
237 * @param worker Optional worker object to distribute the computation
238 * @tparam T The data type of a pixel channel
239 * @tparam tChannels The number of data channels, with range [1, infinity)
240 */
241 template <typename T, unsigned int tChannels>
242 static void multiplyByTwo(const T* source, T* target, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker = nullptr);
243
244 private:
245
246 /**
247 * Doubles a subset of a given frame by a pixel repeating upsampling.
248 * @param source Buffer of the source frame to be upsampled
249 * @param target Buffer of the target frame receiving the upsampled frame
250 * @param targetWidth Width of the target buffer in pixel, with range [2, infinity) and targetWidth / 2 == sourceWidth
251 * @param targetHeight Height of the target buffer in pixel, with range [2, infinity) and targetHeight / 2 == sourceHeight
252 * @param sourcePaddingElements The number of padding elements at the end of each source row, in elements, with range [0, infinity)
253 * @param targetPaddingElements The number of padding elements at the end of each target row, in elements, with range [0, infinity)
254 * @param firstTargetRow First target row to be handled, with range [0, targetHeight)
255 * @param numberTargetRows Number of target rows to be handled, with range [1, targetHeight]
256 * @tparam T The data type of a pixel channel
257 * @tparam tChannels The number of data channels, with range [1, infinity)
258 */
259 template <typename T, unsigned int tChannels>
260 static void multiplyByTwoSubset(const T* source, T* target, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const unsigned int firstTargetRow, const unsigned int numberTargetRows);
261};
262
263inline bool FrameEnlarger::Comfort::addBorder(Frame& frame, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const void* color)
264{
265 ocean_assert(frame.isValid());
266 ocean_assert(color != nullptr);
267
268 Frame tmpFrame;
269 if (!addBorder(frame, tmpFrame, borderSizeLeft, borderSizeTop, borderSizeRight, borderSizeBottom, color))
270 {
271 return false;
272 }
273
274 tmpFrame.setTimestamp(frame.timestamp());
275 tmpFrame.setRelativeTimestamp(frame.relativeTimestamp());
276
277 frame = std::move(tmpFrame);
278 return true;
279}
280
281bool FrameEnlarger::Comfort::addBorderNearestPixel(Frame& frame, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom)
282{
283 ocean_assert(frame.isValid());
284
285 Frame tmpFrame;
286 if (!addBorderNearestPixel(frame, tmpFrame, borderSizeLeft, borderSizeTop, borderSizeRight, borderSizeBottom))
287 {
288 return false;
289 }
290
291 tmpFrame.setTimestamp(frame.timestamp());
292 tmpFrame.setRelativeTimestamp(frame.relativeTimestamp());
293
294 frame = std::move(tmpFrame);
295 return true;
296}
297
298bool FrameEnlarger::Comfort::addBorderMirrored(Frame& frame, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom)
299{
300 ocean_assert(frame.isValid());
301
302 Frame tmpFrame;
303 if (!addBorderMirrored(frame, tmpFrame, borderSizeLeft, borderSizeTop, borderSizeRight, borderSizeBottom))
304 {
305 return false;
306 }
307
308 tmpFrame.setTimestamp(frame.timestamp());
309 tmpFrame.setRelativeTimestamp(frame.relativeTimestamp());
310
311 frame = std::move(tmpFrame);
312 return true;
313}
314
315
316template <typename T, unsigned int tChannels>
317void FrameEnlarger::addBorder(const T* source, T* target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const T* color, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
318{
319 static_assert(tChannels >= 1u, "Invalid channel number!");
320
321 ocean_assert(source != nullptr && target != nullptr);
322 ocean_assert(sourceWidth != 0u && sourceHeight != 0u);
323
324 using PixelType = typename DataType<T, tChannels>::Type;
325 static_assert(sizeof(PixelType) == sizeof(T) * tChannels, "Invalid pixel type!");
326
327 const unsigned int targetWidth = sourceWidth + borderSizeLeft + borderSizeRight;
328
329 const unsigned int sourceStrideElements = sourceWidth * tChannels + sourcePaddingElements;
330 const unsigned int targetStrideElements = targetWidth * tChannels + targetPaddingElements;
331
332 const PixelType borderColorPixel = *((const PixelType*)color);
333
334 if (borderSizeTop != 0u)
335 {
336 // top border rows
337
338 // first row
339 for (unsigned int n = 0u; n < targetWidth; ++n)
340 {
341 ((PixelType*)target)[n] = borderColorPixel;
342 }
343
344 // following top borders
345 for (unsigned int y = 1u; y < borderSizeTop; ++y)
346 {
347 memcpy(target + y * targetStrideElements, target, targetWidth * sizeof(PixelType));
348 }
349 }
350
351 for (unsigned int y = 0u; y < sourceHeight; ++y)
352 {
353 const PixelType* sourcePixel = (const PixelType*)(source + y * sourceStrideElements);
354 PixelType* targetPixel = (PixelType*)(target + (borderSizeTop + y) * targetStrideElements);
355
356 if (borderSizeTop == 0u)
357 {
358 for (unsigned int n = 0u; n < borderSizeLeft; ++n)
359 {
360 targetPixel[n] = borderColorPixel;
361 }
362 }
363 else
364 {
365 // left
366 memcpy(targetPixel, target, borderSizeLeft * sizeof(PixelType));
367 }
368
369 targetPixel += borderSizeLeft;
370
371 // center
372 memcpy(targetPixel, sourcePixel, sourceWidth * sizeof(PixelType));
373
374 targetPixel += sourceWidth;
375 sourcePixel += sourceWidth;
376
377 if (borderSizeTop == 0u)
378 {
379 for (unsigned int n = 0u; n < borderSizeRight; ++n)
380 {
381 targetPixel[n] = borderColorPixel;
382 }
383 }
384 else
385 {
386 // right
387 memcpy(targetPixel, target, borderSizeRight * sizeof(PixelType));
388 }
389 }
390
391 if (borderSizeBottom != 0u)
392 {
393 PixelType* targetPixel = (PixelType*)(target + (borderSizeTop + sourceHeight) * targetStrideElements);
394
395 // first row
396 for (unsigned int n = 0u; n < targetWidth; ++n)
397 {
398 targetPixel[n] = borderColorPixel;
399 }
400
401 // following top borders
402 for (unsigned int y = 1u; y < borderSizeBottom; ++y)
403 {
404 memcpy(target + (borderSizeTop + sourceHeight + y) * targetStrideElements, targetPixel, targetWidth * sizeof(PixelType));
405 }
406 }
407}
408
409template <typename T, unsigned int tChannels>
410void FrameEnlarger::addBorderNearestPixel(const T* source, T* target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
411{
412 static_assert(tChannels >= 1u, "Invalid channel number!");
413
414 ocean_assert(source != nullptr && target != nullptr);
415 ocean_assert(sourceWidth != 0u && sourceHeight != 0u);
416
417 using PixelType = typename DataType<T, tChannels>::Type;
418 static_assert(sizeof(PixelType) == sizeof(T) * tChannels, "Invalid pixel type!");
419
420 const unsigned int targetWidth = sourceWidth + borderSizeLeft + borderSizeRight;
421
422 const unsigned int sourceStrideElements = sourceWidth * tChannels + sourcePaddingElements;
423 const unsigned int targetStrideElements = targetWidth * tChannels + targetPaddingElements;
424
425 const PixelType* sourcePixel = (const PixelType*)source;
426 PixelType* targetPixel = (PixelType*)target;
427
428 if (borderSizeTop != 0u)
429 {
430 // top border rows
431 for (unsigned int x = 0u; x < borderSizeLeft; ++x)
432 {
433 targetPixel[x] = *sourcePixel;
434 }
435
436 targetPixel += borderSizeLeft;
437
438 memcpy(targetPixel, sourcePixel, sourceWidth * sizeof(PixelType));
439 targetPixel += sourceWidth;
440
441 for (unsigned int x = 0u; x < borderSizeRight; ++x)
442 {
443 targetPixel[x] = sourcePixel[sourceWidth - 1u];
444 }
445
446 targetPixel += borderSizeRight;
447
448 // following top borders
449 for (unsigned int y = 1u; y < borderSizeTop; ++y)
450 {
451 memcpy(target + y * targetStrideElements, target, targetWidth * sizeof(PixelType));
452 }
453 }
454
455 // middle rows
456 for (unsigned int y = 0u; y < sourceHeight; ++y)
457 {
458 sourcePixel = (const PixelType*)(source + y * sourceStrideElements);
459 targetPixel = (PixelType*)(target + (borderSizeTop + y) * targetStrideElements);
460
461 // left border columns
462 for (unsigned int x = 0u; x < borderSizeLeft; ++x)
463 {
464 targetPixel[x] = *sourcePixel;
465 }
466
467 targetPixel += borderSizeLeft;
468
469 memcpy(targetPixel, sourcePixel, sourceWidth * sizeof(PixelType));
470
471 targetPixel += sourceWidth;
472 sourcePixel += sourceWidth - 1u;
473
474 // right border columns
475 for (unsigned int x = 0u; x < borderSizeRight; ++x)
476 {
477 targetPixel[x] = *sourcePixel;
478 }
479 }
480
481 if (borderSizeBottom != 0u)
482 {
483 sourcePixel = (const PixelType*)(source + (sourceHeight - 1u) * sourceStrideElements);
484 targetPixel = (PixelType*)(target + (borderSizeTop + sourceHeight) * targetStrideElements);
485
486 // first bottom row
487 for (unsigned int x = 0u; x < borderSizeLeft; ++x)
488 {
489 targetPixel[x] = *sourcePixel;
490 }
491
492 targetPixel += borderSizeLeft;
493
494 memcpy(targetPixel, sourcePixel, sourceWidth * sizeof(PixelType));
495 targetPixel += sourceWidth;
496
497 for (unsigned int x = 0u; x < borderSizeRight; ++x)
498 {
499 targetPixel[x] = sourcePixel[sourceWidth - 1u];
500 }
501
502 // following top borders
503 const unsigned int targetHeight = sourceHeight + borderSizeTop + borderSizeBottom;
504
505 targetPixel = (PixelType*)(target + (targetHeight - borderSizeBottom) * targetStrideElements);
506
507 for (unsigned int y = targetHeight - borderSizeBottom + 1u; y < targetHeight; ++y)
508 {
509 memcpy(target + y * targetStrideElements,targetPixel, targetWidth * sizeof(PixelType));
510 }
511 }
512}
513
514template <typename T, unsigned int tChannels>
515void FrameEnlarger::addBorderMirrored(const T* source, T* target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
516{
517 static_assert(tChannels >= 1u, "Invalid channel number!");
518
519 ocean_assert(source != nullptr && target != nullptr);
520 ocean_assert(sourceWidth != 0u && sourceHeight != 0u);
521 ocean_assert(borderSizeLeft <= sourceWidth && borderSizeRight <= sourceWidth);
522 ocean_assert(borderSizeTop <= sourceHeight && borderSizeBottom <= sourceHeight);
523
524 using PixelType = typename DataType<T, tChannels>::Type;
525 static_assert(sizeof(PixelType) == sizeof(T) * tChannels, "Invalid pixel type!");
526
527 const unsigned int targetWidth = sourceWidth + borderSizeLeft + borderSizeRight;
528
529 const unsigned int sourceStrideElements = sourceWidth * tChannels + sourcePaddingElements;
530 const unsigned int targetStrideElements = targetWidth * tChannels + targetPaddingElements;
531
532 // top rows
533
534 for (unsigned int y = 0u; y < borderSizeTop; ++y)
535 {
536 const PixelType* sourcePixel = (const PixelType*)(source + (borderSizeTop - y - 1u) * sourceStrideElements);
537 PixelType* targetPixel = (PixelType*)(target + y * targetStrideElements);
538
539 // left
540 for (unsigned int n = 0u; n < borderSizeLeft; ++n)
541 {
542 targetPixel[n] = *(sourcePixel + borderSizeLeft - n - 1u);
543 }
544
545 targetPixel += borderSizeLeft;
546
547 // middle
548 memcpy(targetPixel, sourcePixel, sourceWidth * sizeof(PixelType));
549
550 targetPixel += sourceWidth;
551 sourcePixel += sourceWidth;
552
553 // right
554 for (unsigned int n = 0u; n < borderSizeRight; ++n)
555 {
556 targetPixel[n] = *(sourcePixel - n - 1u);
557 }
558 }
559
560 // middle rows
561
562 for (unsigned int y = 0u; y < sourceHeight; ++y)
563 {
564 const PixelType* sourcePixel = (const PixelType*)(source + y * sourceStrideElements);
565 PixelType* targetPixel = (PixelType*)(target + (borderSizeTop + y) * targetStrideElements);
566
567 // left
568 for (unsigned int n = 0u; n < borderSizeLeft; ++n)
569 {
570 targetPixel[n] = *(sourcePixel + borderSizeLeft - n - 1u);
571 }
572
573 targetPixel += borderSizeLeft;
574
575 // middle
576 memcpy(targetPixel, sourcePixel, sourceWidth * sizeof(PixelType));
577
578 targetPixel += sourceWidth;
579 sourcePixel += sourceWidth;
580
581 // right
582 for (unsigned int n = 0u; n < borderSizeRight; ++n)
583 {
584 targetPixel[n] = *(sourcePixel - n - 1u);
585 }
586 }
587
588 for (unsigned int y = 0u; y < borderSizeBottom; ++y)
589 {
590 const PixelType* sourcePixel = (const PixelType*)(source + (sourceHeight - y - 1u) * sourceStrideElements);
591 PixelType* targetPixel = (PixelType*)(target + (borderSizeTop + sourceHeight + y) * targetStrideElements);
592
593 // left
594 for (unsigned int n = 0u; n < borderSizeLeft; ++n)
595 {
596 targetPixel[n] = *(sourcePixel + borderSizeLeft - n - 1u);
597 }
598
599 targetPixel += borderSizeLeft;
600
601 // middle
602 memcpy(targetPixel, sourcePixel, sourceWidth * sizeof(PixelType));
603
604 targetPixel += sourceWidth;
605 sourcePixel += sourceWidth;
606
607 // right
608 for (unsigned int n = 0u; n < borderSizeRight; ++n)
609 {
610 targetPixel[n] = *(sourcePixel - n - 1u);
611 }
612 }
613}
614
615template <bool tTransparentIs0xFF>
616bool FrameEnlarger::Comfort::addTransparentBorder(const Frame& source, Frame& target, const unsigned int leftBorder, const unsigned int topBorder, const unsigned int rightBorder, const unsigned int bottomBorder)
617{
618 ocean_assert(source);
619
620 if (leftBorder == 0u && topBorder == 0u && rightBorder == 0u && bottomBorder == 0u)
621 {
622 target = source;
623 return true;
624 }
625
626 if (source.numberPlanes() == 1u)
627 {
628 FrameType::PixelFormat targetPixelFormat = FrameType::FORMAT_UNDEFINED;
629
630 const bool sourceHasAlpha = FrameType::formatHasAlphaChannel(source.pixelFormat());
631
632 if (sourceHasAlpha)
633 {
634 targetPixelFormat = source.pixelFormat();
635 }
636 else if (FrameType::formatHasAlphaChannel(target.pixelFormat()) && FrameType::formatRemoveAlphaChannel(target.pixelFormat()) == source.pixelFormat())
637 {
638 targetPixelFormat = target.pixelFormat();
639 }
640 else
641 {
642 targetPixelFormat = FrameType::formatAddAlphaChannel(source.pixelFormat());
643 }
644
645 if (!target.set(FrameType(source.width() + leftBorder + rightBorder, source.height() + topBorder + bottomBorder, targetPixelFormat, source.pixelOrigin()), false /*forceOwner*/, true /*forceWritable*/))
646 {
647 ocean_assert(false && "This should never happen!");
648 return false;
649 }
650
651 ocean_assert(target && FrameType::formatHasAlphaChannel(target.pixelFormat()));
652
653 if (!target)
654 {
655 return false;
656 }
657
658 bool alphaAtBack = false;
659 const bool tmpResult = FrameType::formatHasAlphaChannel(target.pixelFormat(), &alphaAtBack);
660 ocean_assert_and_suppress_unused(tmpResult, tmpResult);
661
662 switch (target.channels())
663 {
664 case 2u:
665 {
666 if (alphaAtBack)
667 {
668 if (sourceHasAlpha)
669 {
670 addTransparentBorder8BitPerChannel<2u, false, true, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
671 }
672 else
673 {
674 addTransparentBorder8BitPerChannel<2u, false, false, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
675 }
676 }
677 else
678 {
679 if (sourceHasAlpha)
680 {
681 addTransparentBorder8BitPerChannel<2u, true, true, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
682 }
683 else
684 {
685 addTransparentBorder8BitPerChannel<2u, true, false, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
686 }
687 }
688
689 return true;
690 }
691
692 case 3u:
693 {
694 if (alphaAtBack)
695 {
696 if (sourceHasAlpha)
697 {
698 addTransparentBorder8BitPerChannel<3u, false, true, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
699 }
700 else
701 {
702 addTransparentBorder8BitPerChannel<3u, false, false, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
703 }
704 }
705 else
706 {
707 if (sourceHasAlpha)
708 {
709 addTransparentBorder8BitPerChannel<3u, true, true, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
710 }
711 else
712 {
713 addTransparentBorder8BitPerChannel<3u, true, false, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
714 }
715 }
716
717 return true;
718 }
719
720 case 4u:
721 {
722 if (alphaAtBack)
723 {
724 if (sourceHasAlpha)
725 {
726 addTransparentBorder8BitPerChannel<4u, false, true, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
727 }
728 else
729 {
730 addTransparentBorder8BitPerChannel<4u, false, false, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
731 }
732 }
733 else
734 {
735 if (sourceHasAlpha)
736 {
737 addTransparentBorder8BitPerChannel<4u, true, true, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
738 }
739 else
740 {
741 addTransparentBorder8BitPerChannel<4u, true, false, tTransparentIs0xFF>(source.constdata<uint8_t>(), target.data<uint8_t>(), source.width(), source.height(), leftBorder, topBorder, rightBorder, bottomBorder, source.paddingElements(), target.paddingElements());
742 }
743 }
744
745 return true;
746 }
747
748 default:
749 ocean_assert(false && "Missing implementation");
750 break;
751 }
752 }
753
754 return false;
755}
756
757template <bool tTransparentIs0xFF>
758bool FrameEnlarger::Comfort::addTransparentBorder(Frame& frame, const unsigned int leftBorder, const unsigned int topBorder, const unsigned int rightBorder, const unsigned int bottomBorder)
759{
760 ocean_assert(frame.isValid());
761
762 Frame tmpFrame;
763 if (!addTransparentBorder<tTransparentIs0xFF>(frame, tmpFrame, leftBorder, topBorder, rightBorder, bottomBorder))
764 {
765 return false;
766 }
767
768 tmpFrame.setTimestamp(frame.timestamp());
769 tmpFrame.setRelativeTimestamp(frame.relativeTimestamp());
770
771 frame = std::move(tmpFrame);
772 return true;
773}
774
775template <unsigned int tChannelsWithAlpha, bool tAlphaAtFront, bool tSourceHasAlpha, bool tTransparentIs0xFF>
776void FrameEnlarger::addTransparentBorder8BitPerChannel(const uint8_t* source, uint8_t* target, const unsigned int width, const unsigned int height, const unsigned int leftBorder, const unsigned int topBorder, const unsigned int rightBorder, const unsigned int bottomBorder, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
777{
778 ocean_assert(source && target);
779
780 using TypeWithoutAlpha = typename DataType<uint8_t, tChannelsWithAlpha - 1u>::Type;
781
782 const unsigned int targetWidthElements = (width + leftBorder + rightBorder) * tChannelsWithAlpha;
783 const unsigned int targetStrideElements = targetWidthElements + targetPaddingElements;
784
785 if (topBorder != 0u)
786 {
787 // first row, left block: use the color values of the top left pixel of the source frame
788 for (unsigned int x = 0u; x < leftBorder; ++x)
789 {
790 *(TypeWithoutAlpha*)(target + x * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::data()) =
791 *(TypeWithoutAlpha*)(source + FrameBlender::SourceOffset<tAlphaAtFront>::template data<tSourceHasAlpha>());
792
793 *(target + x * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::template alpha<tChannelsWithAlpha>()) = FrameBlender::fullTransparent8Bit<tTransparentIs0xFF>();
794 }
795
796 // first row, center block: use the color values of the top row of the source frame
797 for (unsigned int x = 0u; x < width; ++x)
798 {
799 *(TypeWithoutAlpha*)(target + (x + leftBorder) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::data()) =
800 *(TypeWithoutAlpha*)(source + x * FrameBlender::FrameChannels<tSourceHasAlpha>::template channels<tChannelsWithAlpha>() + FrameBlender::SourceOffset<tAlphaAtFront>::template data<tSourceHasAlpha>());
801
802 *(target + (x + leftBorder) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::template alpha<tChannelsWithAlpha>()) = FrameBlender::fullTransparent8Bit<tTransparentIs0xFF>();
803 }
804
805 // first row, right block: use the color values of the top right pixel of the source frame
806 for (unsigned int x = 0u; x < rightBorder; ++x)
807 {
808 *(TypeWithoutAlpha*)(target + (x + leftBorder + width) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::data()) =
809 *(TypeWithoutAlpha*)(source + (width - 1u) * FrameBlender::FrameChannels<tSourceHasAlpha>::template channels<tChannelsWithAlpha>() + FrameBlender::SourceOffset<tAlphaAtFront>::template data<tSourceHasAlpha>());
810
811 *(target + (x + leftBorder + width) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::template alpha<tChannelsWithAlpha>()) = FrameBlender::fullTransparent8Bit<tTransparentIs0xFF>();
812 }
813
814 // the remaining rows of the top border are copies of the first row
815 for (unsigned int y = 1u; y < topBorder; ++y)
816 {
817 memcpy(target + y * targetStrideElements, target, targetWidthElements);
818 }
819
820 // next row
821 target += topBorder * targetStrideElements;
822 }
823
824
825 for (unsigned int y = 0u; y < height; ++y)
826 {
827 // left border
828 for (unsigned int x = 0u; x < leftBorder; ++x)
829 {
830 *(TypeWithoutAlpha*)(target + x * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::data()) =
831 *(TypeWithoutAlpha*)(source + FrameBlender::SourceOffset<tAlphaAtFront>::template data<tSourceHasAlpha>());
832
833 *(target + x * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::template alpha<tChannelsWithAlpha>()) = FrameBlender::fullTransparent8Bit<tTransparentIs0xFF>();
834 }
835
836 // center block
837 if constexpr (tSourceHasAlpha)
838 {
839 memcpy(target + leftBorder * tChannelsWithAlpha, source, width * tChannelsWithAlpha);
840 }
841 else
842 {
843 for (unsigned int x = 0u; x < width; ++x)
844 {
845 *(TypeWithoutAlpha*)(target + (x + leftBorder) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::data()) =
846 *(TypeWithoutAlpha*)(source + x * FrameBlender::FrameChannels<tSourceHasAlpha>::template channels<tChannelsWithAlpha>() + FrameBlender::SourceOffset<tAlphaAtFront>::template data<tSourceHasAlpha>());
847
848 *(target + (x + leftBorder) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::template alpha<tChannelsWithAlpha>()) = FrameBlender::fullOpaque8Bit<tTransparentIs0xFF>();
849 }
850 }
851
852 // right border
853 for (unsigned int x = 0u; x < rightBorder; ++x)
854 {
855 *(TypeWithoutAlpha*)(target + (x + leftBorder + width) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::data()) =
856 *(TypeWithoutAlpha*)(source + (width - 1u) * FrameBlender::FrameChannels<tSourceHasAlpha>::template channels<tChannelsWithAlpha>() + FrameBlender::SourceOffset<tAlphaAtFront>::template data<tSourceHasAlpha>());
857
858 *(target + (x + leftBorder + width) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::template alpha<tChannelsWithAlpha>()) = FrameBlender::fullTransparent8Bit<tTransparentIs0xFF>();
859 }
860
861 // next row
862 source += FrameBlender::FrameChannels<tSourceHasAlpha>::template channels<tChannelsWithAlpha>() * width + sourcePaddingElements;
863 target += targetStrideElements;
864 }
865
866 if (bottomBorder != 0u)
867 {
868 // we need the last row of the source frame
869 source -= FrameBlender::FrameChannels<tSourceHasAlpha>::template channels<tChannelsWithAlpha>() * width + sourcePaddingElements;
870
871 // first row of bottom border, left block: use the color values of the bottom left pixel of the source frame
872 for (unsigned int x = 0u; x < leftBorder; ++x)
873 {
874 *(TypeWithoutAlpha*)(target + x * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::data()) =
875 *(TypeWithoutAlpha*)(source + FrameBlender::SourceOffset<tAlphaAtFront>::template data<tSourceHasAlpha>());
876
877 *(target + x * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::template alpha<tChannelsWithAlpha>()) = FrameBlender::fullTransparent8Bit<tTransparentIs0xFF>();
878 }
879
880 // first row of the bottom border, center block: use the color values of the top row of the source frame
881 for (unsigned int x = 0u; x < width; ++x)
882 {
883 *(TypeWithoutAlpha*)(target + (x + leftBorder) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::data()) =
884 *(TypeWithoutAlpha*)(source + x * FrameBlender::FrameChannels<tSourceHasAlpha>::template channels<tChannelsWithAlpha>() + FrameBlender::SourceOffset<tAlphaAtFront>::template data<tSourceHasAlpha>());
885
886 *(target + (x + leftBorder) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::template alpha<tChannelsWithAlpha>()) = FrameBlender::fullTransparent8Bit<tTransparentIs0xFF>();
887 }
888
889 // first row of the bottom border, right block: use the color values of the top right pixel of the source frame
890 for (unsigned int x = 0u; x < rightBorder; ++x)
891 {
892 *(TypeWithoutAlpha*)(target + (x + leftBorder + width) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::data()) =
893 *(TypeWithoutAlpha*)(source + (width - 1u) * FrameBlender::FrameChannels<tSourceHasAlpha>::template channels<tChannelsWithAlpha>() + FrameBlender::SourceOffset<tAlphaAtFront>::template data<tSourceHasAlpha>());
894
895 *(target + (x + leftBorder + width) * tChannelsWithAlpha + FrameBlender::SourceOffset<tAlphaAtFront>::template alpha<tChannelsWithAlpha>()) = FrameBlender::fullTransparent8Bit<tTransparentIs0xFF>();
896 }
897
898 // the remaining rows of the bottom border are copies of the first row
899 for (unsigned int y = 1u; y < bottomBorder; ++y)
900 {
901 memcpy(target + y * targetStrideElements, target, targetWidthElements);
902 }
903 }
904}
905
906template <typename T, unsigned int tChannels>
907void FrameEnlarger::multiplyByTwo(const T* source, T* target, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker* worker)
908{
909 ocean_assert(targetWidth >= 2u && targetHeight >= 2u);
910
911 if (worker)
912 {
913 worker->executeFunction(Worker::Function::createStatic(&FrameEnlarger::multiplyByTwoSubset<T, tChannels>, source, target, targetWidth, targetHeight, sourcePaddingElements, targetPaddingElements, 0u, 0u), 0u, targetHeight);
914 }
915 else
916 {
917 multiplyByTwoSubset<T, tChannels>(source, target, targetWidth, targetHeight, sourcePaddingElements, targetPaddingElements, 0u, targetHeight);
918 }
919}
920
921template <typename T, unsigned int tChannels>
922void FrameEnlarger::multiplyByTwoSubset(const T* source, T* target, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const unsigned int firstTargetRow, const unsigned int numberTargetRows)
923{
924 ocean_assert(targetWidth >= 2u && targetHeight >= 2u);
925
926 ocean_assert(source && target);
927 ocean_assert(firstTargetRow + numberTargetRows <= targetHeight);
928
929 const unsigned int sourceWidth = targetWidth / 2u;
930 const unsigned int sourceHeight = targetHeight / 2u;
931 ocean_assert(sourceWidth >= 1u && sourceHeight >= 1u);
932
933 const unsigned int sourceStrideElements = sourceWidth * tChannels + sourcePaddingElements;
934 const unsigned int targetStrideElements = targetWidth * tChannels + targetPaddingElements;
935
936 using PixelType = typename DataType<T, tChannels>::Type;
937
938 // check whether no extra right column handling is necessary
939 if (targetWidth % 2u == 0u)
940 {
941 for (unsigned int targetRowIndex = firstTargetRow; targetRowIndex < (firstTargetRow + numberTargetRows); ++targetRowIndex)
942 {
943 const PixelType* sourcePixel = (const PixelType*)(source + min(targetRowIndex / 2u, sourceHeight - 1u) * sourceStrideElements);
944
945 PixelType* targetPixel = (PixelType*)(target + targetRowIndex * targetStrideElements);
946
947 const PixelType* const targetRowEnd = targetPixel + targetWidth;
948
949 while (targetPixel != targetRowEnd)
950 {
951 ocean_assert(targetPixel < targetRowEnd);
952
953 *targetPixel++ = *sourcePixel;
954
955 ocean_assert(targetPixel < targetRowEnd);
956
957 *targetPixel++ = *sourcePixel++;
958 }
959 }
960 }
961 else
962 {
963 ocean_assert((targetWidth - 1u) % 2u == 0u);
964
965 for (unsigned int targetRowIndex = firstTargetRow; targetRowIndex < (firstTargetRow + numberTargetRows); ++targetRowIndex)
966 {
967 const PixelType* sourcePixel = (const PixelType*)(source + min(targetRowIndex / 2u, sourceHeight - 1u) * sourceStrideElements);
968 --sourcePixel;
969
970 PixelType* targetPixel = (PixelType*)(target + targetRowIndex * targetStrideElements);
971
972 const PixelType* const targetRowEnd = targetPixel + targetWidth - 1u;
973
974 while (targetPixel != targetRowEnd)
975 {
976 ocean_assert(targetPixel < targetRowEnd);
977
978 *targetPixel++ = *++sourcePixel;
979
980 ocean_assert(targetPixel < targetRowEnd);
981
982 *targetPixel++ = *sourcePixel;
983 }
984
985 // special handling for the last column
986 *targetPixel++ = *sourcePixel;
987 }
988 }
989}
990
991}
992
993}
994
995#endif // META_OCEAN_CV_FRAME_ENLARGER_H
Ocean::CV::FrameBlender::FrameChannels
Helper class allowing to determine the number of channels of a frame.
Definition FrameBlender.h:117
Ocean::CV::FrameBlender::SourceOffset
Helper class allowing to determine the offset that is necessary to access the alpha channel.
Definition FrameBlender.h:60
Ocean::CV::FrameBlender::SourceOffset::data
static constexpr unsigned int data()
Returns the offset that is applied to access the first data channel.
Definition FrameBlender.h:1171
Ocean::CV::FrameEnlarger::Comfort
The following comfort class provides comfortable functions simplifying prototyping applications but a...
Definition FrameEnlarger.h:38
Ocean::CV::FrameEnlarger::Comfort::addBorder
static bool addBorder(const Frame &source, Frame &target, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const void *color)
Adds a border to the given frame while all new pixels will receive a specified border color.
Ocean::CV::FrameEnlarger::Comfort::addTransparentBorder
static bool addTransparentBorder(const Frame &source, Frame &target, const unsigned int leftBorder, const unsigned int topBorder, const unsigned int rightBorder, const unsigned int bottomBorder)
Adds a transparent border to a given frame.
Definition FrameEnlarger.h:616
Ocean::CV::FrameEnlarger::Comfort::multiplyByTwo
static bool multiplyByTwo(const Frame &source, Frame &target, Worker *worker=nullptr)
Doubles the size of a given frame by a pixel repeating upsampling.
Ocean::CV::FrameEnlarger::Comfort::addBorderMirrored
static bool addBorderMirrored(const Frame &source, Frame &target, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom)
Adds a border to the given frame by mirroring the frame border (and border neighbor) pixels.
Ocean::CV::FrameEnlarger::Comfort::addBorderNearestPixel
static bool addBorderNearestPixel(const Frame &source, Frame &target, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom)
Adds a border to the given frame.
Ocean::CV::FrameEnlarger
This class implements functions to enlarge/up-sample frames.
Definition FrameEnlarger.h:29
Ocean::CV::FrameEnlarger::addTransparentBorder8BitPerChannel
static void addTransparentBorder8BitPerChannel(const uint8_t *source, uint8_t *target, const unsigned int width, const unsigned int height, const unsigned int leftBorder, const unsigned int topBorder, const unsigned int rightBorder, const unsigned int bottomBorder, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
Adds a transparent border to a given frame.
Definition FrameEnlarger.h:776
Ocean::CV::FrameEnlarger::multiplyByTwoSubset
static void multiplyByTwoSubset(const T *source, T *target, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, const unsigned int firstTargetRow, const unsigned int numberTargetRows)
Doubles a subset of a given frame by a pixel repeating upsampling.
Definition FrameEnlarger.h:922
Ocean::CV::FrameEnlarger::addBorderMirrored
static void addBorderMirrored(const T *source, T *target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
Adds a border to a given frame by mirroring the frame's content.
Definition FrameEnlarger.h:515
Ocean::CV::FrameEnlarger::addBorder
static void addBorder(const T *source, T *target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const T *color, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
Adds a border to a given frame while all new pixels will receive a specified border color/value.
Definition FrameEnlarger.h:317
Ocean::CV::FrameEnlarger::addBorderNearestPixel
static void addBorderNearestPixel(const T *source, T *target, const unsigned int sourceWidth, const unsigned int sourceHeight, const unsigned int borderSizeLeft, const unsigned int borderSizeTop, const unsigned int borderSizeRight, const unsigned int borderSizeBottom, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements)
Adds a border to a given frame while the color of the border pixels are defined by the nearest pixels...
Definition FrameEnlarger.h:410
Ocean::CV::FrameEnlarger::multiplyByTwo
static void multiplyByTwo(const T *source, T *target, const unsigned int targetWidth, const unsigned int targetHeight, const unsigned int sourcePaddingElements, const unsigned int targetPaddingElements, Worker *worker=nullptr)
Doubles the size of a given frame by a pixel repeating upsampling.
Definition FrameEnlarger.h:907
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:2877
Ocean::DataType
Template class allowing to define an array of data types.
Definition DataType.h:27
Ocean::Frame
This class implements Ocean's image class.
Definition Frame.h:1969
Ocean::Frame::constdata
const T * constdata(const unsigned int planeIndex=0u) const
Returns a pointer to the read-only pixel data of a specific plane.
Definition Frame.h:4425
Ocean::Frame::setRelativeTimestamp
void setRelativeTimestamp(const Timestamp &relative)
Sets the relative timestamp of this frame.
Definition Frame.h:4410
Ocean::Frame::data
T * data(const unsigned int planeIndex=0u)
Returns a pointer to the pixel data of a specific plane.
Definition Frame.h:4416
Ocean::Frame::isValid
bool isValid() const
Returns whether this frame is valid.
Definition Frame.h:4705
Ocean::Frame::setTimestamp
void setTimestamp(const Timestamp &timestamp)
Sets the timestamp of this frame.
Definition Frame.h:4405
Ocean::Frame::set
bool set(const FrameType &frameType, const bool forceOwner, const bool forceWritable=false, const Indices32 &planePaddingElements=Indices32(), const Timestamp &timestamp=Timestamp(false), bool *reallocated=nullptr)
Sets a new frame type for this frame.
Ocean::Frame::timestamp
const Timestamp & timestamp() const
Returns the timestamp of this frame.
Definition Frame.h:4395
Ocean::Frame::relativeTimestamp
const Timestamp & relativeTimestamp() const
Returns the relative timestamp of this frame.
Definition Frame.h:4400
Ocean::Frame::paddingElements
unsigned int paddingElements(const unsigned int planeIndex=0u) const
Returns the optional number of padding elements at the end of each row for a specific plane.
Definition Frame.h:4299
Ocean::FrameType
Definition of a frame type composed by the frame dimension, pixel format and pixel origin.
Definition Frame.h:30
Ocean::FrameType::PixelFormat
PixelFormat
Definition of all pixel formats available in the Ocean framework.
Definition Frame.h:183
Ocean::FrameType::FORMAT_UNDEFINED
@ FORMAT_UNDEFINED
Undefined pixel format.
Definition Frame.h:187
Ocean::FrameType::width
unsigned int width() const
Returns the width of the frame format in pixel.
Definition Frame.h:3334
Ocean::FrameType::pixelOrigin
PixelOrigin pixelOrigin() const
Returns the pixel origin of the frame.
Definition Frame.h:3379
Ocean::FrameType::numberPlanes
uint32_t numberPlanes() const
Returns the number of planes of the pixel format of this frame.
Definition Frame.h:3374
Ocean::FrameType::formatRemoveAlphaChannel
static PixelFormat formatRemoveAlphaChannel(const PixelFormat pixelFormat)
Removes an alpha channel from a given pixel format.
Ocean::FrameType::formatHasAlphaChannel
static bool formatHasAlphaChannel(const PixelFormat pixelFormat, bool *isLastChannel=nullptr)
Returns whether a given pixel format holds an alpha channel.
Ocean::FrameType::pixelFormat
PixelFormat pixelFormat() const
Returns the pixel format of the frame.
Definition Frame.h:3344
Ocean::FrameType::height
unsigned int height() const
Returns the height of the frame in pixel.
Definition Frame.h:3339
Ocean::FrameType::channels
unsigned int channels() const
Returns the number of individual channels the frame has.
Definition Frame.h:3364
Ocean::FrameType::formatAddAlphaChannel
static PixelFormat formatAddAlphaChannel(const PixelFormat pixelFormat, const bool lastChannel=true)
Adds an alpha channel to a given pixel format.
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
Ocean::DataType::Type
Default definition of a type with tBytes bytes.
Definition DataType.h:32