1/*****************************************************************************/
2// Copyright 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_opcodes.h#2 $ */
10/* $DateTime: 2012/08/02 06:09:06 $ */
11/* $Change: 841096 $ */
12/* $Author: erichan $ */
13
14/** \file
15 * Base class and common data structures for opcodes (introduced in DNG 1.3).
16 */
17
18/*****************************************************************************/
19
20#ifndef __dng_opcodes__
21#define __dng_opcodes__
22
23/*****************************************************************************/
24
25#include "dng_auto_ptr.h"
26#include "dng_classes.h"
27#include "dng_rect.h"
28#include "dng_types.h"
29
30/*****************************************************************************/
31
32/// \brief List of supported opcodes (by ID).
33
34enum dng_opcode_id
35 {
36
37 // Internal use only opcode. Never written to DNGs.
38
39 dngOpcode_Private = 0,
40
41 // Warp image to correct distortion and lateral chromatic aberration for
42 // rectilinear lenses.
43
44 dngOpcode_WarpRectilinear = 1,
45
46 // Warp image to correction distortion for fisheye lenses (i.e., map the
47 // fisheye projection to a perspective projection).
48
49 dngOpcode_WarpFisheye = 2,
50
51 // Radial vignette correction.
52
53 dngOpcode_FixVignetteRadial = 3,
54
55 // Patch bad Bayer pixels which are marked with a special value in the image.
56
57 dngOpcode_FixBadPixelsConstant = 4,
58
59 // Patch bad Bayer pixels/rectangles at a list of specified coordinates.
60
61 dngOpcode_FixBadPixelsList = 5,
62
63 // Trim image to specified bounds.
64
65 dngOpcode_TrimBounds = 6,
66
67 // Map an area through a 16-bit LUT.
68
69 dngOpcode_MapTable = 7,
70
71 // Map an area using a polynomial function.
72
73 dngOpcode_MapPolynomial = 8,
74
75 // Apply a gain map to an area.
76
77 dngOpcode_GainMap = 9,
78
79 // Apply a per-row delta to an area.
80
81 dngOpcode_DeltaPerRow = 10,
82
83 // Apply a per-column delta to an area.
84
85 dngOpcode_DeltaPerColumn = 11,
86
87 // Apply a per-row scale to an area.
88
89 dngOpcode_ScalePerRow = 12,
90
91 // Apply a per-column scale to an area.
92
93 dngOpcode_ScalePerColumn = 13
94
95 };
96
97/*****************************************************************************/
98
99/// \brief Virtual base class for opcode.
100
101class dng_opcode
102 {
103
104 public:
105
106 /// Opcode flags.
107
108 enum
109 {
110 kFlag_None = 0, //!< No flag.
111 kFlag_Optional = 1, //!< This opcode is optional.
112 kFlag_SkipIfPreview = 2 //!< May skip opcode for preview images.
113 };
114
115 private:
116
117 uint32 fOpcodeID;
118
119 uint32 fMinVersion;
120
121 uint32 fFlags;
122
123 bool fWasReadFromStream;
124
125 uint32 fStage;
126
127 protected:
128
129 dng_opcode (uint32 opcodeID,
130 uint32 minVersion,
131 uint32 flags);
132
133 dng_opcode (uint32 opcodeID,
134 dng_stream &stream,
135 const char *name);
136
137 public:
138
139 virtual ~dng_opcode ();
140
141 /// The ID of this opcode.
142
143 uint32 OpcodeID () const
144 {
145 return fOpcodeID;
146 }
147
148 /// The first DNG version that supports this opcode.
149
150 uint32 MinVersion () const
151 {
152 return fMinVersion;
153 }
154
155 /// The flags for this opcode.
156
157 uint32 Flags () const
158 {
159 return fFlags;
160 }
161
162 /// Is this opcode optional?
163
164 bool Optional () const
165 {
166 return (Flags () & kFlag_Optional) != 0;
167 }
168
169 /// Should the opcode be skipped when rendering preview images?
170
171 bool SkipIfPreview () const
172 {
173 return (Flags () & kFlag_SkipIfPreview) != 0;
174 }
175
176 /// Was this opcode read from a data stream?
177
178 bool WasReadFromStream () const
179 {
180 return fWasReadFromStream;
181 }
182
183 /// Which image processing stage (1, 2, 3) is associated with this
184 /// opcode?
185
186 uint32 Stage () const
187 {
188 return fStage;
189 }
190
191 /// Set the image processing stage (1, 2, 3) for this opcode. Stage 1 is
192 /// the original image data, including masked areas. Stage 2 is
193 /// linearized image data and trimmed to the active area. Stage 3 is
194 /// demosaiced and trimmed to the active area.
195
196 void SetStage (uint32 stage)
197 {
198 fStage = stage;
199 }
200
201 /// Is the opcode a NOP (i.e., does nothing)? An opcode could be a NOP
202 /// for some specific parameters.
203
204 virtual bool IsNOP () const
205 {
206 return false;
207 }
208
209 /// Is this opcode valid for the specified negative?
210
211 virtual bool IsValidForNegative (const dng_negative & /* negative */) const
212 {
213 return true;
214 }
215
216 /// Write opcode to a stream.
217 /// \param stream The stream to which to write the opcode data.
218
219 virtual void PutData (dng_stream &stream) const;
220
221 /// Perform error checking prior to applying this opcode to the
222 /// specified negative. Returns true if this opcode should be applied to
223 /// the negative, false otherwise.
224
225 bool AboutToApply (dng_host &host,
226 dng_negative &negative);
227
228 /// Apply this opcode to the specified image with associated negative.
229
230 virtual void Apply (dng_host &host,
231 dng_negative &negative,
232 AutoPtr<dng_image> &image) = 0;
233
234 };
235
236/*****************************************************************************/
237
238/// \brief Class to represent unknown opcodes (e.g, opcodes defined in future
239/// DNG versions).
240
241class dng_opcode_Unknown: public dng_opcode
242 {
243
244 private:
245
246 AutoPtr<dng_memory_block> fData;
247
248 public:
249
250 dng_opcode_Unknown (dng_host &host,
251 uint32 opcodeID,
252 dng_stream &stream);
253
254 virtual void PutData (dng_stream &stream) const;
255
256 virtual void Apply (dng_host &host,
257 dng_negative &negative,
258 AutoPtr<dng_image> &image);
259
260 };
261
262/*****************************************************************************/
263
264/// \brief Class to represent a filter opcode, such as a convolution.
265
266class dng_filter_opcode: public dng_opcode
267 {
268
269 protected:
270
271 dng_filter_opcode (uint32 opcodeID,
272 uint32 minVersion,
273 uint32 flags);
274
275 dng_filter_opcode (uint32 opcodeID,
276 dng_stream &stream,
277 const char *name);
278
279 public:
280
281 /// The pixel data type of this opcode.
282
283 virtual uint32 BufferPixelType (uint32 imagePixelType)
284 {
285 return imagePixelType;
286 }
287
288 /// The adjusted bounds (processing area) of this opcode. It is limited to
289 /// the intersection of the specified image area and the GainMap area.
290
291 virtual dng_rect ModifiedBounds (const dng_rect &imageBounds)
292 {
293 return imageBounds;
294 }
295
296 /// Returns the width and height (in pixels) of the repeating mosaic pattern.
297
298 virtual dng_point SrcRepeat ()
299 {
300 return dng_point (1, 1);
301 }
302
303 /// Returns the source pixel area needed to process a destination pixel area
304 /// that lies within the specified bounds.
305 /// \param dstArea The destination pixel area to be computed.
306 /// \param imageBounds The overall image area (dstArea will lie within these
307 /// bounds).
308 /// \retval The source pixel area needed to process the specified dstArea.
309
310 virtual dng_rect SrcArea (const dng_rect &dstArea,
311 const dng_rect & /* imageBounds */)
312 {
313 return dstArea;
314 }
315
316 /// Given a destination tile size, calculate input tile size. Simlar to
317 /// SrcArea, and should seldom be overridden.
318 ///
319 /// \param dstTileSize The destination tile size that is targeted for output.
320 ///
321 /// \param imageBounds The image bounds (the destination tile will
322 /// always lie within these bounds).
323 ///
324 /// \retval The source tile size needed to compute a tile of the destination
325 /// size.
326
327 virtual dng_point SrcTileSize (const dng_point &dstTileSize,
328 const dng_rect &imageBounds)
329 {
330 return SrcArea (dng_rect (dstTileSize),
331 imageBounds).Size ();
332 }
333
334 /// Startup method called before any processing is performed on pixel areas.
335 /// It can be used to allocate (per-thread) memory and setup tasks.
336 ///
337 /// \param negative The negative object to be processed.
338 ///
339 /// \param threadCount The number of threads to be used to perform the
340 /// processing.
341 ///
342 /// \param threadCount Total number of threads that will be used for
343 /// processing. Less than or equal to MaxThreads.
344 ///
345 /// \param tileSize Size of source tiles which will be processed. (Not all
346 /// tiles will be this size due to edge conditions.)
347 ///
348 /// \param imageBounds Total size of image to be processed.
349 ///
350 /// \param imagePlanes Number of planes in the image. Less than or equal to
351 /// kMaxColorPlanes.
352 ///
353 /// \param bufferPixelType Pixel type of image buffer (see dng_tag_types.h).
354 ///
355 /// \param allocator dng_memory_allocator to use for allocating temporary
356 /// buffers, etc.
357
358 virtual void Prepare (dng_negative & /* negative */,
359 uint32 /* threadCount */,
360 const dng_point & /* tileSize */,
361 const dng_rect & /* imageBounds */,
362 uint32 /* imagePlanes */,
363 uint32 /* bufferPixelType */,
364 dng_memory_allocator & /* allocator */)
365 {
366 }
367
368 /// Implements filtering operation from one buffer to another. Source
369 /// and destination pixels are set up in member fields of this class.
370 /// Ideally, no allocation should be done in this routine.
371 ///
372 /// \param negative The negative associated with the pixels to be
373 /// processed.
374 ///
375 /// \param threadIndex The thread on which this routine is being called,
376 /// between 0 and threadCount - 1 for the threadCount passed to Prepare
377 /// method.
378 ///
379 /// \param srcBuffer Input area and source pixels.
380 ///
381 /// \param dstBuffer Destination pixels.
382 ///
383 /// \param dstArea Destination pixel processing area.
384 ///
385 /// \param imageBounds Total image area to be processed; dstArea will
386 /// always lie within these bounds.
387
388 virtual void ProcessArea (dng_negative &negative,
389 uint32 threadIndex,
390 dng_pixel_buffer &srcBuffer,
391 dng_pixel_buffer &dstBuffer,
392 const dng_rect &dstArea,
393 const dng_rect &imageBounds) = 0;
394
395 virtual void Apply (dng_host &host,
396 dng_negative &negative,
397 AutoPtr<dng_image> &image);
398
399 };
400
401/*****************************************************************************/
402
403/// \brief Class to represent an in-place (i.e., pointwise, per-pixel) opcode,
404/// such as a global tone curve.
405
406class dng_inplace_opcode: public dng_opcode
407 {
408
409 protected:
410
411 dng_inplace_opcode (uint32 opcodeID,
412 uint32 minVersion,
413 uint32 flags);
414
415 dng_inplace_opcode (uint32 opcodeID,
416 dng_stream &stream,
417 const char *name);
418
419 public:
420
421 /// The pixel data type of this opcode.
422
423 virtual uint32 BufferPixelType (uint32 imagePixelType)
424 {
425 return imagePixelType;
426 }
427
428 /// The adjusted bounds (processing area) of this opcode. It is limited to
429 /// the intersection of the specified image area and the GainMap area.
430
431 virtual dng_rect ModifiedBounds (const dng_rect &imageBounds)
432 {
433 return imageBounds;
434 }
435
436 /// Startup method called before any processing is performed on pixel areas.
437 /// It can be used to allocate (per-thread) memory and setup tasks.
438 ///
439 /// \param negative The negative object to be processed.
440 ///
441 /// \param threadCount The number of threads to be used to perform the
442 /// processing.
443 ///
444 /// \param threadCount Total number of threads that will be used for
445 /// processing. Less than or equal to MaxThreads.
446 ///
447 /// \param tileSize Size of source tiles which will be processed. (Not all
448 /// tiles will be this size due to edge conditions.)
449 ///
450 /// \param imageBounds Total size of image to be processed.
451 ///
452 /// \param imagePlanes Number of planes in the image. Less than or equal to
453 /// kMaxColorPlanes.
454 ///
455 /// \param bufferPixelType Pixel type of image buffer (see dng_tag_types.h).
456 ///
457 /// \param allocator dng_memory_allocator to use for allocating temporary
458 /// buffers, etc.
459
460 virtual void Prepare (dng_negative & /* negative */,
461 uint32 /* threadCount */,
462 const dng_point & /* tileSize */,
463 const dng_rect & /* imageBounds */,
464 uint32 /* imagePlanes */,
465 uint32 /* bufferPixelType */,
466 dng_memory_allocator & /* allocator */)
467 {
468 }
469
470 /// Implements image processing operation in a single buffer. The source
471 /// pixels are provided as input to the buffer, and this routine
472 /// calculates and writes the destination pixels to the same buffer.
473 /// Ideally, no allocation should be done in this routine.
474 ///
475 /// \param negative The negative associated with the pixels to be
476 /// processed.
477 ///
478 /// \param threadIndex The thread on which this routine is being called,
479 /// between 0 and threadCount - 1 for the threadCount passed to Prepare
480 /// method.
481 ///
482 /// \param srcBuffer Input area and source pixels.
483 ///
484 /// \param dstBuffer Destination pixels.
485 ///
486 /// \param dstArea Destination pixel processing area.
487 ///
488 /// \param imageBounds Total image area to be processed; dstArea will
489 /// always lie within these bounds.
490
491 virtual void ProcessArea (dng_negative &negative,
492 uint32 threadIndex,
493 dng_pixel_buffer &buffer,
494 const dng_rect &dstArea,
495 const dng_rect &imageBounds) = 0;
496
497 virtual void Apply (dng_host &host,
498 dng_negative &negative,
499 AutoPtr<dng_image> &image);
500
501 };
502
503/*****************************************************************************/
504
505#endif
506
507/*****************************************************************************/
508