Application: gvSIG desktop » gvSIG 3D

	<project name="libjni-mrsid" default="main" basedir=".">

	<description>

		Compila la librería jmrsid

	</description>

	<property name="src-java" location="src/main/java" />

	<property name="src-test-java" location="src/test/java" />

	<property name="jar-dist" location="jar-dist" />

	<property name="build" location="bin/" />

	<property name="build-test" location="bin-test/" />

	<property name="cmake_build" location="BMCMake/" />

	<property name="sdk-dir" location="/home/miguel/mrsid/Geo_DSDK-6.0.7.1407" />

	<property environment="env"/>

	<condition property="jmrsid_version" value="0.0.6">

		<os family="unix"/>

	</condition>

	<condition property="jmrsid_version" value="006">

		<os family="windows"/>

	</condition>

	<property name="jmrsid-jar" location="jmrsid-0.0.6.jar" />

	<condition property="cmake_generator" value="'Unix Makefiles'">

		<os family="unix"/>

	</condition>

	<condition property="cmake_generator" value="'NMake Makefiles'">

		<os family="windows"/>

	</condition>		

	<target name="main" description="compile java code, make jars, prepare and compile natives" depends="clean,jar,prepare-natives,compile-natives">

	</target>

	<target name="jar" description="makes jar file">

		<mkdir dir="${build}" />

		<javac srcdir="${src-java}" destdir="${build}" debug="true" />

		<mkdir dir="${jar-dist}" />

		<jar jarfile="${jmrsid-jar}" basedir="${build}" includes="es/gva/cit/jmrsid/**" />

		<move file="${jmrsid-jar}" todir="${jar-dist}" />

	</target>

	<target name="prepare-natives" description="prepares the natives to be compiled">

		<mkdir dir="${cmake_build}"/>

		<delete file="${cmake_build}/CMakeCache.txt"/>

		<exec dir="${cmake_build}" executable="cmake">

			<arg line=".." />

			<arg line="-G${cmake_generator}" />

			<arg line="-DMRSID_DIR=${sdk-dir}" />

			<arg line="-DCMAKE_BUILD_TYPE=Release" />

			<arg line="-DJMRSID_VERSION=${jmrsid_version}" />

		</exec>

	</target>

	<target name="compile-natives" description="compiles natives">

		<exec dir="${cmake_build}" executable="make" os="Linux">

			<arg line="install" />

		</exec>

		<exec dir="${cmake_build}" executable="nmake" os="Windows 98,Windows 2000,Windows XP,Windows NT (Unknown)">

			<arg line="install" />

		</exec>

	</target>

	<target name="clean" description="clean distribution">

		<delete dir="jar-dist"/>

		<delete dir="lib-dist"/>

		<delete dir="BMCMake"/>

	</target>

</project>

<?xml version="1.0" encoding="UTF-8"?>

<?eclipse-cdt version="2.0"?>

<cdtproject id="org.eclipse.cdt.make.core.make">

<extension point="org.eclipse.cdt.core.BinaryParser" id="org.eclipse.cdt.core.ELF"/>

<data>

<item id="org.eclipse.cdt.core.pathentry">

<pathentry kind="src" path=""/>

<pathentry kind="out" path=""/>

<pathentry kind="con" path="org.eclipse.cdt.make.core.DISCOVERED_SCANNER_INFO"/>

</item>

<item id="cdt_indexer">

<indexEnabled indexValue="true"/>

<indexerProblemsEnabled indexProblemsValue="0"/>

</item>

<item id="org.eclipse.cdt.make.core.buildtargets">

<buildTargets>

<target name="all" targetID="org.eclipse.cdt.make.MakeTargetBuilder" path="">

<buildCommand>make</buildCommand>

<buildTarget>all</buildTarget>

<stopOnError>false</stopOnError>

<useDefaultCommand>true</useDefaultCommand>

</target>

<target name="clean" targetID="org.eclipse.cdt.make.MakeTargetBuilder" path="">

<buildCommand>make</buildCommand>

<buildTarget>clean</buildTarget>

<stopOnError>false</stopOnError>

<useDefaultCommand>true</useDefaultCommand>

</target>

</buildTargets>

</item>

</data>

</cdtproject>

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="src" path="src/main/java"/>

	<classpathentry kind="src" path="src/test/java"/>

	<classpathentry kind="src" path="src/main/resources"/>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/3"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

/* $Id: MrSIDPasswordDelegate.h 3539 2006-01-09 12:23:20Z nacho $ */

/* //////////////////////////////////////////////////////////////////////////

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

////////////////////////////////////////////////////////////////////////// */

/* PUBLIC */

#ifndef MRSIDPASSWORDDELEGATE_H

#define MRSIDPASSWORDDELEGATE_H

// lt_lib_base

#include "lt_base.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class EncryptImp;

class MrSIDImageReaderBase;

class MG2ImageWriter;

class MG3ImageWriter;

/**

 * delegate for locked MrSID images

 *

 * This abstract class is used with MrSIDImageReaderBase::setPasswordDelegate()

 * to supply a user-callback mechanism for supplying text passwords to

 * the internal MrSID decoder logic.

 *

 * Users should derive their own class from this, supplying their own

 * reportIncorrectPassword() and getPassword() methods.

 */

class MrSIDPasswordDelegate

{

public:

   /**

    * constructor

    */

   MrSIDPasswordDelegate();

