1 | /*****************************************************************************/ |
2 | // Copyright 2006-2008 Adobe Systems Incorporated |
3 | // All Rights Reserved. |
4 | // |
5 | // NOTICE: Adobe permits you to use, modify, and distribute this file in |
6 | // accordance with the terms of the Adobe license agreement accompanying it. |
7 | /*****************************************************************************/ |
8 | |
9 | /* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_pixel_buffer.h#1 $ */ |
10 | /* $DateTime: 2012/05/30 13:28:51 $ */ |
11 | /* $Change: 832332 $ */ |
12 | /* $Author: tknoll $ */ |
13 | |
14 | /** \file |
15 | * Support for holding buffers of sample data. |
16 | */ |
17 | |
18 | /*****************************************************************************/ |
19 | |
20 | #ifndef __dng_pixel_buffer__ |
21 | #define __dng_pixel_buffer__ |
22 | |
23 | /*****************************************************************************/ |
24 | |
25 | #include "dng_assertions.h" |
26 | #include "dng_rect.h" |
27 | #include "dng_safe_arithmetic.h" |
28 | #include "dng_tag_types.h" |
29 | |
30 | /*****************************************************************************/ |
31 | |
32 | /// Compute best set of step values for a given source and destination area and stride. |
33 | |
34 | void OptimizeOrder (const void *&sPtr, |
35 | void *&dPtr, |
36 | uint32 sPixelSize, |
37 | uint32 dPixelSize, |
38 | uint32 &count0, |
39 | uint32 &count1, |
40 | uint32 &count2, |
41 | int32 &sStep0, |
42 | int32 &sStep1, |
43 | int32 &sStep2, |
44 | int32 &dStep0, |
45 | int32 &dStep1, |
46 | int32 &dStep2); |
47 | |
48 | void OptimizeOrder (const void *&sPtr, |
49 | uint32 sPixelSize, |
50 | uint32 &count0, |
51 | uint32 &count1, |
52 | uint32 &count2, |
53 | int32 &sStep0, |
54 | int32 &sStep1, |
55 | int32 &sStep2); |
56 | |
57 | void OptimizeOrder (void *&dPtr, |
58 | uint32 dPixelSize, |
59 | uint32 &count0, |
60 | uint32 &count1, |
61 | uint32 &count2, |
62 | int32 &dStep0, |
63 | int32 &dStep1, |
64 | int32 &dStep2); |
65 | |
66 | /*****************************************************************************/ |
67 | |
68 | #define qDebugPixelType 0 |
69 | |
70 | #if qDebugPixelType |
71 | |
72 | #define ASSERT_PIXEL_TYPE(typeVal) CheckPixelType (typeVal) |
73 | |
74 | #else |
75 | |
76 | #define ASSERT_PIXEL_TYPE(typeVal) DNG_ASSERT (fPixelType == typeVal, "Pixel type access mismatch") |
77 | |
78 | #endif |
79 | |
80 | /*****************************************************************************/ |
81 | |
82 | /// \brief Holds a buffer of pixel data with "pixel geometry" metadata. |
83 | /// |
84 | /// The pixel geometry describes the layout in terms of how many planes, rows and columns |
85 | /// plus the steps (in bytes) between each column, row and plane. |
86 | |
87 | class dng_pixel_buffer |
88 | { |
89 | |
90 | public: |
91 | |
92 | // Area this buffer holds. |
93 | |
94 | dng_rect fArea; |
95 | |
96 | // Range of planes this buffer holds. |
97 | |
98 | uint32 fPlane; |
99 | uint32 fPlanes; |
100 | |
101 | // Steps between pixels. |
102 | |
103 | int32 fRowStep; |
104 | int32 fColStep; |
105 | int32 fPlaneStep; |
106 | |
107 | // Basic pixel type (TIFF tag type code). |
108 | |
109 | uint32 fPixelType; |
110 | |
111 | // Size of pixel type in bytes. |
112 | |
113 | uint32 fPixelSize; |
114 | |
115 | // Pointer to buffer's data. |
116 | |
117 | void *fData; |
118 | |
119 | // Do we have write-access to this data? |
120 | |
121 | bool fDirty; |
122 | |
123 | private: |
124 | |
125 | void * InternalPixel (int32 row, |
126 | int32 col, |
127 | uint32 plane = 0) const |
128 | { |
129 | |
130 | // Ensure pixel to be accessed lies inside valid area. |
131 | if (row < fArea.t || row >= fArea.b || |
132 | col < fArea.l || col >= fArea.r || |
133 | plane < fPlane || (plane - fPlane) >= fPlanes) |
134 | { |
135 | ThrowProgramError ("Out-of-range pixel access" ); |
136 | } |
137 | |
138 | // Compute offset of pixel. |
139 | const int64 rowOffset = SafeInt64Mult(fRowStep, |
140 | static_cast<int64> (row) - static_cast<int64> (fArea.t)); |
141 | const int64 colOffset = SafeInt64Mult(fColStep, |
142 | static_cast<int64> (col) - static_cast<int64> (fArea.l)); |
143 | const int64 planeOffset = SafeInt64Mult(fPlaneStep, |
144 | static_cast<int64> (plane - fPlane)); |
145 | const int64 offset = SafeInt64Mult(static_cast<int64>(fPixelSize), |
146 | SafeInt64Add(SafeInt64Add(rowOffset, colOffset), planeOffset)); |
147 | |
148 | // Add offset to buffer base address. |
149 | return static_cast<void *> (static_cast<uint8 *> (fData) + offset); |
150 | |
151 | } |
152 | |
153 | #if qDebugPixelType |
154 | |
155 | void CheckPixelType (uint32 pixelType) const; |
156 | |
157 | #endif |
158 | |
159 | public: |
160 | |
161 | dng_pixel_buffer (); |
162 | |
163 | /// Note: This constructor is for internal use only and should not be |
164 | /// considered part of the DNG SDK API. |
165 | /// |
166 | /// Initialize the pixel buffer according to the given parameters (see |
167 | /// below). May throw an error if arithmetic overflow occurs when |
168 | /// computing the row, column or plane step, or if an invalid value was |
169 | /// passed for planarConfiguration. |
170 | /// |
171 | /// \param size Area covered by the pixel buffer |
172 | /// \param plane Index of the first plane |
173 | /// \param planes Number of planes |
174 | /// \param pixelType Pixel data type (one of the values defined in |
175 | /// dng_tag_types.h) |
176 | /// \param planarConfiguration Layout of the pixel planes in memory: One |
177 | /// of pcInterleaved, pcPlanar, or pcRowInterleaved (defined in |
178 | /// dng_tag_values.h) |
179 | /// \param data Pointer to the pixel data |
180 | dng_pixel_buffer (const dng_rect &area, uint32 plane, uint32 planes, |
181 | uint32 pixelType, uint32 planarConfiguration, |
182 | void *data); |
183 | |
184 | dng_pixel_buffer (const dng_pixel_buffer &buffer); |
185 | |
186 | dng_pixel_buffer & operator= (const dng_pixel_buffer &buffer); |
187 | |
188 | virtual ~dng_pixel_buffer (); |
189 | |
190 | /// Get the range of pixel values. |
191 | /// \retval Range of value a pixel can take. (Meaning [0, max] for unsigned case. Signed case is biased so [-32768, max - 32768].) |
192 | |
193 | uint32 PixelRange () const; |
194 | |
195 | /// Get extent of pixels in buffer |
196 | /// \retval Rectangle giving valid extent of buffer. |
197 | |
198 | const dng_rect & Area () const |
199 | { |
200 | return fArea; |
201 | } |
202 | |
203 | /// Number of planes of image data. |
204 | /// \retval Number of planes held in buffer. |
205 | |
206 | uint32 Planes () const |
207 | { |
208 | return fPlanes; |
209 | } |
210 | |
211 | /// Step, in pixels not bytes, between rows of data in buffer. |
212 | /// \retval row step in pixels. May be negative. |
213 | |
214 | int32 RowStep () const |
215 | { |
216 | return fRowStep; |
217 | } |
218 | |
219 | /// Step, in pixels not bytes, between planes of data in buffer. |
220 | /// \retval plane step in pixels. May be negative. |
221 | |
222 | int32 PlaneStep () const |
223 | { |
224 | return fPlaneStep; |
225 | } |
226 | |
227 | /// Get read-only untyped (void *) pointer to pixel data starting at a specific pixel in the buffer. |
228 | /// \param row Start row for buffer pointer. |
229 | /// \param col Start column for buffer pointer. |
230 | /// \param plane Start plane for buffer pointer. |
231 | /// \retval Pointer to pixel data as void *. |
232 | |
233 | const void * ConstPixel (int32 row, |
234 | int32 col, |
235 | uint32 plane = 0) const |
236 | { |
237 | |
238 | return InternalPixel (row, col, plane); |
239 | |
240 | } |
241 | |
242 | /// Get a writable untyped (void *) pointer to pixel data starting at a specific pixel in the buffer. |
243 | /// \param row Start row for buffer pointer. |
244 | /// \param col Start column for buffer pointer. |
245 | /// \param plane Start plane for buffer pointer. |
246 | /// \retval Pointer to pixel data as void *. |
247 | |
248 | void * DirtyPixel (int32 row, |
249 | int32 col, |
250 | uint32 plane = 0) |
251 | { |
252 | |
253 | DNG_ASSERT (fDirty, "Dirty access to const pixel buffer" ); |
254 | |
255 | return InternalPixel (row, col, plane); |
256 | |
257 | } |
258 | |
259 | /// Get read-only uint8 * to pixel data starting at a specific pixel in the buffer. |
260 | /// \param row Start row for buffer pointer. |
261 | /// \param col Start column for buffer pointer. |
262 | /// \param plane Start plane for buffer pointer. |
263 | /// \retval Pointer to pixel data as uint8 *. |
264 | |
265 | const uint8 * ConstPixel_uint8 (int32 row, |
266 | int32 col, |
267 | uint32 plane = 0) const |
268 | { |
269 | |
270 | ASSERT_PIXEL_TYPE (ttByte); |
271 | |
272 | return (const uint8 *) ConstPixel (row, col, plane); |
273 | |
274 | } |
275 | |
276 | /// Get a writable uint8 * to pixel data starting at a specific pixel in the buffer. |
277 | /// \param row Start row for buffer pointer. |
278 | /// \param col Start column for buffer pointer. |
279 | /// \param plane Start plane for buffer pointer. |
280 | /// \retval Pointer to pixel data as uint8 *. |
281 | |
282 | uint8 * DirtyPixel_uint8 (int32 row, |
283 | int32 col, |
284 | uint32 plane = 0) |
285 | { |
286 | |
287 | ASSERT_PIXEL_TYPE (ttByte); |
288 | |
289 | return (uint8 *) DirtyPixel (row, col, plane); |
290 | |
291 | } |
292 | |
293 | /// Get read-only int8 * to pixel data starting at a specific pixel in the buffer. |
294 | /// \param row Start row for buffer pointer. |
295 | /// \param col Start column for buffer pointer. |
296 | /// \param plane Start plane for buffer pointer. |
297 | /// \retval Pointer to pixel data as int8 *. |
298 | |
299 | const int8 * ConstPixel_int8 (int32 row, |
300 | int32 col, |
301 | uint32 plane = 0) const |
302 | { |
303 | |
304 | ASSERT_PIXEL_TYPE (ttSByte); |
305 | |
306 | return (const int8 *) ConstPixel (row, col, plane); |
307 | |
308 | } |
309 | |
310 | /// Get a writable int8 * to pixel data starting at a specific pixel in the buffer. |
311 | /// \param row Start row for buffer pointer. |
312 | /// \param col Start column for buffer pointer. |
313 | /// \param plane Start plane for buffer pointer. |
314 | /// \retval Pointer to pixel data as int8 *. |
315 | |
316 | int8 * DirtyPixel_int8 (int32 row, |
317 | int32 col, |
318 | uint32 plane = 0) |
319 | { |
320 | |
321 | ASSERT_PIXEL_TYPE (ttSByte); |
322 | |
323 | return (int8 *) DirtyPixel (row, col, plane); |
324 | |
325 | } |
326 | |
327 | /// Get read-only uint16 * to pixel data starting at a specific pixel in the buffer. |
328 | /// \param row Start row for buffer pointer. |
329 | /// \param col Start column for buffer pointer. |
330 | /// \param plane Start plane for buffer pointer. |
331 | /// \retval Pointer to pixel data as uint16 *. |
332 | |
333 | const uint16 * ConstPixel_uint16 (int32 row, |
334 | int32 col, |
335 | uint32 plane = 0) const |
336 | { |
337 | |
338 | ASSERT_PIXEL_TYPE (ttShort); |
339 | |
340 | return (const uint16 *) ConstPixel (row, col, plane); |
341 | |
342 | } |
343 | |
344 | /// Get a writable uint16 * to pixel data starting at a specific pixel in the buffer. |
345 | /// \param row Start row for buffer pointer. |
346 | /// \param col Start column for buffer pointer. |
347 | /// \param plane Start plane for buffer pointer. |
348 | /// \retval Pointer to pixel data as uint16 *. |
349 | |
350 | uint16 * DirtyPixel_uint16 (int32 row, |
351 | int32 col, |
352 | uint32 plane = 0) |
353 | { |
354 | |
355 | ASSERT_PIXEL_TYPE (ttShort); |
356 | |
357 | return (uint16 *) DirtyPixel (row, col, plane); |
358 | |
359 | } |
360 | |
361 | /// Get read-only int16 * to pixel data starting at a specific pixel in the buffer. |
362 | /// \param row Start row for buffer pointer. |
363 | /// \param col Start column for buffer pointer. |
364 | /// \param plane Start plane for buffer pointer. |
365 | /// \retval Pointer to pixel data as int16 *. |
366 | |
367 | const int16 * ConstPixel_int16 (int32 row, |
368 | int32 col, |
369 | uint32 plane = 0) const |
370 | { |
371 | |
372 | ASSERT_PIXEL_TYPE (ttSShort); |
373 | |
374 | return (const int16 *) ConstPixel (row, col, plane); |
375 | |
376 | } |
377 | |
378 | /// Get a writable int16 * to pixel data starting at a specific pixel in the buffer. |
379 | /// \param row Start row for buffer pointer. |
380 | /// \param col Start column for buffer pointer. |
381 | /// \param plane Start plane for buffer pointer. |
382 | /// \retval Pointer to pixel data as int16 *. |
383 | |
384 | int16 * DirtyPixel_int16 (int32 row, |
385 | int32 col, |
386 | uint32 plane = 0) |
387 | { |
388 | |
389 | ASSERT_PIXEL_TYPE (ttSShort); |
390 | |
391 | return (int16 *) DirtyPixel (row, col, plane); |
392 | |
393 | } |
394 | |
395 | /// Get read-only uint32 * to pixel data starting at a specific pixel in the buffer. |
396 | /// \param row Start row for buffer pointer. |
397 | /// \param col Start column for buffer pointer. |
398 | /// \param plane Start plane for buffer pointer. |
399 | /// \retval Pointer to pixel data as uint32 *. |
400 | |
401 | const uint32 * ConstPixel_uint32 (int32 row, |
402 | int32 col, |
403 | uint32 plane = 0) const |
404 | { |
405 | |
406 | ASSERT_PIXEL_TYPE (ttLong); |
407 | |
408 | return (const uint32 *) ConstPixel (row, col, plane); |
409 | |
410 | } |
411 | |
412 | /// Get a writable uint32 * to pixel data starting at a specific pixel in the buffer. |
413 | /// \param row Start row for buffer pointer. |
414 | /// \param col Start column for buffer pointer. |
415 | /// \param plane Start plane for buffer pointer. |
416 | /// \retval Pointer to pixel data as uint32 *. |
417 | |
418 | uint32 * DirtyPixel_uint32 (int32 row, |
419 | int32 col, |
420 | uint32 plane = 0) |
421 | { |
422 | |
423 | ASSERT_PIXEL_TYPE (ttLong); |
424 | |
425 | return (uint32 *) DirtyPixel (row, col, plane); |
426 | |
427 | } |
428 | |
429 | /// Get read-only int32 * to pixel data starting at a specific pixel in the buffer. |
430 | /// \param row Start row for buffer pointer. |
431 | /// \param col Start column for buffer pointer. |
432 | /// \param plane Start plane for buffer pointer. |
433 | /// \retval Pointer to pixel data as int32 *. |
434 | |
435 | const int32 * ConstPixel_int32 (int32 row, |
436 | int32 col, |
437 | uint32 plane = 0) const |
438 | { |
439 | |
440 | ASSERT_PIXEL_TYPE (ttSLong); |
441 | |
442 | return (const int32 *) ConstPixel (row, col, plane); |
443 | |
444 | } |
445 | |
446 | /// Get a writable int32 * to pixel data starting at a specific pixel in the buffer. |
447 | /// \param row Start row for buffer pointer. |
448 | /// \param col Start column for buffer pointer. |
449 | /// \param plane Start plane for buffer pointer. |
450 | /// \retval Pointer to pixel data as int32 *. |
451 | |
452 | int32 * DirtyPixel_int32 (int32 row, |
453 | int32 col, |
454 | uint32 plane = 0) |
455 | { |
456 | |
457 | ASSERT_PIXEL_TYPE (ttSLong); |
458 | |
459 | return (int32 *) DirtyPixel (row, col, plane); |
460 | |
461 | } |
462 | |
463 | /// Get read-only real32 * to pixel data starting at a specific pixel in the buffer. |
464 | /// \param row Start row for buffer pointer. |
465 | /// \param col Start column for buffer pointer. |
466 | /// \param plane Start plane for buffer pointer. |
467 | /// \retval Pointer to pixel data as real32 *. |
468 | |
469 | const real32 * ConstPixel_real32 (int32 row, |
470 | int32 col, |
471 | uint32 plane = 0) const |
472 | { |
473 | |
474 | ASSERT_PIXEL_TYPE (ttFloat); |
475 | |
476 | return (const real32 *) ConstPixel (row, col, plane); |
477 | |
478 | } |
479 | |
480 | /// Get a writable real32 * to pixel data starting at a specific pixel in the buffer. |
481 | /// \param row Start row for buffer pointer. |
482 | /// \param col Start column for buffer pointer. |
483 | /// \param plane Start plane for buffer pointer. |
484 | /// \retval Pointer to pixel data as real32 *. |
485 | |
486 | real32 * DirtyPixel_real32 (int32 row, |
487 | int32 col, |
488 | uint32 plane = 0) |
489 | { |
490 | |
491 | ASSERT_PIXEL_TYPE (ttFloat); |
492 | |
493 | return (real32 *) DirtyPixel (row, col, plane); |
494 | |
495 | } |
496 | |
497 | /// Initialize a rectangular area of pixel buffer to a constant. |
498 | /// \param area Rectangle of pixel buffer to set. |
499 | /// \param plane Plane to start filling on. |
500 | /// \param planes Number of planes to fill. |
501 | /// \param value Constant value to set pixels to. |
502 | |
503 | void SetConstant (const dng_rect &area, |
504 | uint32 plane, |
505 | uint32 planes, |
506 | uint32 value); |
507 | |
508 | /// Initialize a rectangular area of pixel buffer to a constant unsigned 8-bit value. |
509 | /// \param area Rectangle of pixel buffer to set. |
510 | /// \param plane Plane to start filling on. |
511 | /// \param planes Number of planes to fill. |
512 | /// \param value Constant uint8 value to set pixels to. |
513 | |
514 | void SetConstant_uint8 (const dng_rect &area, |
515 | uint32 plane, |
516 | uint32 planes, |
517 | uint8 value) |
518 | { |
519 | |
520 | DNG_ASSERT (fPixelType == ttByte, "Mismatched pixel type" ); |
521 | |
522 | SetConstant (area, plane, planes, (uint32) value); |
523 | |
524 | } |
525 | |
526 | /// Initialize a rectangular area of pixel buffer to a constant unsigned 16-bit value. |
527 | /// \param area Rectangle of pixel buffer to set. |
528 | /// \param plane Plane to start filling on. |
529 | /// \param planes Number of planes to fill. |
530 | /// \param value Constant uint16 value to set pixels to. |
531 | |
532 | void SetConstant_uint16 (const dng_rect &area, |
533 | uint32 plane, |
534 | uint32 planes, |
535 | uint16 value) |
536 | { |
537 | |
538 | DNG_ASSERT (fPixelType == ttShort, "Mismatched pixel type" ); |
539 | |
540 | SetConstant (area, plane, planes, (uint32) value); |
541 | |
542 | } |
543 | |
544 | /// Initialize a rectangular area of pixel buffer to a constant signed 16-bit value. |
545 | /// \param area Rectangle of pixel buffer to set. |
546 | /// \param plane Plane to start filling on. |
547 | /// \param planes Number of planes to fill. |
548 | /// \param value Constant int16 value to set pixels to. |
549 | |
550 | void SetConstant_int16 (const dng_rect &area, |
551 | uint32 plane, |
552 | uint32 planes, |
553 | int16 value) |
554 | { |
555 | |
556 | DNG_ASSERT (fPixelType == ttSShort, "Mismatched pixel type" ); |
557 | |
558 | SetConstant (area, plane, planes, (uint32) (uint16) value); |
559 | |
560 | } |
561 | |
562 | /// Initialize a rectangular area of pixel buffer to a constant unsigned 32-bit value. |
563 | /// \param area Rectangle of pixel buffer to set. |
564 | /// \param plane Plane to start filling on. |
565 | /// \param planes Number of planes to fill. |
566 | /// \param value Constant uint32 value to set pixels to. |
567 | |
568 | void SetConstant_uint32 (const dng_rect &area, |
569 | uint32 plane, |
570 | uint32 planes, |
571 | uint32 value) |
572 | { |
573 | |
574 | DNG_ASSERT (fPixelType == ttLong, "Mismatched pixel type" ); |
575 | |
576 | SetConstant (area, plane, planes, value); |
577 | |
578 | } |
579 | |
580 | /// Initialize a rectangular area of pixel buffer to a constant real 32-bit value. |
581 | /// \param area Rectangle of pixel buffer to set. |
582 | /// \param plane Plane to start filling on. |
583 | /// \param planes Number of planes to fill. |
584 | /// \param value Constant real32 value to set pixels to. |
585 | |
586 | void SetConstant_real32 (const dng_rect &area, |
587 | uint32 plane, |
588 | uint32 planes, |
589 | real32 value) |
590 | { |
591 | |
592 | DNG_ASSERT (fPixelType == ttFloat, "Mismatched pixel type" ); |
593 | |
594 | union |
595 | { |
596 | uint32 i; |
597 | real32 f; |
598 | } x; |
599 | |
600 | x.f = value; |
601 | |
602 | SetConstant (area, plane, planes, x.i); |
603 | |
604 | } |
605 | |
606 | /// Initialize a rectangular area of pixel buffer to zeros. |
607 | /// \param area Rectangle of pixel buffer to zero. |
608 | /// \param area Area to zero |
609 | /// \param plane Plane to start filling on. |
610 | /// \param planes Number of planes to fill. |
611 | |
612 | void SetZero (const dng_rect &area, |
613 | uint32 plane, |
614 | uint32 planes); |
615 | |
616 | /// Copy image data from an area of one pixel buffer to same area of another. |
617 | /// \param src Buffer to copy from. |
618 | /// \param area Rectangle of pixel buffer to copy. |
619 | /// \param srcPlane Plane to start copy in src. |
620 | /// \param dstPlane Plane to start copy in dst. |
621 | /// \param planes Number of planes to copy. |
622 | |
623 | void CopyArea (const dng_pixel_buffer &src, |
624 | const dng_rect &area, |
625 | uint32 srcPlane, |
626 | uint32 dstPlane, |
627 | uint32 planes); |
628 | |
629 | /// Copy image data from an area of one pixel buffer to same area of another. |
630 | /// \param src Buffer to copy from. |
631 | /// \param area Rectangle of pixel buffer to copy. |
632 | /// \param plane Plane to start copy in src and this. |
633 | /// \param planes Number of planes to copy. |
634 | |
635 | void CopyArea (const dng_pixel_buffer &src, |
636 | const dng_rect &area, |
637 | uint32 plane, |
638 | uint32 planes) |
639 | { |
640 | |
641 | CopyArea (src, area, plane, plane, planes); |
642 | |
643 | } |
644 | |
645 | /// Calculate the offset phase of destination rectangle relative to source rectangle. |
646 | /// Phase is based on a 0,0 origin and the notion of repeating srcArea across dstArea. |
647 | /// It is the number of pixels into srcArea to start repeating from when tiling dstArea. |
648 | /// \retval dng_point containing horizontal and vertical phase. |
649 | |
650 | static dng_point RepeatPhase (const dng_rect &srcArea, |
651 | const dng_rect &dstArea); |
652 | |
653 | /// Repeat the image data in srcArea across dstArea. |
654 | /// (Generally used for padding operations.) |
655 | /// \param srcArea Area to repeat from. |
656 | /// \param dstArea Area to fill with data from srcArea. |
657 | |
658 | void RepeatArea (const dng_rect &srcArea, |
659 | const dng_rect &dstArea); |
660 | |
661 | /// Replicates a sub-area of a buffer to fill the entire buffer. |
662 | |
663 | void RepeatSubArea (const dng_rect subArea, |
664 | uint32 repeatV = 1, |
665 | uint32 repeatH = 1); |
666 | |
667 | /// Apply a right shift (C++ oerpator >>) to all pixel values. Only implemented for 16-bit (signed or unsigned) pixel buffers. |
668 | /// \param shift Number of bits by which to right shift each pixel value. |
669 | |
670 | void ShiftRight (uint32 shift); |
671 | |
672 | /// Change metadata so pixels are iterated in opposite horizontal order. |
673 | /// This operation does not require movement of actual pixel data. |
674 | |
675 | void FlipH (); |
676 | |
677 | /// Change metadata so pixels are iterated in opposite vertical order. |
678 | /// This operation does not require movement of actual pixel data. |
679 | |
680 | void FlipV (); |
681 | |
682 | /// Change metadata so pixels are iterated in opposite plane order. |
683 | /// This operation does not require movement of actual pixel data. |
684 | |
685 | void FlipZ (); // Flip planes |
686 | |
687 | /// Return true if the contents of an area of the pixel buffer area are the same as those of another. |
688 | /// \param rhs Buffer to compare against. |
689 | /// \param area Rectangle of pixel buffer to test. |
690 | /// \param plane Plane to start comparing. |
691 | /// \param planes Number of planes to compare. |
692 | /// \retval bool true if areas are equal, false otherwise. |
693 | |
694 | bool EqualArea (const dng_pixel_buffer &rhs, |
695 | const dng_rect &area, |
696 | uint32 plane, |
697 | uint32 planes) const; |
698 | |
699 | /// Return the absolute value of the maximum difference between two pixel buffers. Used for comparison testing with tolerance |
700 | /// \param rhs Buffer to compare against. |
701 | /// \param area Rectangle of pixel buffer to test. |
702 | /// \param plane Plane to start comparing. |
703 | /// \param planes Number of planes to compare. |
704 | /// \retval larges absolute value difference between the corresponding pixels each buffer across area. |
705 | |
706 | real64 MaximumDifference (const dng_pixel_buffer &rhs, |
707 | const dng_rect &area, |
708 | uint32 plane, |
709 | uint32 planes) const; |
710 | |
711 | }; |
712 | |
713 | /*****************************************************************************/ |
714 | |
715 | #endif |
716 | |
717 | /*****************************************************************************/ |
718 | |