~cosme/ubuntu/precise/freeimage/freeimage-3.15.1

« back to all changes in this revision

Viewing changes to Source/OpenEXR/IlmImf/ImfTiledRgbaFile.h

  • Committer: Stefano Rivera
  • Date: 2010-07-24 15:35:51 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: stefanor@ubuntu.com-20100724153551-6s3fth1653huk31a
Tags: upstream-3.13.1
ImportĀ upstreamĀ versionĀ 3.31.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
///////////////////////////////////////////////////////////////////////////
2
 
//
3
 
// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
4
 
// Digital Ltd. LLC
5
 
// 
6
 
// All rights reserved.
7
 
// 
8
 
// Redistribution and use in source and binary forms, with or without
9
 
// modification, are permitted provided that the following conditions are
10
 
// met:
11
 
// *       Redistributions of source code must retain the above copyright
12
 
// notice, this list of conditions and the following disclaimer.
13
 
// *       Redistributions in binary form must reproduce the above
14
 
// copyright notice, this list of conditions and the following disclaimer
15
 
// in the documentation and/or other materials provided with the
16
 
// distribution.
17
 
// *       Neither the name of Industrial Light & Magic nor the names of
18
 
// its contributors may be used to endorse or promote products derived
19
 
// from this software without specific prior written permission. 
20
 
// 
21
 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22
 
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23
 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24
 
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25
 
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26
 
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27
 
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28
 
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29
 
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30
 
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31
 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32
 
//
33
 
///////////////////////////////////////////////////////////////////////////
34
 
 
35
 
 
36
 
#ifndef INCLUDED_IMF_TILED_RGBA_FILE_H
37
 
#define INCLUDED_IMF_TILED_RGBA_FILE_H
38
 
 
39
 
//-----------------------------------------------------------------------------
40
 
//
41
 
//      Simplified RGBA image I/O for tiled files
42
 
//
43
 
//      class TiledRgbaOutputFile
44
 
//      class TiledRgbaInputFile
45
 
//
46
 
//-----------------------------------------------------------------------------
47
 
 
48
 
#include <ImfHeader.h>
49
 
#include <ImfFrameBuffer.h>
50
 
#include "ImathVec.h"
51
 
#include "ImathBox.h"
52
 
#include "half.h"
53
 
#include <ImfTileDescription.h>
54
 
#include <ImfRgba.h>
55
 
#include <ImfThreading.h>
56
 
 
57
 