   /**

    * destructor

    */

   virtual ~MrSIDPasswordDelegate();

   /**

    * user function for user notification

    *

    * This function is called by the decoder if the password

    * entered was incorrect.  Derived classes must implement

    * this function, e.g. to pop up a message box, abort the

    * operation, etc.

    *

    * @return success or failure in reporting to user

    */

   virtual LT_STATUS reportIncorrectPassword() = 0;

   /**

    * user function for getting the password

    *

    * This function is called by the decoder to request a password

    * from the user.  Derived classes must implement

    * this function, e.g. to pop up a text-entry dialog box.

    *

    * The implementation of this function must copy the password

    * into the buffer pointed by getPasswordBuffer().

    *

    * @return success or failure in getting password from user

    */

   virtual LT_STATUS getPassword() = 0;

protected:

   /**

    * get password buffer

    *

    * This function returns a pointer to the allocated area for the

    * password obtained from the user.

    *

    * @return  pointer to the password buffer

    */

   char* getPasswordBuffer();

   /**

    * get password buffer length

    *

    * This function returns the length of the buffer returned from

    * getPasswordBuffer().

    *

    * @return  length of the password buffer

    */

   lt_uint32 getPasswordBufferLength();

private:

   friend class EncryptImp;

   EncryptImp* m_encryptImp;

   char* m_passwordBuffer;

   static const lt_uint32 s_passwordBufferLength;

   friend class MrSIDImageReaderBase;

   friend class MG2ImageWriter;

   friend class MG3ImageWriter;

   void registerProvider();

   // nope

   MrSIDPasswordDelegate(const MrSIDPasswordDelegate&);

   MrSIDPasswordDelegate& operator=(const MrSIDPasswordDelegate&);

};

/**

 * simple concrete delegate for locked MrSID images

 *

 * This class is a concrete password delegate class which just

 * takes a fixed string in its ctor.

 */

class MrSIDSimplePasswordDelegate : public MrSIDPasswordDelegate

{

public:

   /**

    * constructor

    * 

    * Create a password delegate, using the given string.

    *

    * @param password the password to use to unlock the image

    */

   MrSIDSimplePasswordDelegate(const char* password);

   /**

    * failure user notification

    *

    * This function just returns LT_STS_Failure.

    *

    * @return always LT_STS_Failure

    */

   LT_STATUS reportIncorrectPassword();

   /**

    * get the password

    *

    * This function does nothing, as the password is fixed (determined

    * by parameter to constructor).

    *

    * @return always LT_STS_Success

    */

   LT_STATUS getPassword();

private:

   // nope

   MrSIDSimplePasswordDelegate(const MrSIDSimplePasswordDelegate&);

