IMG_TileFile.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        IMG_TileFile (C++)
 *
 * COMMENTS:    This class actually writes out to a file.  No if's ands or
 *              buts.
 *
 */

#ifndef __IMG_TileFile_H__
#define __IMG_TileFile_H__

#include "IMG_API.h"
#include "IMG_File.h"
#include "IMG_Stat.h"
#include "IMG_TileDevice.h"
#include <UT/UT_Array.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_UniquePtr.h>

class IMG_File;

class IMG_API IMG_TileFileMapEntry
{
public:
    // When opening multiple files, we get a list of plane definitions
    // Each plane may be written to a "shared" file, or it might be written to
    // aunique file.
    // This class keeps track of the mappings of each input channel to the
    // output file/channel.
    // For each source channel, we store
    //  int     SourceOffset;   // Offset into source data
    //  int     SourceSize;     // Bytes per pixel
    //  int     DestFile;       // Destination file index
    //  int     DestPlane;      // Destination plane index
     IMG_TileFileMapEntry()     {}

    int         getSourceOffset() const         { return mySourceOffset; }
    int         getSourceSize() const           { return mySourceSize; }
    int         getDestFileIndex() const        { return myDestFileIndex; }
    int         getPlaneIndex() const           { return myDestPlane; }
    IMG_File    *getFile() const                { return myDestFile; }
    void        setupMap(int off, int size,
                         const IMG_FilePtr &fp, int findex, int plane)
                {
                    mySourceOffset = off;
                    mySourceSize = size;
                    myDestFile = fp.get();
                    myDestFileIndex = findex;
                    myDestPlane = plane;
                }

private:
    IMG_File    *myDestFile;
    int          mySourceOffset;
    int          mySourceSize;
    int          myDestFileIndex;
    int          myDestPlane;
};
using IMG_TileFileMapEntryPtr = UT_UniquePtr<IMG_TileFileMapEntry>;

class IMG_API IMG_TileFile
    : public IMG_TileDevice
{
public:
             IMG_TileFile();
            ~IMG_TileFile() override;

             UT_NON_COPYABLE(IMG_TileFile)

    const char          *className() const override;
    void                 getDescription(UT_WorkBuffer &wbuf) const override;
//
//  Virtual method to open a picture.  Returns 0 on failure
    int                 open(const IMG_TileOptions &finfo,
                                int xres, int yres,
                                int twidth, int theight,
                                fpreal aspect) override;
    int                 openMulti(IMG_TileOptionList &flist,
                                int xres, int yres,
                                int twidth, int theight,
                                fpreal aspect) override;

//  Method to actually write a tile to the file.  The data to write is passed
//    relative to the dataWindow() on the IMG_TileDevice.
    int                  writeTile(const void *data,
                                   unsigned x0, unsigned x1,
                                   unsigned y0, unsigned y1) override;
    void                 checkpoint() override;
    int                  close(bool keep_alive=false) override;

protected:
    void                 writeCustomTag(const char *tagname, int size,
                                        const char *const *values) override;
private:
    void                prepData();

    UT_Array<IMG_FilePtr>               myFiles;
    UT_StringArray                      myFilenames;
    UT_Array<IMG_TileFileMapEntryPtr>   myPlaneMap;
    int                                 myBPP;
};

#endif