namespace Imf {
58
 
 
59
 
class TiledOutputFile;
60
 
class TiledInputFile;
61
 
struct PreviewRgba;
62
 
 
63
 
 
64
 
//
65
 
// Tiled RGBA output file.
66
 
//
67
 
 
68
 
class TiledRgbaOutputFile
69
 
{
70
 
  public:
71
 
 
72
 
    //---------------------------------------------------
73
 
    // Constructor -- rgbaChannels, tileXSize, tileYSize,
74
 
    // levelMode, and levelRoundingMode overwrite the
75
 
    // channel list and tile description attribute in the
76
 
    // header that is passed as an argument to the
77
 
    // constructor.
78
 
    //---------------------------------------------------
79
 
 
80
 
    TiledRgbaOutputFile (const char name[],
81
 
                         const Header &header,
82
 
                         RgbaChannels rgbaChannels,
83
 
                         int tileXSize,
84
 
                         int tileYSize,
85
 
                         LevelMode mode,
86
 
                         LevelRoundingMode rmode = ROUND_DOWN,
87
 
                         int numThreads = globalThreadCount ());
88
 
 
89
 
 
90
 
    //---------------------------------------------------
91
 
    // Constructor -- like the previous one, but the new
92
 
    // TiledRgbaOutputFile is attached to a file that has
93
 
    // already been opened by the caller.  Destroying
94
 
    // TiledRgbaOutputFileObjects constructed with this
95
 
    // constructor does not automatically close the
96
 
    // corresponding files.
97
 
    //---------------------------------------------------
98
 
 
99
 
    TiledRgbaOutputFile (OStream &os,
100
 
                         const Header &header,
101
 
                         RgbaChannels rgbaChannels,
102
 
                         int tileXSize,
103
 
                         int tileYSize,
104
 
                         LevelMode mode,
105
 
                         LevelRoundingMode rmode = ROUND_DOWN,
106
 
                         int numThreads = globalThreadCount ());
107
 
 
108
 
 
109
 
    //------------------------------------------------------
110
 
    // Constructor -- header data are explicitly specified
111
 
    // as function call arguments (an empty dataWindow means
112
 
    // "same as displayWindow")
113
 
    //------------------------------------------------------
114
 
 
115
 
    TiledRgbaOutputFile (const char name[],
116
 
                         int tileXSize,
117
 
                         int tileYSize,
118
 
                         LevelMode mode,
119
 
                         LevelRoundingMode rmode,
120
 
                         const Imath::Box2i &displayWindow,
121
 
                         const Imath::Box2i &dataWindow = Imath::Box2i(),
122
 
                         RgbaChannels rgbaChannels = WRITE_RGBA,
123
 
                         float pixelAspectRatio = 1,
124
 
                         const Imath::V2f screenWindowCenter =
125
 
                                                    Imath::V2f (0, 0),
126
 
                         float screenWindowWidth = 1,
127
 
                         LineOrder lineOrder = INCREASING_Y,
128
 
                         Compression compression = ZIP_COMPRESSION,
129
 
                         int numThreads = globalThreadCount ());
130
 
 
131
 
 
132
 
    //-----------------------------------------------
133
 
    // Constructor -- like the previous one, but both
134
 
    // the display window and the data window are
135
 
    // Box2i (V2i (0, 0), V2i (width - 1, height -1))
136
 
    //-----------------------------------------------
137
 
 
138
 
    TiledRgbaOutputFile (const char name[],
139
 
                         int width,
140
 
                         int height,
141
 
                         int tileXSize,
142
 
                         int tileYSize,
143
 
                         LevelMode mode,
144
 
                         LevelRoundingMode rmode = ROUND_DOWN,
145
 
                         RgbaChannels rgbaChannels = WRITE_RGBA,
146
 
                         float pixelAspectRatio = 1,
147
 
                         const Imath::V2f screenWindowCenter =
148
 
                                                    Imath::V2f (0, 0),
149
 
                         float screenWindowWidth = 1,
150
 
                         LineOrder lineOrder = INCREASING_Y,
151
 
                         Compression compression = ZIP_COMPRESSION,
152
 
                         int numThreads = globalThreadCount ());
153
 
 
154
 
 
155
 
    virtual ~TiledRgbaOutputFile ();
156
 
 
157
 
 
158
 
    //------------------------------------------------
159
 
    // Define a frame buffer as the pixel data source:
160
 
    // Pixel (x, y) is at address
161
 
    //
162
 
    //  base + x * xStride + y * yStride
163
 
    //
164
 
    //------------------------------------------------
165
 
 
166
 
    void                setFrameBuffer (const Rgba *base,
167
 
                                        size_t xStride,
168
 
                                        size_t yStride);
169
 
 
170
 
    //--------------------------
171
 
    // Access to the file header
172
 
    //--------------------------
173
 
 
174
 
    const Header &              header () const;
175
 
    const FrameBuffer &         frameBuffer () const;
176
 
    const Imath::Box2i &        displayWindow () const;
177
 
    const Imath::Box2i &        dataWindow () const;
178
 
    float                       pixelAspectRatio () const;
179
 
    const Imath::V2f            screenWindowCenter () const;
180
 
    float                       screenWindowWidth () const;
181
 
    LineOrder                   lineOrder () const;
182
 
    Compression                 compression () const;
183
 
    RgbaChannels                channels () const;
184
 
 
185
 
 
186
 
    //----------------------------------------------------
187
 
    // Utility functions (same as in Imf::TiledOutputFile)
188
 
    //----------------------------------------------------
189
 
 
190
 
    unsigned int        tileXSize () const;
191
 
    unsigned int        tileYSize () const;
192
 
    LevelMode           levelMode () const;
193
 
    LevelRoundingMode   levelRoundingMode () const;
194
 
 
195
 
    int                 numLevels () const;
196
 
    int                 numXLevels () const;
197
 
    int                 numYLevels () const;
198
 
    bool                isValidLevel (int lx, int ly) const;
199
 
 
200
 
    int                 levelWidth  (int lx) const;
201
 
    int                 levelHeight (int ly) const;
202
 
 
203
 
    int                 numXTiles (int lx = 0) const;
204
 
    int                 numYTiles (int ly = 0) const;
205
 
 
206
 
    Imath::Box2i        dataWindowForLevel (int l = 0) const;
207
 
    Imath::Box2i        dataWindowForLevel (int lx, int ly) const;
208
 
 
209
 
    Imath::Box2i        dataWindowForTile (int dx, int dy,
210
 
                                           int l = 0) const;
211
 
 
212
 
    Imath::Box2i        dataWindowForTile (int dx, int dy,
213
 
                                           int lx, int ly) const;
214
 
 
215
 
    //------------------------------------------------------------------
216
 
    // Write pixel data:
217
 
    //
218
 
    // writeTile(dx, dy, lx, ly) writes the tile with tile
219
 
    // coordinates (dx, dy), and level number (lx, ly) to
220
 
    // the file.
221
 
    //
222
 
    //   dx must lie in the interval [0, numXTiles(lx)-1]
223
 
    //   dy must lie in the interval [0, numYTiles(ly)-1]
224
 
    //
225
 
    //   lx must lie in the interval [0, numXLevels()-1]
226
 
    //   ly must lie in the inverval [0, numYLevels()-1]
227
 
    //
228
 
    // writeTile(dx, dy, level) is a convenience function
229
 
    // used for ONE_LEVEL and MIPMAP_LEVEL files.  It calls
230
 
    // writeTile(dx, dy, level, level).
231
 
    //
232
 
    // The two writeTiles(dx1, dx2, dy1, dy2, ...) functions allow
233
 
    // writing multiple tiles at once.  If multi-threading is used
234
 
    // multiple tiles are written concurrently.
235
 
    //
236
 
    // Pixels that are outside the pixel coordinate range for the tile's
237
 
    // level, are never accessed by writeTile().
238
 
    //
239
 
    // Each tile in the file must be written exactly once.
240
 
    //
241
 
    //------------------------------------------------------------------
242
 
 
243
 
    void                writeTile (int dx, int dy, int l = 0);
244
 
    void                writeTile (int dx, int dy, int lx, int ly);
245
 
 
246
 
    void                writeTiles (int dxMin, int dxMax, int dyMin, int dyMax,
247
 
                                    int lx, int ly);
248
 
 
249
 
    void                writeTiles (int dxMin, int dxMax, int dyMin, int dyMax,
250
 
                                    int l = 0);
251
 
 
252
 
 
253
 
    // -------------------------------------------------------------------------
254
 
    // Update the preview image (see Imf::TiledOutputFile::updatePreviewImage())
255
 
    // -------------------------------------------------------------------------
256
 
 
257
 
    void                updatePreviewImage (const PreviewRgba[]);
258
 
 
259
 
 
260
 
    //------------------------------------------------
261
 
    // Break a tile -- for testing and debugging only
262
 
    // (see Imf::TiledOutputFile::breakTile())
263
 
    //
264
 
    // Warning: Calling this function usually results
265
 
    // in a broken image file.  The file or parts of
266
 
    // it may not be readable, or the file may contain
267
 
    // bad data.
268
 
    //
269
 
    //------------------------------------------------
270
 
 
271
 
    void                breakTile  (int dx, int dy,
272
 
                                    int lx, int ly,
273
 
                                    int offset,
274
 
                                    int length,
275
 
                                    char c);
276
 
  private:
277
 
 
278
 
    //
279
 
    // Copy constructor and assignment are not implemented
280
 
    //
281
 
 
282
 
    TiledRgbaOutputFile (const TiledRgbaOutputFile &);  
283
 
    TiledRgbaOutputFile & operator = (const TiledRgbaOutputFile &);
284
 
 
285
 
    class ToYa;
286
 
 
287
 
    TiledOutputFile *            _outputFile;
288
 
    ToYa *                      _toYa;
289
 
};
290
 
 
291
 
 
292
 
 
293
 
//
294
 
// Tiled RGBA input file
295
 
//
296
 
 
297
 
class TiledRgbaInputFile
298
 
{
299
 
  public:
300
 
 
301
 
    //--------------------------------------------------------
302
 
    // Constructor -- opens the file with the specified name.
303
 
    // Destroying TiledRgbaInputFile objects constructed with
304
 
    // this constructor automatically closes the corresponding
305
 
    // files.
306
 
    //--------------------------------------------------------
307
 
 
308
 
    TiledRgbaInputFile (const char name[],
309
 
                        int numThreads = globalThreadCount ());
310
 
 
311
 
 
312
 
    //-------------------------------------------------------
313
 
    // Constructor -- attaches the new TiledRgbaInputFile
314
 
    // object to a file that has already been opened by the
315
 
    // caller.
316
 
    // Destroying TiledRgbaInputFile objects constructed with
317
 
    // this constructor does not automatically close the
318
 
    // corresponding files.
319
 
    //-------------------------------------------------------
320
 
 
321
 
    TiledRgbaInputFile (IStream &is, int numThreads = globalThreadCount ());
322
 
 
323
 
 
324
 
    //-----------
325
 
    // Destructor
326
 
    //-----------
327
 
 
328
 
    virtual ~TiledRgbaInputFile ();
329
 
 
330
 
 
331
 
    //-----------------------------------------------------
332
 
    // Define a frame buffer as the pixel data destination:
333
 
    // Pixel (x, y) is at address
334
 
    //
335
 
    //  base + x * xStride + y * yStride
336
 
    //
337
 
    //-----------------------------------------------------
338
 
 
339
 
    void                        setFrameBuffer (Rgba *base,
340
 
                                                size_t xStride,
341
 
                                                size_t yStride);
342
 
 
343
 
    //--------------------------
344
 
    // Access to the file header
345
 
    //--------------------------
346
 
 
347
 
    const Header &              header () const;
348
 
    const FrameBuffer &         frameBuffer () const;
349
 
    const Imath::Box2i &        displayWindow () const;
350
 
    const Imath::Box2i &        dataWindow () const;
351
 
    float                       pixelAspectRatio () const;
352
 
    const Imath::V2f            screenWindowCenter () const;
353
 
    float                       screenWindowWidth () const;
354
 
    LineOrder                   lineOrder () const;
355
 
    Compression                 compression () const;
356
 
    RgbaChannels                channels () const;
357
 
    const char *                fileName () const;
358
 
    bool                        isComplete () const;
359
 
 
360
 
    //----------------------------------
361
 
    // Access to the file format version
362
 
    //----------------------------------
363
 
 
364
 
    int                         version () const;
365
 
 
366
 
 
367
 
    //---------------------------------------------------
368
 
    // Utility functions (same as in Imf::TiledInputFile)
369
 
    //---------------------------------------------------
370
 
 
371
 
    unsigned int        tileXSize () const;
372
 
    unsigned int        tileYSize () const;
373
 
    LevelMode           levelMode () const;
374
 
    LevelRoundingMode   levelRoundingMode () const;
375
 
 
376
 
    int                 numLevels () const;
377
 
    int                 numXLevels () const;
378
 
    int                 numYLevels () const;
379
 
    bool                isValidLevel (int lx, int ly) const;
380
 
 
381
 
    int                 levelWidth  (int lx) const;
382
 
    int                 levelHeight (int ly) const;
383
 
 
384
 
    int                 numXTiles (int lx = 0) const;
385
 
    int                 numYTiles (int ly = 0) const;
386
 
 
387
 
    Imath::Box2i        dataWindowForLevel (int l = 0) const;
388
 
    Imath::Box2i        dataWindowForLevel (int lx, int ly) const;
389
 
 
390
 
    Imath::Box2i        dataWindowForTile (int dx, int dy,
391
 
                                           int l = 0) const;
392
 
 
393
 
    Imath::Box2i        dataWindowForTile (int dx, int dy,
394
 
                                           int lx, int ly) const;
395
 
                                           
396
 
 
397
 
    //----------------------------------------------------------------
398
 
    // Read pixel data:
399
 
    //
400
 
    // readTile(dx, dy, lx, ly) reads the tile with tile
401
 
    // coordinates (dx, dy), and level number (lx, ly),
402
 
    // and stores it in the current frame buffer.
403
 
    //
404
 
    //   dx must lie in the interval [0, numXTiles(lx)-1]
405
 
    //   dy must lie in the interval [0, numYTiles(ly)-1]
406
 
    //
407
 
    //   lx must lie in the interval [0, numXLevels()-1]
408
 
    //   ly must lie in the inverval [0, numYLevels()-1]
409
 
    //
410
 
    // readTile(dx, dy, level) is a convenience function used
411
 
    // for ONE_LEVEL and MIPMAP_LEVELS files.  It calls
412
 
    // readTile(dx, dy, level, level).
413
 
    //
414
 
    // The two readTiles(dx1, dx2, dy1, dy2, ...) functions allow
415
 
    // reading multiple tiles at once.  If multi-threading is used
416
 
    // multiple tiles are read concurrently.
417
 
    //
418
 
    // Pixels that are outside the pixel coordinate range for the
419
 
    // tile's level, are never accessed by readTile().
420
 
    //
421
 
    // Attempting to access a tile that is not present in the file
422
 
    // throws an InputExc exception.
423
 
    //
424
 
    //----------------------------------------------------------------
425
 
 
426
 
    void                readTile (int dx, int dy, int l = 0);
427
 
    void                readTile (int dx, int dy, int lx, int ly);
428
 
 
429
 
    void                readTiles (int dxMin, int dxMax,
430
 
                                   int dyMin, int dyMax, int lx, int ly);
431
 
 
432
 
    void                readTiles (int dxMin, int dxMax,
433
 
                                   int dyMin, int dyMax, int l = 0);
434
 
 
435
 
  private:
436
 
 
437
 
    //
438
 
    // Copy constructor and assignment are not implemented
439
 
    //
440
 
 
441
 
    TiledRgbaInputFile (const TiledRgbaInputFile &);
442
 
    TiledRgbaInputFile & operator = (const TiledRgbaInputFile &);
443
 
 
444
 
    class FromYa;
445
 
 
446
 
    TiledInputFile *    _inputFile;
447
 
    FromYa *            _fromYa;
448
 
};
449
 
 
450
 
 
451
 
} // namespace Imf
452
 
 
453
 