   MrSIDSimplePasswordDelegate& operator=(const MrSIDSimplePasswordDelegate&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // MRSIDPASSWORDDELEGATE_H

/* $Id: MG3CompositeImageReader.h 3539 2006-01-09 12:23:20Z nacho $ */

/* //////////////////////////////////////////////////////////////////////////

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

////////////////////////////////////////////////////////////////////////// */

/* PUBLIC */

#ifndef MG3COMPOSITEIMAGEREADER_H

#define MG3COMPOSITEIMAGEREADER_H

// lt_lib_mrsid_mrsidReaders

#include "MrSIDImageReaderBase.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class MG3Container;

class LTIMosaicFilter;

class MG3SingleImageReader;

class MG2ImageReader;

class J2KImageReader;

/**

 * reader for MrSID/MG3 images

 *

 * This class supports reading MrSID/MG3 images.

 *

 * @note MrSID/MG2 images are not supported with this class.

 */

class MG3CompositeImageReader : public MrSIDImageReaderBase

{

public:

   /**

    * constructor

    *

    * Create an MG3 reader from the given file.

    *

    * The \a imageNumber array allows for control over

    * which tiles in the image should be opened to form

    * the composite (mosaic) image.  If NULL is passed,

    * all tiles will be used.

    *

    * To determine the tiles available in the image,

    * you can use the static getCompositeImageInfo()

    * member function.

    *

    * @param fileSpec      file containing MrSID image

    * @param imageNumber   array of image tile numbers

    * @param numImages     size of \a imageNumber array

    * @param useWorldFile  incorporate world file data when reading image

    * @param memoryUsage   control memory resource usage

    * @param streamUsage   control stream resource usage

    */

   MG3CompositeImageReader(const LTFileSpec& fileSpec,

                           const lt_uint32* imageNumber,

                           lt_uint32 numImages,

                           bool useWorldFile,

                           MrSIDMemoryUsage memoryUsage,

                           MrSIDStreamUsage streamUsage);

   /**

    * constructor

    *

    * Construct an MG3 image from a stream.  (See file-based

    * constructor for details.)

    *

    * @param stream           stream containing MrSID image (may not be NULL)

    * @param imageNumber      array of image tile numbers

    * @param numImages        size of \a imageNumber array

    * @param worldFileStream  stream containing world file data (may be NULL)

    * @param memoryUsage      control memory resource usage

    * @param streamUsage      control stream resource usage

    */

   MG3CompositeImageReader(LTIOStreamInf* stream,

                           const lt_uint32* imageNumber,

                           lt_uint32 numImages,

                           LTIOStreamInf* worldFileStream,

                           MrSIDMemoryUsage memoryUsage,

                           MrSIDStreamUsage streamUsage);

   MG3CompositeImageReader(MG3Container* container,

                           const lt_uint32* imageNumber,

                           lt_uint32 numImages,

                           LTIOStreamInf* worldFileStream,

                           MrSIDMemoryUsage memoryUsage,

                           MrSIDStreamUsage streamUsage);

   virtual ~MG3CompositeImageReader();

   LT_STATUS initialize();

   LT_STATUS setStripHeight(lt_uint32 stripHeight);

   lt_uint32 getStripHeight() const;

   lt_uint8 getNumLevels() const;

   bool isLocked() const;

   void getVersion(lt_uint8& major, lt_uint8& minor, lt_uint8& tweak, char& letter) const;

   /**

    * query if is optimizable

    *

    * Returns true if and only if the image can be further compressed.

    *

    * @return true, if and only if the image may be compressed

    */

   bool isOptimizable() const;

   /**

    * tile type queries

    *

    * These functions are used to determine whether any of the tiles

    * in the image are MG2 or JPEG 2000.

    */

   /*@{*/

   bool hasMG2Data() const;

   bool hasJP2Data() const;

   /*@}*/

   void setInterruptDelegate(LTIInterruptDelegate* delegate);

   lt_int64 getPhysicalFileSize() const;

   /**

    * file format type of image tile

    */

   enum CompositeImageType

   {

      COMPOSITETYPE_MG2 = 1,

      COMPOSITETYPE_MG3 = 2,

      COMPOSITETYPE_JP2 = 3

   };

   /**

    * structure representing tiled image

    */

   struct CompositeImageInfo

   {

      /** image tile number */

      lt_uint32 imageId;

      /** x-position of tile in the mosaic */

      double xPos;

      /** y-position of tile in the mosaic */

      double yPos;

      /** type of image tile */

      CompositeImageType imageType;

   };

   /**

    * query tile information

    *

    * This function is used to collect information about the tiles in the

    * image.

    *

    * The caller takes ownership of the returned \a tileInfo array.

    *

    * @param  tileInfo  array of tile information structures to be set

    * @param  numTiles  number of tiles

    * @return status code indicating success or failure

    */

   LT_STATUS getTileInfo(CompositeImageInfo *&tileInfo, lt_uint32 &numTiles) const;

   /**

    * query tile information

    *

    * This function is used to collect information about the tiles in

    * the image contained in the given file.

    *

    * The caller takes ownership of the returned \a info array.

    *

    * @param  fileSpec  name of image to query

    * @param  tileInfo  array of tile information structures to be set

    * @param  numTiles  number of tiles

    * @return status code indicating success or failure

    */

   static LT_STATUS getCompositeImageInfo(const LTFileSpec &fileSpec,

                                          CompositeImageInfo *&tileInfo,

                                          lt_uint32 &numTiles);

   /**

    * query tile information

    *

    * This function is used to collect information about the tiles in

    * the image contained in the given stream.

    *

    * The caller takes ownership of the returned \a info array.

    *

    * @param  stream    stream containing image to query

    * @param  tileInfo  array of tile information structures to be set

    * @param  numTiles  number of tiles

    * @return status code indicating success or failure

    */

   static LT_STATUS getCompositeImageInfo(LTIOStreamInf &stream,

                                          CompositeImageInfo *&tileInfo,

                                          lt_uint32 &numTiles);

   static LT_STATUS getCompositeImageInfo(const MG3Container &container,

                                          CompositeImageInfo *&tileInfo,

                                          lt_uint32 &numTiles);

//protected: // only used be MG3Optimizer

   bool getReaderScene(lt_uint32 imageIndex,

                       const LTIScene &scene,

                       LTIScene &readerScene) const;

protected:

   LT_STATUS decodeBegin(const LTIScene& scene);

   LT_STATUS decodeStrip(LTISceneBuffer& stripBuffer,

                         const LTIScene& stripScene);

   LT_STATUS decodeEnd();

   LT_STATUS init(void);

   virtual LT_STATUS createMG2Reader(lt_uint32 imageNumber,

                                       MG2ImageReader *&mg2Reader);

   virtual LT_STATUS createMG3Reader(lt_uint32 imageNumber,

                                       MG3SingleImageReader *&mg3Reader);

   virtual LT_STATUS createJP2Reader(lt_uint32 imageNumber,

                                       J2KImageReader *&jp2Reader);

   virtual LT_STATUS updateMemoryModel();

#ifndef DOXYGEN_EXCLUDE

   struct Data

   {

      ~Data(void);

      Data(const LTFileSpec *fileSpec,

           LTIOStreamInf *stream,

           MG3Container* container,

           lt_uint32 numImages,

           const lt_uint32* imageNumbers,

           LTIOStreamInf* worldFileStream);

      MG3Container* m_container;

      bool m_ownContainer;   

      lt_uint32 m_numImages;

      lt_uint32* m_imageNumbers;

      LTIImageReader** m_readers;

      LTIImageStage** m_images;

      CompositeImageType *m_tileType;

      LTIMosaicFilter* m_mosaic;

      LTFileSpec* m_fileSpec;

      LTIOStreamInf* m_stream;

      bool m_ownStream;

      LTIOStreamInf* m_worldFileStream;

      bool m_isLockedComposite;

      lt_uint8 m_numLevelsComposite;

      bool m_isOptimizableComposite;

      bool m_hasMG2Composite;

      bool m_hasJP2Composite;

   };

#endif

   Data *m_dat;

private:

   typedef MrSIDImageReaderBase Super;

   // nope

   MG3CompositeImageReader(const MG3CompositeImageReader&);

   MG3CompositeImageReader& operator=(const MG3CompositeImageReader&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // MG3COMPOSITEIMAGEREADER_H

/* $Id: MrSIDImageReaderBase.h 3539 2006-01-09 12:23:20Z nacho $ */

/* //////////////////////////////////////////////////////////////////////////

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

////////////////////////////////////////////////////////////////////////// */

/* PUBLIC */

#ifndef MRSIDIMAGEREADERBASE_H

#define MRSIDIMAGEREADERBASE_H

// lt_lib_mrsid_core

#include "lti_imageReader.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class LTFileSpec;

class LTIOStreamInf;

class MrSIDPasswordDelegate;

class MrSIDSimplePasswordDelegate;

/*

 * memory settings for creating MrSID decoders

 *

 * "Small", "medium", and "large" refer to how much memory the

 * decoder will use when opening the image and constructing certain

 * internal data structures and tables.  In general, decode

 * performance will increase if more memory can be used.

 */

enum MrSIDMemoryUsage

{

   MRSID_MEMORY_USAGE_INVALID    = 0,

   MRSID_MEMORY_USAGE_DEFAULT    = 1,

   MRSID_MEMORY_USAGE_SMALL      = 2,

   MRSID_MEMORY_USAGE_MEDIUM     = 3,

   MRSID_MEMORY_USAGE_LARGE      = 4

};

/*

 * stream settings for creating MrSID decoders

 *

 * Normally, the stream used by the decoder is

 * only opened when doing actual decode work, as resources like

 * file handles can be a scarce resource in some environments.  This

 * obviously incurs a performance penalty; the "KeepStreamOpen" modes

 * can be used to change the behaviour.

 */

enum MrSIDStreamUsage

{

   MRSID_STREAM_USAGE_INVALID    = 0,

   MRSID_STREAM_USAGE_KEEPOPEN   = 2,

   MRSID_STREAM_USAGE_KEEPCLOSED = 3,

   MRSID_STREAM_USAGE_DEFAULT    = MRSID_STREAM_USAGE_KEEPCLOSED

};

/**

 * base class for MrSID image readers

 *

 * All the MrSID image readers (MrSIDImageReader, MG3CompositeImageReader, etc)

 * inherit from this class.

 */

class MrSIDImageReaderBase : public LTIImageReader

{

public:

   /**

    * constructor

    *

    * Creates a MrSIDImageReaderBase object.

    *

    * @param  memoryUsage   the memory model to use

    * @param  streamUsage   the stream model to use

    * @param  useWorldFile  whether or not a world file is being used

    */

   MrSIDImageReaderBase(MrSIDMemoryUsage memoryUsage,

                        MrSIDStreamUsage streamUsage,

                        bool useWorldFile);

   virtual ~MrSIDImageReaderBase();

   virtual LT_STATUS initialize();

   /**

    * get number of resolution levels

    *

    * Returns the number of resolution levels supported by the image.

    * This value returned corresponds to the LTIImage::getMinMagnification()

    * function.

    *

    * @return the number of resolution levels in the MrSID image

    */

   virtual lt_uint8 getNumLevels() const =0;

   /**

    * image encryption query

    *

    * Returns true iff the image is password-protected.  If the image is

    * locked, the setPasswordDelegate() or setPassword() function must be

    * used to provide the decoder with information to decrypt the image

    * as decode requests are processed.

    *

    * @return true, if image is password-protected

    */

   virtual bool isLocked() const =0;

   /**

    * get MrSID image version

    *

    * Returns detailed version information for the MrSID image.  Typical

    * version numbers will be 1.0.1 for MG2 (the \a letter value is not

    * used) and 3.0.26.q for MG3.  Most developers need only consider the

    * \a major number, which will be either 2 or 3..

    *

    * See also getSidVersion().

    *

    * @param major  the major version number

    * @param minor  the minor version number

    * @param tweak  the revision number

    * @param letter  the revision build number (MG3 only)

    */

   virtual void getVersion(lt_uint8& major, lt_uint8& minor, lt_uint8& tweak, char& letter) const=0;

   /**

    * set password handler

    *

    * This function is used to set up a password delegate, which will be

    * automatically called form within the internal decoder logic to obtain

    * a text password, if one is needed for decoded the image.

    *

    * Alternatively, the more direct setPassword() function may be used.

    *

    * See the isLocked() function for more details.

    * 

    * @param  passwordDelegate  the delegate to be called

    */

   void setPasswordDelegate(MrSIDPasswordDelegate* passwordDelegate);

   /**

    * set password handler

    *

    * This function is set the password used by the decoder logic

    * to decode the image, if one is needed.

    *

    * The password must be set prior to performing any decode (read)

    * requests; for more flexibility, the setPasswordDelegate() function

    * may be used.

    *

    * See the isLocked() function for more details.

    * 

    * @param  password  the password for the image

    */

   void setPassword(const lt_utf8* password);

public:

   /**

    * get MrSID version information

    *

    * Returns version information for a specific MrSID image.  This is

    * a static function, which is passed a filename; the getVersion()

    * function operates on the image represented by this MrSIDImageReaderBase

    * image and returns more detailed information.

    *

    * The \a ver value returned will be 2 (for MrSID/MG2), 3 (for MrSID/MG3),

    * or 0 (if error).

    *

    * @param fileSpec  the file to get the version of

    * @param ver       the major version number

    * @return status code indicating success or failure

    */

   static LT_STATUS getSidVersion(const LTFileSpec& fileSpec, lt_uint8& ver);

   /**

    * MrSID version information

    *

    * Returns version information for a specific MrSID image.  This is

    * a static function, which is passed a stream; the getVersion()

    * function operates on the image represented by this MrSIDImageReaderBase

    * image and returns more detailed information.

    *

    * The \a ver value returned will be 2 (for MrSID/MG2), 3 (for MrSID/MG3),

    * or 0 (if error).

    *

    * @param stream  the file to get the version of

    * @param ver       the major version number

    * @return status code indicating success or failure

    */

   static LT_STATUS getSidVersion(LTIOStreamInf& stream, lt_uint8& ver);

protected:

   LT_STATUS setupDynamicRangeFromMetadata(bool& gotThem,

                                           double& min,

                                           double& max);

   static LT_STATUS setupClutFromMetadata(const LTIMetadataDatabase& metadata,

                                          LTIPixelLookupTable*& clut);

   static LT_STATUS setupDefaultPixelFromMetadata(LTIMetadataDatabase& metadata,

                                                  const LTIPixel& pixelProps,

                                                  LTIPixel*& backgroundPixel,

                                                  LTIPixel*& nodataPixel);

   LT_STATUS setupGeoInfoFromMetadata(bool &didSet);

   LT_STATUS setupGeoInfoFromWorldFile(const LTFileSpec *file,

                                       LTIOStreamInf *stream,

                                       bool &didSet);

   LT_STATUS updateGeoMetadata();

   MrSIDMemoryUsage m_memoryUsage;

   MrSIDStreamUsage m_streamUsage;

   bool m_useWorldFile;

private:

   typedef LTIImageReader Super;

   MrSIDPasswordDelegate* m_pwdDelegate;

   MrSIDSimplePasswordDelegate* m_localPwdDelegate;

   // nope

   MrSIDImageReaderBase(const MrSIDImageReaderBase&);

   MrSIDImageReaderBase& operator=(const MrSIDImageReaderBase&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // MRSIDIMAGEREADERBASE_H

/* $Id: lti_mrsidReadersStatus.h 3539 2006-01-09 12:23:20Z nacho $ */

/* //////////////////////////////////////////////////////////////////////////

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

////////////////////////////////////////////////////////////////////////// */

/* PUBLIC */

#ifndef LTI_MRSIDREADERSSTATUS_H

#define LTI_MRSIDREADERSSTATUS_H

#include "lt_base.h"

#define LTI_STS_MrSIDReaders_Base                           50600

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_Base, "lt_lib_mrsid_mrsidReaders base")

#define LTI_STS_MrSIDReaders_UnsupColorSpace                50601

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_UnsupColorSpace, "unsupported colorspace")

#define LTI_STS_MrSIDReaders_UnsupDataType                  50602

LT_STATUSSTRING_ADD(LTI_STS_Filters_UnsupDataType, "unsupported datatype")

#define LTI_STS_MrSIDReaders_InvalidMemoryModel             50603

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_InvalidMemoryModel, "invalid memory model")

#define LTI_STS_MrSIDReaders_InvalidMetadata                50604

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_InvalidMetadata, "invalid metadata")

#define LTI_STS_MrSIDReaders_MetadataReadError              50605

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_MetadataReadError, "error reading metadata")

#define LTI_STS_MrSIDReaders_InvalidStripHeight             50606

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_InvalidStripHeight, "invalid stripheight")

