1 | /*****************************************************************************/ |
2 | // Copyright 2008-2009 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_misc_opcodes.h#2 $ */ |
10 | /* $DateTime: 2012/08/02 06:09:06 $ */ |
11 | /* $Change: 841096 $ */ |
12 | /* $Author: erichan $ */ |
13 | |
14 | /** \file |
15 | * Miscellaneous DNG opcodes. |
16 | */ |
17 | |
18 | /*****************************************************************************/ |
19 | |
20 | #ifndef __dng_misc_opcodes__ |
21 | #define __dng_misc_opcodes__ |
22 | |
23 | /*****************************************************************************/ |
24 | |
25 | #include "dng_opcodes.h" |
26 | |
27 | /*****************************************************************************/ |
28 | |
29 | /// \brief Opcode to trim image to a specified rectangle. |
30 | |
31 | class dng_opcode_TrimBounds: public dng_opcode |
32 | { |
33 | |
34 | private: |
35 | |
36 | dng_rect fBounds; |
37 | |
38 | public: |
39 | |
40 | /// Create opcode to trim image to the specified bounds. |
41 | |
42 | dng_opcode_TrimBounds (const dng_rect &bounds); |
43 | |
44 | dng_opcode_TrimBounds (dng_stream &stream); |
45 | |
46 | virtual void PutData (dng_stream &stream) const; |
47 | |
48 | virtual void Apply (dng_host &host, |
49 | dng_negative &negative, |
50 | AutoPtr<dng_image> &image); |
51 | |
52 | }; |
53 | |
54 | /*****************************************************************************/ |
55 | |
56 | /// \brief A class to describe an area of an image, including a pixel subrectangle, |
57 | /// plane range, and row/column pitch (e.g., for mosaic images). Useful for |
58 | /// specifying opcodes that only apply to specific color planes or pixel types (e.g., |
59 | /// only one of the two green Bayer pixels). |
60 | |
61 | class dng_area_spec |
62 | { |
63 | |
64 | public: |
65 | |
66 | enum |
67 | { |
68 | kDataSize = 32 |
69 | }; |
70 | |
71 | private: |
72 | |
73 | dng_rect fArea; |
74 | |
75 | uint32 fPlane; |
76 | uint32 fPlanes; |
77 | |
78 | uint32 fRowPitch; |
79 | uint32 fColPitch; |
80 | |
81 | public: |
82 | |
83 | /// Create an empty area. |
84 | |
85 | dng_area_spec (const dng_rect &area = dng_rect (), |
86 | uint32 plane = 0, |
87 | uint32 planes = 1, |
88 | uint32 rowPitch = 1, |
89 | uint32 colPitch = 1) |
90 | |
91 | : fArea (area) |
92 | , fPlane (plane) |
93 | , fPlanes (planes) |
94 | , fRowPitch (rowPitch) |
95 | , fColPitch (colPitch) |
96 | |
97 | { |
98 | } |
99 | |
100 | /// The pixel area. |
101 | |
102 | const dng_rect & Area () const |
103 | { |
104 | return fArea; |
105 | } |
106 | |
107 | /// The first plane. |
108 | |
109 | const uint32 Plane () const |
110 | { |
111 | return fPlane; |
112 | } |
113 | |
114 | /// The total number of planes. |
115 | |
116 | const uint32 Planes () const |
117 | { |
118 | return fPlanes; |
119 | } |
120 | |
121 | /// The row pitch (i.e., stride). A pitch of 1 means all rows. |
122 | |
123 | const uint32 RowPitch () const |
124 | { |
125 | return fRowPitch; |
126 | } |
127 | |
128 | /// The column pitch (i.e., stride). A pitch of 1 means all columns. |
129 | |
130 | const uint32 ColPitch () const |
131 | { |
132 | return fColPitch; |
133 | } |
134 | |
135 | /// Read area data from the specified stream. |
136 | |
137 | void GetData (dng_stream &stream); |
138 | |
139 | /// Write area data to the specified stream. |
140 | |
141 | void PutData (dng_stream &stream) const; |
142 | |
143 | /// Compute and return pixel area overlap (i.e., intersection) between this |
144 | /// area and the specified tile. |
145 | |
146 | dng_rect Overlap (const dng_rect &tile) const; |
147 | |
148 | }; |
149 | |
150 | /*****************************************************************************/ |
151 | |
152 | /// \brief An opcode to apply a 1D function (represented as a 16-bit table) to an |
153 | /// image area. |
154 | |
155 | class dng_opcode_MapTable: public dng_inplace_opcode |
156 | { |
157 | |
158 | private: |
159 | |
160 | dng_area_spec fAreaSpec; |
161 | |
162 | AutoPtr<dng_memory_block> fTable; |
163 | |
164 | uint32 fCount; |
165 | |
166 | public: |
167 | |
168 | /// Create a MapTable opcode with the specified area, table, and number of |
169 | /// table entries. |
170 | |
171 | dng_opcode_MapTable (dng_host &host, |
172 | const dng_area_spec &areaSpec, |
173 | const uint16 *table, |
174 | uint32 count = 0x10000); |
175 | |
176 | dng_opcode_MapTable (dng_host &host, |
177 | dng_stream &stream); |
178 | |
179 | virtual void PutData (dng_stream &stream) const; |
180 | |
181 | virtual uint32 BufferPixelType (uint32 imagePixelType); |
182 | |
183 | virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); |
184 | |
185 | virtual void ProcessArea (dng_negative &negative, |
186 | uint32 threadIndex, |
187 | dng_pixel_buffer &buffer, |
188 | const dng_rect &dstArea, |
189 | const dng_rect &imageBounds); |
190 | |
191 | private: |
192 | |
193 | void ReplicateLastEntry (); |
194 | |
195 | }; |
196 | |
197 | /*****************************************************************************/ |
198 | |
199 | /// \brief An opcode to apply a 1D function (represented as a polynomial) to an |
200 | /// image area. |
201 | |
202 | class dng_opcode_MapPolynomial: public dng_inplace_opcode |
203 | { |
204 | |
205 | public: |
206 | |
207 | enum |
208 | { |
209 | kMaxDegree = 8 |
210 | }; |
211 | |
212 | private: |
213 | |
214 | dng_area_spec fAreaSpec; |
215 | |
216 | uint32 fDegree; |
217 | |
218 | real64 fCoefficient [kMaxDegree + 1]; |
219 | |
220 | real32 fCoefficient32 [kMaxDegree + 1]; |
221 | |
222 | public: |
223 | |
224 | /// Create a MapPolynomial opcode with the specified area, polynomial |
225 | /// degree, and polynomial coefficients. The function that will be |
226 | /// applied to each pixel x is: |
227 | /// |
228 | /// f (x) = coefficient [0] + ((x * coefficient [1]) + |
229 | /// (x^2 * coefficient [2]) + |
230 | /// (x^3 * coefficient [3]) + |
231 | /// (x^4 * coefficient [4]) ... |
232 | |
233 | dng_opcode_MapPolynomial (const dng_area_spec &areaSpec, |
234 | uint32 degree, |
235 | const real64 *coefficient); |
236 | |
237 | dng_opcode_MapPolynomial (dng_stream &stream); |
238 | |
239 | virtual void PutData (dng_stream &stream) const; |
240 | |
241 | virtual uint32 BufferPixelType (uint32 imagePixelType); |
242 | |
243 | virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); |
244 | |
245 | virtual void ProcessArea (dng_negative &negative, |
246 | uint32 threadIndex, |
247 | dng_pixel_buffer &buffer, |
248 | const dng_rect &dstArea, |
249 | const dng_rect &imageBounds); |
250 | |
251 | }; |
252 | |
253 | /*****************************************************************************/ |
254 | |
255 | /// \brief An opcode to apply a delta (i.e., offset) that varies per row. Within |
256 | /// a row, the same delta value is applied to all specified pixels. |
257 | |
258 | class dng_opcode_DeltaPerRow: public dng_inplace_opcode |
259 | { |
260 | |
261 | private: |
262 | |
263 | dng_area_spec fAreaSpec; |
264 | |
265 | AutoPtr<dng_memory_block> fTable; |
266 | |
267 | real32 fScale; |
268 | |
269 | public: |
270 | |
271 | /// Create a DeltaPerRow opcode with the specified area and row deltas |
272 | /// (specified as a table of 32-bit floats). |
273 | |
274 | dng_opcode_DeltaPerRow (const dng_area_spec &areaSpec, |
275 | AutoPtr<dng_memory_block> &table); |
276 | |
277 | dng_opcode_DeltaPerRow (dng_host &host, |
278 | dng_stream &stream); |
279 | |
280 | virtual void PutData (dng_stream &stream) const; |
281 | |
282 | virtual uint32 BufferPixelType (uint32 imagePixelType); |
283 | |
284 | virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); |
285 | |
286 | virtual void ProcessArea (dng_negative &negative, |
287 | uint32 threadIndex, |
288 | dng_pixel_buffer &buffer, |
289 | const dng_rect &dstArea, |
290 | const dng_rect &imageBounds); |
291 | |
292 | }; |
293 | |
294 | /*****************************************************************************/ |
295 | |
296 | /// \brief An opcode to apply a delta (i.e., offset) that varies per column. |
297 | /// Within a column, the same delta value is applied to all specified pixels. |
298 | |
299 | class dng_opcode_DeltaPerColumn: public dng_inplace_opcode |
300 | { |
301 | |
302 | private: |
303 | |
304 | dng_area_spec fAreaSpec; |
305 | |
306 | AutoPtr<dng_memory_block> fTable; |
307 | |
308 | real32 fScale; |
309 | |
310 | public: |
311 | |
312 | /// Create a DeltaPerColumn opcode with the specified area and column |
313 | /// deltas (specified as a table of 32-bit floats). |
314 | |
315 | dng_opcode_DeltaPerColumn (const dng_area_spec &areaSpec, |
316 | AutoPtr<dng_memory_block> &table); |
317 | |
318 | dng_opcode_DeltaPerColumn (dng_host &host, |
319 | dng_stream &stream); |
320 | |
321 | virtual void PutData (dng_stream &stream) const; |
322 | |
323 | virtual uint32 BufferPixelType (uint32 imagePixelType); |
324 | |
325 | virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); |
326 | |
327 | virtual void ProcessArea (dng_negative &negative, |
328 | uint32 threadIndex, |
329 | dng_pixel_buffer &buffer, |
330 | const dng_rect &dstArea, |
331 | const dng_rect &imageBounds); |
332 | |
333 | }; |
334 | |
335 | /*****************************************************************************/ |
336 | |
337 | /// \brief An opcode to apply a scale factor that varies per row. Within a row, |
338 | /// the same scale factor is applied to all specified pixels. |
339 | |
340 | class dng_opcode_ScalePerRow: public dng_inplace_opcode |
341 | { |
342 | |
343 | private: |
344 | |
345 | dng_area_spec fAreaSpec; |
346 | |
347 | AutoPtr<dng_memory_block> fTable; |
348 | |
349 | public: |
350 | |
351 | /// Create a ScalePerRow opcode with the specified area and row scale |
352 | /// factors (specified as a table of 32-bit floats). |
353 | |
354 | dng_opcode_ScalePerRow (const dng_area_spec &areaSpec, |
355 | AutoPtr<dng_memory_block> &table); |
356 | |
357 | dng_opcode_ScalePerRow (dng_host &host, |
358 | dng_stream &stream); |
359 | |
360 | virtual void PutData (dng_stream &stream) const; |
361 | |
362 | virtual uint32 BufferPixelType (uint32 imagePixelType); |
363 | |
364 | virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); |
365 | |
366 | virtual void ProcessArea (dng_negative &negative, |
367 | uint32 threadIndex, |
368 | dng_pixel_buffer &buffer, |
369 | const dng_rect &dstArea, |
370 | const dng_rect &imageBounds); |
371 | |
372 | }; |
373 | |
374 | /*****************************************************************************/ |
375 | |
376 | /// \brief An opcode to apply a scale factor that varies per column. Within a |
377 | /// column, the same scale factor is applied to all specified pixels. |
378 | |
379 | class dng_opcode_ScalePerColumn: public dng_inplace_opcode |
380 | { |
381 | |
382 | private: |
383 | |
384 | dng_area_spec fAreaSpec; |
385 | |
386 | AutoPtr<dng_memory_block> fTable; |
387 | |
388 | public: |
389 | |
390 | /// Create a ScalePerColumn opcode with the specified area and column |
391 | /// scale factors (specified as a table of 32-bit floats). |
392 | |
393 | dng_opcode_ScalePerColumn (const dng_area_spec &areaSpec, |
394 | AutoPtr<dng_memory_block> &table); |
395 | |
396 | dng_opcode_ScalePerColumn (dng_host &host, |
397 | dng_stream &stream); |
398 | |
399 | virtual void PutData (dng_stream &stream) const; |
400 | |
401 | virtual uint32 BufferPixelType (uint32 imagePixelType); |
402 | |
403 | virtual dng_rect ModifiedBounds (const dng_rect &imageBounds); |
404 | |
405 | virtual void ProcessArea (dng_negative &negative, |
406 | uint32 threadIndex, |
407 | dng_pixel_buffer &buffer, |
408 | const dng_rect &dstArea, |
409 | const dng_rect &imageBounds); |
410 | |
411 | }; |
412 | |
413 | /*****************************************************************************/ |
414 | |
415 | #endif |
416 | |
417 | /*****************************************************************************/ |
418 | |