#endif
 
1
///////////////////////////////////////////////////////////////////////////
 
2
//
 
3
// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
 
4
// Digital Ltd. LLC
 
5
// 
 
6
// All rights reserved.
 
7
// 
 
8
// Redistribution and use in source and binary forms, with or without
 
9
// modification, are permitted provided that the following conditions are
 
10
// met:
 
11
// *       Redistributions of source code must retain the above copyright
 
12
// notice, this list of conditions and the following disclaimer.
 
13
// *       Redistributions in binary form must reproduce the above
 
14
// copyright notice, this list of conditions and the following disclaimer
 
15
// in the documentation and/or other materials provided with the
 
16
// distribution.
 
17
// *       Neither the name of Industrial Light & Magic nor the names of
 
18
// its contributors may be used to endorse or promote products derived
 
19
// from this software without specific prior written permission. 
 
20
// 
 
21
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
22
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
23
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
24
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
25
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
26
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
27
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
28
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
29
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
30
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
31
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
32
//
 
33
///////////////////////////////////////////////////////////////////////////
 
34
 
 
35
 
 
36
#ifndef INCLUDED_IMF_TILED_RGBA_FILE_H
 
37
#define INCLUDED_IMF_TILED_RGBA_FILE_H
 
38
 
 
39
//-----------------------------------------------------------------------------
 