#define LTI_STS_MrSIDReaders_BadFileFormat                  50607

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_BadFileFormat, "invalid mrsid file format")

#define LTI_STS_MrSIDReaders_BadMG2letInit                  50608

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_BadMG2letInit, "mg2let init error")

#define LTI_STS_MrSIDReaders_BadMG3letInit                  50609

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_BadMG3letInit, "mg3let init error")

#define LTI_STS_MrSIDReaders_MG2Error                       50610

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_MG2Error, "error decoding MG2 file")

#define LTI_STS_MrSIDReaders_BadSidletFormat                50611

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_BadSidletFormat, "invalid sidlet message")

#define LTI_STS_MrSIDReaders_UnknownTileImageFormat         50612

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_UnknownTileImageFormat, "unknown tile image format")

#define LTI_STS_MrSIDReaders_CannotOpenFile                 50613

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_CannotOpenFile, "can't open file: %F")

#define LTI_STS_MrSIDReaders_Max                            50699

LT_STATUSSTRING_ADD(LTI_STS_MrSIDReaders_Max, "lt_lib_mrsid_mrsidReaders max")

#endif // LTI_MRSIDREADERSSTATUS_H

/* $Id: MrSIDImageReader.h 3539 2006-01-09 12:23:20Z nacho $ */

/* //////////////////////////////////////////////////////////////////////////

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

////////////////////////////////////////////////////////////////////////// */

/* PUBLIC */

#ifndef MRSIDIMAGEREADER_H

#define MRSIDIMAGEREADER_H

// lt_lib_mrsid_mrsidReader

#include "MrSIDImageReaderBase.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class LTFileSpec;

class LTIOStreamInf;

class MG2ImageReader;

class MG3SingleImageReader;

class MG3CompositeImageReader;

class MG3Container;

/**

 * reader for MrSID images (MG2 and MG3)

 *

 * This class supports reading MrSID/MG2 and MrSID/MG3 images, including

 * composite MG3 images.

 */

class MrSIDImageReader : public MrSIDImageReaderBase

{

public:

   /**

    * constructor

    *

    * Construct a MrSID reader from the given file.

    *

    * @param  fileSpec      file containing MrSID image

    * @param  useWorldFile  incorporate world file data when reading image

    * @param  memoryUsage   control memory resource usage

    * @param  streamUsage   control stream resource usage

    */

   MrSIDImageReader(const LTFileSpec& fileSpec,

                    bool useWorldFile = false,

                    MrSIDMemoryUsage memoryUsage=MRSID_MEMORY_USAGE_DEFAULT,

                    MrSIDStreamUsage streamUsage=MRSID_STREAM_USAGE_DEFAULT);