40
//
 
41
//      Simplified RGBA image I/O for tiled files
 
42
//
 
43
//      class TiledRgbaOutputFile
 
44
//      class TiledRgbaInputFile
 
45
//
 
46
//-----------------------------------------------------------------------------
 
47
 
 
48
#include <ImfHeader.h>
 
49
#include <ImfFrameBuffer.h>
 
50
#include "ImathVec.h"
 
51
#include "ImathBox.h"
 
52
#include "half.h"
 
53
#include <ImfTileDescription.h>
 
54
#include <ImfRgba.h>
 
55
#include <ImfThreading.h>
 
56
 
 
57
namespace Imf {
 
58
 
 
59
class TiledOutputFile;
 
60
class TiledInputFile;
 
61
struct PreviewRgba;
 
62
 
 
63
 
 
64
//
 
65
// Tiled RGBA output file.
 
66
//
 
67
 
 
68
class TiledRgbaOutputFile
 
69
{
 
70
  public:
 
71
 
 
72
    //---------------------------------------------------
 
73
    // Constructor -- rgbaChannels, tileXSize, tileYSize,
 
74
    // levelMode, and levelRoundingMode overwrite the
 
75
    // channel list and tile description attribute in the
 
76
    // header that is passed as an argument to the
 
77
    // constructor.
 
78
    //---------------------------------------------------
 
79
 
 
80
    TiledRgbaOutputFile (const char name[],
 
81
                         const Header &header,
 
82
                         RgbaChannels rgbaChannels,
 
83
                         int tileXSize,
 
84
                         int tileYSize,
 
85
                         LevelMode mode,
 
86
                         LevelRoundingMode rmode = ROUND_DOWN,
 
87
                         int numThreads = globalThreadCount ());
 
88
 
 
89
 
 
90
    //---------------------------------------------------
 
91
    // Constructor -- like the previous one, but the new
 
92
    // TiledRgbaOutputFile is attached to a file that has
 
93
    // already been opened by the caller.  Destroying
 
94
    // TiledRgbaOutputFileObjects constructed with this
 
95
    // constructor does not automatically close the
 
96
    // corresponding files.
 
97
    //---------------------------------------------------
 
98
 
 
99
    TiledRgbaOutputFile (OStream &os,
 
100
                         const Header &header,
 
101
                         RgbaChannels rgbaChannels,
 
102
                         int tileXSize,
 
103
                         int tileYSize,
 
104
                         LevelMode mode,
 
105
                         LevelRoundingMode rmode = ROUND_DOWN,
 
106
                         int numThreads = globalThreadCount ());
 
107
 
 
108
 
 
109
    //------------------------------------------------------
 
110
    // Constructor -- header data are explicitly specified
 
111
    // as function call arguments (an empty dataWindow means
 
112
    // "same as displayWindow")
 
113
    //------------------------------------------------------
 
114
 
 
115
    TiledRgbaOutputFile (const char name[],
 
116
                         int tileXSize,
 
117
                         int tileYSize,
 
118
                         LevelMode mode,
 
119
                         LevelRoundingMode rmode,
 
120
                         const Imath::Box2i &displayWindow,
 
121
                         const Imath::Box2i &dataWindow = Imath::Box2i(),
 
122
                         RgbaChannels rgbaChannels = WRITE_RGBA,
 
123
                         float pixelAspectRatio = 1,
 
124
                         const Imath::V2f screenWindowCenter =
 
125
                                                    Imath::V2f (0, 0),
 
126
                         float screenWindowWidth = 1,
 
127
                         LineOrder lineOrder = INCREASING_Y,
 
128
                         Compression compression = ZIP_COMPRESSION,
 
129
                         int numThreads = globalThreadCount ());
 
130
 
 
131
 
 
132
    //-----------------------------------------------
 
133
    // Constructor -- like the previous one, but both
 
134
    // the display window and the data window are
 
135
    // Box2i (V2i (0, 0), V2i (width - 1, height -1))
 
136
    //-----------------------------------------------
 
137
 
 
138
    TiledRgbaOutputFile (const char name[],
 
139
                         int width,
 
140
                         int height,
 
141
                         int tileXSize,
 
142
                         int tileYSize,
 
143
                         LevelMode mode,
 
144
                         LevelRoundingMode rmode = ROUND_DOWN,
 
145
                         RgbaChannels rgbaChannels = WRITE_RGBA,
 
146
                         float pixelAspectRatio = 1,
 
147
                         const Imath::V2f screenWindowCenter =
 
148
                                                    Imath::V2f (0, 0),
 
149
                         float screenWindowWidth = 1,
 
150
                         LineOrder lineOrder = INCREASING_Y,
 
151
                         Compression compression = ZIP_COMPRESSION,
 
152
                         int numThreads = globalThreadCount ());
 
153
 
 
154
 
 
155
    virtual ~TiledRgbaOutputFile ();
 
156
 
 
157
 
 
158
    //------------------------------------------------
 
159
    // Define a frame buffer as the pixel data source:
 
160
    // Pixel (x, y) is at address
 
161
    //
 
162
    //  base + x * xStride + y * yStride
 
163
    //
 
164
    //------------------------------------------------
 
165
 
 
166
    void                setFrameBuffer (const Rgba *base,
 
167
                                        size_t xStride,
 
168
                                        size_t yStride);
 
169
 
 
170
    //--------------------------
 
171
    // Access to the file header
 
172
    //--------------------------
 
173
 
 
174
    const Header &              header () const;
 
175
    const FrameBuffer &         frameBuffer () const;
 
176
    const Imath::Box2i &        displayWindow () const;
 
177
    const Imath::Box2i &        dataWindow () const;
 
178
    float                       pixelAspectRatio () const;
 
179
    const Imath::V2f            screenWindowCenter () const;
 
180
    float                       screenWindowWidth () const;
 
181
    LineOrder                   lineOrder () const;
 
182
    Compression                 compression () const;
 
183
    RgbaChannels                channels () const;
 
184
 
 
185
 
 
186
    //----------------------------------------------------
 
187
    // Utility functions (same as in Imf::TiledOutputFile)
 
188
    //----------------------------------------------------
 
189
 
 
190
    unsigned int        tileXSize () const;
 
191
    unsigned int        tileYSize () const;
 
192
    LevelMode           levelMode () const;
 
193
    LevelRoundingMode   levelRoundingMode () const;
 
194
 
 
195
    int                 numLevels () const;
 
196
    int                 numXLevels () const;
 
197
    int                 numYLevels () const;
 
198
    bool                isValidLevel (int lx, int ly) const;
 
199
 
 
200
    int                 levelWidth  (int lx) const;
 
201
    int                 levelHeight (int ly) const;
 
202
 
 
203
    int                 numXTiles (int lx = 0) const;
 
204
    int                 numYTiles (int ly = 0) const;
 
205
 
 
206
    Imath::Box2i        dataWindowForLevel (int l = 0) const;
 
207
    Imath::Box2i        dataWindowForLevel (int lx, int ly) const;
 
208
 
 
209
    Imath::Box2i        dataWindowForTile (int dx, int dy,
 
210
                                           int l = 0) const;
 
211
 
 
212
    Imath::Box2i        dataWindowForTile (int dx, int dy,
 
213
                                           int lx, int ly) const;
 
214
 
 
215
    //------------------------------------------------------------------
 
216
    // Write pixel data:
 
217
    //
 
218
    // writeTile(dx, dy, lx, ly) writes the tile with tile
 
219
    // coordinates (dx, dy), and level number (lx, ly) to
 
220
    // the file.
 
221
    //
 
222
    //   dx must lie in the interval [0, numXTiles(lx)-1]
 
223
    //   dy must lie in the interval [0, numYTiles(ly)-1]
 
224
    //
 
225
    //   lx must lie in the interval [0, numXLevels()-1]
 
226
    //   ly must lie in the inverval [0, numYLevels()-1]
 
227
    //
 
228
    // writeTile(dx, dy, level) is a convenience function
 
229
    // used for ONE_LEVEL and MIPMAP_LEVEL files.  It calls
 
230
    // writeTile(dx, dy, level, level).
 
231
    //
 
232
    // The two writeTiles(dx1, dx2, dy1, dy2, ...) functions allow
 
233
    // writing multiple tiles at once.  If multi-threading is used
 
234
    // multiple tiles are written concurrently.
 
235
    //
 
236
    // Pixels that are outside the pixel coordinate range for the tile's
 
237
    // level, are never accessed by writeTile().
 
238
    //
 
239
    // Each tile in the file must be written exactly once.
 
240
    //
 
241
    //------------------------------------------------------------------
 
242
 
 
243
    void                writeTile (int dx, int dy, int l = 0);
 
244
    void                writeTile (int dx, int dy, int lx, int ly);
 
245
 
 
246
    void                writeTiles (int dxMin, int dxMax, int dyMin, int dyMax,
 
247
                                    int lx, int ly);
 
248
 
 
249
    void                writeTiles (int dxMin, int dxMax, int dyMin, int dyMax,
 
250
                                    int l = 0);
 
251
 
 
252
 
 
253
    // -------------------------------------------------------------------------
 
254
    // Update the preview image (see Imf::TiledOutputFile::updatePreviewImage())
 
255
    // -------------------------------------------------------------------------
 
256
 
 
257
    void                updatePreviewImage (const PreviewRgba[]);
 
258
 
 
259
 
 
260
    //------------------------------------------------
 
261
    // Break a tile -- for testing and debugging only
 
262
    // (see Imf::TiledOutputFile::breakTile())
 
263
    //
 
264
    // Warning: Calling this function usually results
 
265
    // in a broken image file.  The file or parts of
 
266
    // it may not be readable, or the file may contain
 
267
    // bad data.
 
268
    //
 
269
    //------------------------------------------------
 
270
 
 
271
    void                breakTile  (int dx, int dy,
 
272
                                    int lx, int ly,
 
273
                                    int offset,
 
274
                                    int length,
 
275
                                    char c);
 
276
  private:
 
277
 
 
278
    //
 
279
    // Copy constructor and assignment are not implemented
 
280
    //
 
281
 
 
282
    TiledRgbaOutputFile (const TiledRgbaOutputFile &);  
 
283
    TiledRgbaOutputFile & operator = (const TiledRgbaOutputFile &);
 
284
 
 
285
    class ToYa;
 
286
 
 
287
    TiledOutputFile *            _outputFile;
 
288
    ToYa *                      _toYa;
 
289
};
 
290
 
 
291
 
 
292
 
 
293
//
 
294
// Tiled RGBA input file
 
295
//
 
296
 
 
297
class TiledRgbaInputFile
 
298
{
 
299
  public:
 
300
 
 
301
    //--------------------------------------------------------
 
302
    // Constructor -- opens the file with the specified name.
 
303
    // Destroying TiledRgbaInputFile objects constructed with
 
304
    // this constructor automatically closes the corresponding
 
305
    // files.
 
306
    //--------------------------------------------------------
 
307
 
 
308
    TiledRgbaInputFile (const char name[],
 
309
                        int numThreads = globalThreadCount ());
 
310
 
 
311
 
 
312
    //-------------------------------------------------------
 
313
    // Constructor -- attaches the new TiledRgbaInputFile
 
314
    // object to a file that has already been opened by the
 
315
    // caller.
 
316
    // Destroying TiledRgbaInputFile objects constructed with
 
317
    // this constructor does not automatically close the
 
318
    // corresponding files.
 
319
    //-------------------------------------------------------
 
320
 
 
321
    TiledRgbaInputFile (IStream &is, int numThreads = globalThreadCount ());
 
322
 
 
323
 
 
324
    //-----------
 
325
    // Destructor
 
326
    //-----------
 
327
 
 
328
    virtual ~TiledRgbaInputFile ();
 
329
 
 
330
 
 
331
    //-----------------------------------------------------
 
332
    // Define a frame buffer as the pixel data destination:
 
333
    // Pixel (x, y) is at address
 
334
    //
 
335
    //  base + x * xStride + y * yStride
 
336
    //
 
337
    //-----------------------------------------------------
 
338
 
 
339
    void                        setFrameBuffer (Rgba *base,
 
340
                                                size_t xStride,
 
341
                                                size_t yStride);
 
342
 
 
343
    //--------------------------
 
344
    // Access to the file header
 
345
    //--------------------------
 
346
 
 
347
    const Header &              header () const;
 
348
    const FrameBuffer &         frameBuffer () const;
 
349
    const Imath::Box2i &        displayWindow () const;
 
350
    const Imath::Box2i &        dataWindow () const;
 
351
    float                       pixelAspectRatio () const;
 
352
    const Imath::V2f            screenWindowCenter () const;
 
353
    float                       screenWindowWidth () const;
 
354
    LineOrder                   lineOrder () const;
 
355
    Compression                 compression () const;
 
356
    RgbaChannels                channels () const;
 
357
    const char *                fileName () const;
 
358
    bool                        isComplete () const;
 
359
 
 
360
    //----------------------------------
 
361
    // Access to the file format version
 
362
    //----------------------------------
 
363
 
 
364
    int                         version () const;
 
365
 
 
366
 
 
367
    //---------------------------------------------------
 
368
    // Utility functions (same as in Imf::TiledInputFile)
 
369
    //---------------------------------------------------
 
370
 
 
371
    unsigned int        tileXSize () const;
 
372
    unsigned int        tileYSize () const;
 
373
    LevelMode           levelMode () const;
 
374
    LevelRoundingMode   levelRoundingMode () const;
 
375
 
 
376
    int                 numLevels () const;
 
377
    int                 numXLevels () const;
 
378
    int                 numYLevels () const;
 
379
    bool                isValidLevel (int lx, int ly) const;
 
380
 
 
381
    int                 levelWidth  (int lx) const;
 
382
    int                 levelHeight (int ly) const;
 
383
 
 
384
    int                 numXTiles (int lx = 0) const;
 
385
    int                 numYTiles (int ly = 0) const;
 
386
 
 
387
    Imath::Box2i        dataWindowForLevel (int l = 0) const;
 
388
    Imath::Box2i        dataWindowForLevel (int lx, int ly) const;
 
389
 
 
390
    Imath::Box2i        dataWindowForTile (int dx, int dy,
 
391
                                           int l = 0) const;
 
392
 
 
393
    Imath::Box2i        dataWindowForTile (int dx, int dy,
 
394
                                           int lx, int ly) const;
 
395
                                           
 
396
 
 
397
    //----------------------------------------------------------------
 
398
    // Read pixel data:
 
399
    //
 
400
    // readTile(dx, dy, lx, ly) reads the tile with tile
 
401
    // coordinates (dx, dy), and level number (lx, ly),
 
402
    // and stores it in the current frame buffer.
 
403
    //
 
404
    //   dx must lie in the interval [0, numXTiles(lx)-1]
 
405
    //   dy must lie in the interval [0, numYTiles(ly)-1]
 
406
    //
 
407
    //   lx must lie in the interval [0, numXLevels()-1]
 
408
    //   ly must lie in the inverval [0, numYLevels()-1]
 
409
    //
 
410
    // readTile(dx, dy, level) is a convenience function used
 
411
    // for ONE_LEVEL and MIPMAP_LEVELS files.  It calls
 
412
    // readTile(dx, dy, level, level).
 
413
    //
 
414
    // The two readTiles(dx1, dx2, dy1, dy2, ...) functions allow
 
415
    // reading multiple tiles at once.  If multi-threading is used
 
416
    // multiple tiles are read concurrently.
 
417
    //
 
418
    // Pixels that are outside the pixel coordinate range for the
 
419
    // tile's level, are never accessed by readTile().
 
420
    //
 
421
    // Attempting to access a tile that is not present in the file
 
422
    // throws an InputExc exception.
 
423
    //
 
424
    //----------------------------------------------------------------
 
425
 
 
426
    void                readTile (int dx, int dy, int l = 0);
 
427
    void                readTile (int dx, int dy, int lx, int ly);
 
428
 
 
429
    void                readTiles (int dxMin, int dxMax,
 
430
                                   int dyMin, int dyMax, int lx, int ly);
 
431
 
 
432
    void                readTiles (int dxMin, int dxMax,
 
433
                                   int dyMin, int dyMax, int l = 0);
 
434
 
 
435
  private:
 
436
 
 
437
    //
 
438
    // Copy constructor and assignment are not implemented
 
439
    //
 
440
 
 
441
    TiledRgbaInputFile (const TiledRgbaInputFile &);
 
442
    TiledRgbaInputFile & operator = (const TiledRgbaInputFile &);
 
443
 
 
444
    class FromYa;
 
445
 
 
446
    TiledInputFile *    _inputFile;
 
447
    FromYa *            _fromYa;
 
448
};
 
449
 
 
450
 
 
451
} // namespace Imf
 
452
 
 
453
#endif