   /**

    * constructor

    *

    * Construct a MrSID reader from the given stream.

    *

    * @param  stream        stream containing MrSID image (may not be NULL)

    * @param  worldFileStream  stream containing world file data (may be NULL)

    * @param  memoryUsage   control memory resource usage

    * @param  streamUsage   control stream resource usage

    */

   MrSIDImageReader(LTIOStreamInf* stream,

                    LTIOStreamInf* worldFileStream = 0,

                    MrSIDMemoryUsage memoryUsage=MRSID_MEMORY_USAGE_DEFAULT,

                    MrSIDStreamUsage streamUsage=MRSID_STREAM_USAGE_DEFAULT);

   virtual ~MrSIDImageReader();

   virtual LT_STATUS initialize();

   /**

    * number of levels

    * 

    * Return the number of resolution levels in the image.  (This is similar to querying

    * getMinMagnificaton(), but expressed as an integer.)

    *

    * @return the number of levels in the image

    */

   virtual lt_uint8 getNumLevels() const;

   /**

    * query for image encryption

    * 

    * Return true if the image is password-protected.

    *

    * @return true, if and only if the image is encrypted

    */

   virtual bool isLocked() const;

   /**

    * query for file format version

    * 

    * This functions returns detailed version information for the

    * MG2 or MG3 file.

    *

    * @param major the major version number

    * @param minor the minor version number

    * @param tweak the reversion number

    * @param letter the format letter (MG3 only)

    */

   virtual void getVersion(lt_uint8& major, lt_uint8& minor, lt_uint8& tweak, char& letter) const;

   virtual lt_int64 getPhysicalFileSize() const;

   virtual LT_STATUS setStripHeight(lt_uint32 stripHeight);

   virtual lt_uint32 getStripHeight() const;

   // not for the faint of heart

   MG2ImageReader* getMG2Reader() const;

   MG3SingleImageReader* getMG3SingleReader() const;

   MG3CompositeImageReader* getMG3CompositeReader() const;

   virtual LT_STATUS projectPointAtMag(double upperLeft,

                                       double mag,

                                       double& newUpperLeft) const;

   virtual LT_STATUS projectDimAtMag(double dim,

                                     double mag,

                                     double& newDim) const;

   virtual LT_STATUS getDimsAtMag(double mag,

                                  lt_uint32& width,

                                  lt_uint32& height) const;

   void setProgressDelegate(LTIProgressDelegate* delegate);

   void setInterruptDelegate(LTIInterruptDelegate* delegate);

protected:

   virtual LT_STATUS decodeBegin(const LTIScene& scene);

   virtual LT_STATUS decodeStrip(LTISceneBuffer& stripBuffer,

                                 const LTIScene& stripScene);

   virtual LT_STATUS decodeEnd();

   virtual LT_STATUS createMG2Reader(void);

   virtual LT_STATUS createMG3Reader(void);

#ifndef DOXYGEN_EXCLUDE

   struct Data

   {

      ~Data(void);

      Data(const LTFileSpec *fileSpec,

           LTIOStreamInf *stream,

           MG3Container* container,

           LTIOStreamInf* worldFileStream);

      LTIOStreamInf* m_stream;

      LTFileSpec* m_fileSpec;

      bool m_ownStream;

      LTIOStreamInf* m_worldFileStream;

      bool m_worldFileStreamOwned;

      MG3Container* m_container;

      MrSIDImageReaderBase *m_mrsidReader;

      MG3CompositeImageReader* m_mg3CompositeReader;

      MG3SingleImageReader* m_mg3SingleReader;

      MG2ImageReader* m_mg2Reader;

   };

#endif

   Data *m_dat;

private:

   typedef MrSIDImageReaderBase Super;

   // nope

   MrSIDImageReader(const MrSIDImageReader&);

   MrSIDImageReader& operator=(const MrSIDImageReader&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // MRSIDIMAGEREADER_H

/* $Id: lti_colorTransformer.h 3539 2006-01-09 12:23:20Z nacho $ */

/* //////////////////////////////////////////////////////////////////////////

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

////////////////////////////////////////////////////////////////////////// */

/* PUBLIC */

#ifndef LTI_COLORTRANSFORMER_H

#define LTI_COLORTRANSFORMER_H

// lt_lib_mrsid_core

#include "lti_imageFilter.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class LTIReusableBSQBuffer;

/**

 * change the colorspace of the image

 *

 * This class changes the colorspace of the image.

 *

 * The supported color transforms are:

 * \li from RGB to CMYK, GRAYSCALE, or YIQ

 * \li from GRAYSCALE to RGB

 * \li from CMYK to RGB, RGBK, or YIQK

 * \li from YIQ to RGB

 * \li from YIQK to CMYK

 */

class LTIColorTransformer : public LTIImageFilter

{

public:

   /**

    * constructor

    *

    * Creates an image stage with the given colorspace.  The sample values

    * will undergo the requisite color transform function to map from the

    * input colorspace to the output colorspace.

    *

    * @note The value of \a dstNumBands image is set according to the

    * \a dstColorSpace, as is in the constructor for the LTIPixel class.

    *

    * @param  sourceImage    the base image

    * @param  dstColorSpace  the colorspace of the new image

    * @param  dstNumBands    the number of bands in the new image

    * @param  takeOwnership  set to true to have the filter delete the \a sourceImage

    */

   LTIColorTransformer(LTIImageStage* sourceImage,

                       LTIColorSpace dstColorSpace,

                       lt_uint16 dstNumBands,

                       bool takeOwnership);

   virtual ~LTIColorTransformer();

   virtual LT_STATUS initialize();

protected:

   LT_STATUS decodeBegin(const LTIScene& scene);

   LT_STATUS decodeEnd();

   LT_STATUS decodeStrip(LTISceneBuffer& stripBuffer, const LTIScene& stripScene);

protected: // these are only protected for the temporary LTIColorTransformerMultiband class

   LTIPixel* remapPixel(const LTIPixel& pixel);

   const LTIColorSpace m_dstColorSpace;

   const lt_uint16 m_dstNumBands;

   LTIColorSpace m_srcColorSpace;

   lt_uint16 m_srcNumBands;

   bool m_isIdentity;

   LTIReusableBSQBuffer* m_buffer;

private:

   // nope

   LTIColorTransformer(const LTIColorTransformer&);

   LTIColorTransformer& operator=(const LTIColorTransformer&);

};

/**

 * Extends LTIColorTransformer to change the colorspace of the image and

 * also remap the bands.

 *

 * This class is typically used for mapping multispectral images to known

 * (and often displayable) colorspaces.  For example, a 6-banded

 * multispectral image might be changed to an RGB colorspace using only bands

 * 0, 2, and 3.

 *

 * Note that the allowed remapping of bands is different than in the

 * LTISampleMapTransformer class.

 *

 * @note This class is likely to change in a future release.

 */

class LTIColorTransformerMultiband : public LTIColorTransformer

{

public:

   /**

   * Constructor.

   *

   * Creates an image stage with the given colorspace using the given

   * remapping of bands.

   *

   * The \a dstBandMap parameter is an array of band numbers.  The array

   * elements must be within the range of the number of bands in the input

   * colorspace, and the number of elements in the array must be equal to

   * \a dstNumBands.  A given band may be specified more than once.

   *

   * @note The value of \a dstNumBands image is set according to the

   * \a dstColorSpace, as is in the constructor for the LTIPixel class.

   *

   * @param  sourceImage    the base image

   * @param  dstColorSpace  the colorspace of the new image

   * @param  dstBandMap     the array of bands to map to the new colorspace

   * @param  dstNumBands    the number of bands in the new image

   * @param  takeOwnership  set to true to have the filter delete the \a sourceImage

   */

   LTIColorTransformerMultiband(LTIImageStage* sourceImage,

                                LTIColorSpace dstColorSpace,

                                lt_uint16* dstBandMap,

                                lt_uint16 dstNumBands,

                                bool takeOwnership);

   virtual ~LTIColorTransformerMultiband();

   virtual LT_STATUS initialize();

   LT_STATUS decodeStrip(LTISceneBuffer &stripBuffer, const LTIScene &stripScene);

private:

   typedef LTIColorTransformer Super;

   const lt_uint16 *m_dstBandMapCtor;

   lt_uint16 *m_dstBandMap;

   LTIColorTransformerMultiband(const LTIColorTransformerMultiband&);

   LTIColorTransformerMultiband& operator=(const LTIColorTransformerMultiband&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // LTI_COLORTRANSFORMER_H

/* $Id: lti_mosaicFilter.h 3539 2006-01-09 12:23:20Z nacho $ */

/* //////////////////////////////////////////////////////////////////////////

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

////////////////////////////////////////////////////////////////////////// */

/* PUBLIC */

#ifndef LTI_MOSAICFILTER_H

#define LTI_MOSAICFILTER_H

// lt_lib_mrsid_core

#include "lti_imageFilter.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class LTIEmbeddedImage;

class LTIStaticZoomFilter;

/**

 * create a single mosaicked image from a set of images

 *

 * This class create a single mosaicked image from a set of images.

 *

 * The set of input images are all assumed to be in the same coordinate

 * space.  In general, all the images must have the same resolution;

 * differences that are within a small epsilon or exactly a power of two

 * are optionally allowed.

 */

class LTIMosaicFilter : public LTIImageFilter

{

public:

   /**

    * constructor

    *

    * Creates an image stage which is a mosaic of the set of input images.

    *

    * The "res correct" feature allows images with slightly different

    * resolutions to be mosaicked.  This allows for proper handling of

    * situations where one image has a resolution of 0.5000 and another has a

    * resolution of 0.4999.

    *

    * The "multires" feature allows images whose resolutions which differ by

    * a power of two to be mosaicked together.  (The LTIStaticZoomFilter class

    * is used to implement this feature.)

    *

    * NoData and background pixel settings are honored by the mosaic process.

    *

    * @param  images           array of base images to be mosaicked together

    * @param  numImages        number of images in the \a images array

    * @param  backgroundPixel  color of the background pixel for the new image stage

    * @param  useResCorrect    allow images to have slightly different resolutions

    * @param  useMultires      allow images whose resolutions differ by a power of two

    * @param  takeOwnership    set to true to have the filter delete the \a sourceImage

    */

   LTIMosaicFilter(LTIImageStage** images,

                   lt_uint32 numImages,

                   const LTIPixel* backgroundPixel,

                   bool useResCorrect,

                   bool useMultires,

                   bool takeOwnership);

   virtual ~LTIMosaicFilter();

   virtual LT_STATUS initialize();

   // must be called AFTER initialize()

   LT_STATUS setUsingFuzzyNoData(bool fuzzy);

   bool getUsingFuzzyNoData(void) const;

   lt_int64 getPhysicalFileSize() const;

   lt_uint32 getStripHeight() const;

   LT_STATUS setStripHeight(lt_uint32 stripHeight);

   lt_int64 getEncodingCost(const LTIScene& scene) const;

   bool isSelective() const;

   LT_STATUS projectPointAtMag(double upperLeft,

                               double mag,

                               double& newUpperLeft) const;

   LT_STATUS projectDimAtMag(double dim,

                             double mag,

                             double& newDim) const;

   LT_STATUS getDimsAtMag(double mag,

                          lt_uint32& width,

                          lt_uint32& height) const;

   bool getReaderScene(const LTIScene &decodeScene, LTIScene &readerScene) const;

   bool getReaderScene(lt_uint32 child,

                       const LTIScene &decodeScene,

                       LTIScene &readerScene) const;

   /**

    * Check if a set of images can be mosaicked together.  The parameters to

    * this function mirror those of the constructor: this function will

    * return LT_STS_Success if and only if the images' resolutions are such

    * that a mosaic can be produced.

    *

    * @param  images           array of base images to be mosaicked together

    * @param  numImages        number of images in the \a images array

    * @param  useResCorrect    allow images to have slightly different resolutions

    * @param  useMultires      allow images whose resolutions differ by a power of two

    * @return status code indicating success or failure

    */

   static LT_STATUS checkResolutionConformance(LTIImageStage** images,

                                               lt_uint32 numImages,

                                               bool useResCorrect,

                                               bool useMultires);

protected:

   virtual LT_STATUS decodeBegin(const LTIScene& scene);

   virtual LT_STATUS decodeStrip(LTISceneBuffer& stripBuffer, const LTIScene& stripScene);

   virtual LT_STATUS decodeEnd();

   //LTIImageStage* getUnderlying(lt_uint32 i) const;

private:

   typedef LTIImageFilter Super;

   LT_STATUS checkCompat() const;

   LT_STATUS checkCompatResCorrect() const;

   LT_STATUS checkCompatResCorrectForImage(lt_uint32 i) const;

   LT_STATUS fixMultires();

   LTIImageStage** m_imagesUnderlying;

   LTIImageStage** m_images;

   lt_uint32 m_numImages;

   bool m_useResCorrect;

   bool m_useMultires;

   bool m_takeOwnership;

   LTIPixel* m_userBackgroundPixel;

   // nope

   LTIMosaicFilter(const LTIMosaicFilter&);

   LTIMosaicFilter& operator=(const LTIMosaicFilter&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // LTI_MOSAICFILTER_H

/* $Id: lti_sampleMapTransformer.h 3539 2006-01-09 12:23:20Z nacho $ */

/* //////////////////////////////////////////////////////////////////////////

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

////////////////////////////////////////////////////////////////////////// */

/* PUBLIC */

#ifndef LTI_SAMPLEMAPTRANSFORMER_H

#define LTI_SAMPLEMAPTRANSFORMER_H

// lt_lib_mrsid_core

#include "lti_imageFilter.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class LTIReusableBSQBuffer;

/**

 * remaps the color bands of an image

 *

 * This class provides the ability to remap the color bands of an image, e.g.

 * from R-G-B to B-G-R.  Only proper permutations are supported; that is, the

 * number of bands may not be changed, and all bands must appear exactly once

 * in the remapped image.

 *

 * @note This class is \b deprecated.  A better way to remap the bands is to

 * manipulate the band pointers contained in the LTISceneBuffer object at the

 * end of the pipeline.

 */

class LTISampleMapTransformer : public LTIImageFilter

{

public:

   /**

    * constructor

    *

    * Creates an image stage with the bands of the source image reordered,

    * e.g. to change an image from RGB to BGR format.

    *

    * The length of the permutation array is equal to the number of bands in

    * the image and the elements must be a proper permutation of the band

    * numbers.  That is, the default map "0,1,2" may be set to "2,1,0" or

    * "1,2,0" but not "0,1,1" or "2".

    *

    * @param  sourceImage   the base image

    * @param  dstSampleMap  the band permutation array (if NULL, the default

    *                       map of "0,1,2,..." will be used)

    * @param takeOwnership  set to true to have the filter delete the \a sourceImage

    */

   LTISampleMapTransformer(LTIImageStage* sourceImage,

                           const lt_uint16* dstSampleMap,