source/dng_stream.h - platform/external/dng_sdk - Git at Google

 /*****************************************************************************/
 // Copyright 2006-2007 Adobe Systems Incorporated
 // All Rights Reserved.
 //
 // NOTICE:  Adobe permits you to use, modify, and distribute this file in
 // accordance with the terms of the Adobe license agreement accompanying it.
 /*****************************************************************************/

 /* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_stream.h#2 $ */
 /* $DateTime: 2012/06/01 07:28:57 $ */
 /* $Change: 832715 $ */
 /* $Author: tknoll $ */

 /** Data stream abstraction for serializing and deserializing sequences of
  *  basic types and RAW image data.
  */

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

 #ifndef __dng_stream__
 #define __dng_stream__

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

 #include "dng_classes.h"
 #include "dng_types.h"
 #include "dng_memory.h"
 #include "dng_rational.h"
 #include "dng_utils.h"

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

 // Constants for invalid offset in streams.

 const uint64 kDNGStreamInvalidOffset = (uint64) (int64) -1;

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

 /// Base stream abstraction. Has support for going between stream and pointer
 /// abstraction.

 class dng_stream
 	{

 	public:

 		enum
 			{

 			kSmallBufferSize =  4 * 1024,
 			kBigBufferSize   = 64 * 1024,

 			kDefaultBufferSize = kSmallBufferSize

 			};

 	private:

 		bool fSwapBytes;

 		bool fHaveLength;

 		uint64 fLength;

 		const uint64 fOffsetInOriginalFile;

 		uint64 fPosition;

 		dng_memory_data fMemBlock;

 		uint8 *fBuffer;

 		uint32 fBufferSize;

 		uint64 fBufferStart;
 		uint64 fBufferEnd;
 		uint64 fBufferLimit;

 		bool fBufferDirty;

 		dng_abort_sniffer *fSniffer;

 	protected:

 		dng_stream (dng_abort_sniffer *sniffer = NULL,
 					uint32 bufferSize = kDefaultBufferSize,
 					uint64 offsetInOriginalFile = kDNGStreamInvalidOffset);

 		virtual uint64 DoGetLength ();

 		virtual void DoRead (void *data,
 							 uint32 count,
 							 uint64 offset);

 		virtual void DoSetLength (uint64 length);

 		virtual void DoWrite (const void *data,
 							  uint32 count,
 							  uint64 offset);

 	public:

 		/// Construct a stream with initial data.
 		/// \param data Pointer to initial contents of stream.
 		/// \param count Number of bytes data is valid for.
 		/// \param offsetInOriginalFile If data came from a file originally,
 		/// offset can be saved here for later use.

 		dng_stream (const void *data,
 					uint32 count,
 					uint64 offsetInOriginalFile = kDNGStreamInvalidOffset);

 		virtual ~dng_stream ();

 		/// Getter for whether stream is swapping byte order on input/output.
 		/// \retval If true, data will be swapped on input/output.

 		bool SwapBytes () const
 			{
 			return fSwapBytes;
 			}

 		/// Setter for whether stream is swapping byte order on input/output.
 		/// \param swapBytes If true, stream will swap byte order on input or
 		/// output for future reads/writes.

 		void SetSwapBytes (bool swapBytes)
 			{
 			fSwapBytes = swapBytes;
 			}

 		/// Getter for whether data in stream is big endian.
 		/// \retval If true, data in stream is big endian.

 		bool BigEndian () const;

 		/// Setter for whether data in stream is big endian.
 		/// \param bigEndian If true, data in stream is big endian.

 		void SetBigEndian (bool bigEndian = true);

 		/// Getter for whether data in stream is big endian.
 		/// \retval If true, data in stream is big endian.

 		bool LittleEndian () const
 			{
 			return !BigEndian ();
 			}

 		/// Setter for whether data in stream is big endian.
 		/// \param littleEndian If true, data in stream is big endian.

 		void SetLittleEndian (bool littleEndian = true)
 			{
 			SetBigEndian (!littleEndian);
 			}

 		/// Returns the size of the buffer used by the stream.

 		uint32 BufferSize () const
 			{
 			return fBufferSize;
 			}

 		/// Getter for length of data in stream.
 		/// \retval Length of readable data in stream.

 		uint64 Length ()
 			{

 			if (!fHaveLength)
 				{

 				fLength = DoGetLength ();

 				fHaveLength = true;

 				}

 			return fLength;

 			}

 		/// Getter for current offset in stream.
 		/// \retval current offset from start of stream.

 		uint64 Position () const
 			{
 			return fPosition;
 			}

 		/// Getter for current position in original file, taking into account
 		/// OffsetInOriginalFile stream data was taken from.
 		/// \retval kInvalidOffset if no offset in original file is set, sum
 		/// of offset in original file and current position otherwise.

 		uint64 PositionInOriginalFile () const;

 		/// Getter for offset in original file.
 		/// \retval kInvalidOffset if no offset in original file is set,
 		/// offset in original file otherwise.

 		uint64 OffsetInOriginalFile () const;

 		/// Return pointer to stream contents if the stream is entirely
 		/// available as a single memory block, NULL otherwise.

 		const void * Data () const;

 		/// Return the entire stream as a single memory block.
 		/// This works for all streams, but requires copying the data to a new buffer.
 		/// \param allocator Allocator used to allocate memory.

 		dng_memory_block * AsMemoryBlock (dng_memory_allocator &allocator);

 		/// Seek to a new position in stream for reading.

 		void SetReadPosition (uint64 offset);

 		/// Skip forward in stream.
 		/// \param delta Number of bytes to skip forward.

 		void Skip (uint64 delta)
 			{
 			SetReadPosition (Position () + delta);
 			}

 		/// Get data from stream. Exception is thrown and no data is read if
 		/// insufficient data available in stream.
 		/// \param data Buffer to put data into. Must be valid for count bytes.
 		/// \param count Bytes of data to read.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		void Get (void *data, uint32 count);

 		/// Seek to a new position in stream for writing.

 		void SetWritePosition (uint64 offset);

 		/// Force any stored data in stream to be written to underlying storage.

 		void Flush ();

 		/// Set length of available data.
 		/// \param length Number of bytes of avialble data in stream.

 		void SetLength (uint64 length);

 		/// Write data to stream.
 		/// \param data Buffer of data to write to stream.
 		/// \param count Bytes of in data.

 		void Put (const void *data, uint32 count);

 		/// Get an unsigned 8-bit integer from stream and advance read position.
 		/// \retval One unsigned 8-bit integer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		uint8 Get_uint8 ()
 			{

 			// Fast check to see if in buffer

 			if (fPosition >= fBufferStart && fPosition < fBufferEnd)
 				{

 				return fBuffer [fPosition++ - fBufferStart];

 				}

 			// Not in buffer, let main routine do the work.

 			uint8 x;

 			Get (&x, 1);

 			return x;

 			}

 		/// Put an unsigned 8-bit integer to stream and advance write position.
 		/// \param x One unsigned 8-bit integer.

 		void Put_uint8 (uint8 x)
 			{

 			if (fBufferDirty               &&
 			    fPosition  >= fBufferStart &&
 				fPosition  <= fBufferEnd   &&
 				fPosition  <  fBufferLimit)
 				{

 				fBuffer [fPosition - fBufferStart] = x;

 				fPosition++;

 				if (fBufferEnd < fPosition)
 					fBufferEnd = fPosition;

 				fLength = Max_uint64 (Length (), fPosition);

 				}

 			else
 				{

 				Put (&x, 1);

 				}

 			}

 		/// Get an unsigned 16-bit integer from stream and advance read position.
 		/// Byte swap if byte swapping is turned on.
 		/// \retval One unsigned 16-bit integer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		uint16 Get_uint16 ();

 		/// Put an unsigned 16-bit integer to stream and advance write position.
 		/// Byte swap if byte swapping is turned on.
 		/// \param x One unsigned 16-bit integer.

 		void Put_uint16 (uint16 x);

 		/// Get an unsigned 32-bit integer from stream and advance read position.
 		/// Byte swap if byte swapping is turned on.
 		/// \retval One unsigned 32-bit integer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		uint32 Get_uint32 ();

 		/// Put an unsigned 32-bit integer to stream and advance write position.
 		/// Byte swap if byte swapping is turned on.
 		/// \param x One unsigned 32-bit integer.

 		void Put_uint32 (uint32 x);

 		/// Get an unsigned 64-bit integer from stream and advance read position.
 		/// Byte swap if byte swapping is turned on.
 		/// \retval One unsigned 64-bit integer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		uint64 Get_uint64 ();

 		/// Put an unsigned 64-bit integer to stream and advance write position.
 		/// Byte swap if byte swapping is turned on.
 		/// \param x One unsigned 64-bit integer.

 		void Put_uint64 (uint64 x);

 		/// Get one 8-bit integer from stream and advance read position.
 		/// \retval One 8-bit integer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		int8 Get_int8 ()
 			{
 			return (int8) Get_uint8 ();
 			}

 		/// Put one 8-bit integer to stream and advance write position.
 		/// \param x One  8-bit integer.

 		void Put_int8 (int8 x)
 			{
 			Put_uint8 ((uint8) x);
 			}

 		/// Get one 16-bit integer from stream and advance read position.
 		/// Byte swap if byte swapping is turned on.
 		/// \retval One 16-bit integer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		int16 Get_int16 ()
 			{
 			return (int16) Get_uint16 ();
 			}

 		/// Put one 16-bit integer to stream and advance write position.
 		/// Byte swap if byte swapping is turned on.
 		/// \param x One 16-bit integer.

 		void Put_int16 (int16 x)
 			{
 			Put_uint16 ((uint16) x);
 			}

 		/// Get one 32-bit integer from stream and advance read position.
 		/// Byte swap if byte swapping is turned on.
 		/// \retval One 32-bit integer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		int32 Get_int32 ()
 			{
 			return (int32) Get_uint32 ();
 			}

 		/// Put one 32-bit integer to stream and advance write position.
 		/// Byte swap if byte swapping is turned on.
 		/// \param x One 32-bit integer.

 		void Put_int32 (int32 x)
 			{
 			Put_uint32 ((uint32) x);
 			}

 		/// Get one 64-bit integer from stream and advance read position.
 		/// Byte swap if byte swapping is turned on.
 		/// \retval One 64-bit integer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		int64 Get_int64 ()
 			{
 			return (int64) Get_uint64 ();
 			}

 		/// Put one 64-bit integer to stream and advance write position.
 		/// Byte swap if byte swapping is turned on.
 		/// \param x One 64-bit integer.

 		void Put_int64 (int64 x)
 			{
 			Put_uint64 ((uint64) x);
 			}

 		/// Get one 32-bit IEEE floating-point number from stream and advance
 		/// read position. Byte swap if byte swapping is turned on.
 		/// \retval One 32-bit IEEE floating-point number.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		real32 Get_real32 ();

 		/// Put one 32-bit IEEE floating-point number to stream and advance write
 		/// position. Byte swap if byte swapping is turned on.
 		/// \param x One 32-bit IEEE floating-point number.

 		void Put_real32 (real32 x);

 		/// Get one 64-bit IEEE floating-point number from stream and advance
 		/// read position. Byte swap if byte swapping is turned on.
 		/// \retval One 64-bit IEEE floating-point number .
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		real64 Get_real64 ();

 		/// Put one 64-bit IEEE floating-point number to stream and advance write
 		/// position. Byte swap if byte swapping is turned on.
 		/// \param x One64-bit IEEE floating-point number.

 		void Put_real64 (real64 x);

 		/// Get an 8-bit character string from stream and advance read position.
 		/// Routine always reads until a NUL character (8-bits of zero) is read.
 		/// (That is, only maxLength bytes will be returned in buffer, but the
 		/// stream is always advanced until a NUL is read or EOF is reached.)
 		/// \param data Buffer in which string is returned.
 		/// \param maxLength Maximum number of bytes to place in buffer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if stream runs out before NUL is seen.

 		void Get_CString (char *data,
 						  uint32 maxLength);

 		/// Get a 16-bit character string from stream and advance read position.
 		/// 16-bit characters are truncated to 8-bits.
 		/// Routine always reads until a NUL character (16-bits of zero) is read.
 		/// (That is, only maxLength bytes will be returned in buffer, but the
 		/// stream is always advanced until a NUL is read or EOF is reached.)
 		/// \param data Buffer to place string in.
 		/// \param maxLength Maximum number of bytes to place in buffer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if stream runs out before NUL is seen.

 		void Get_UString (char *data,
 						  uint32 maxLength);

 		/// Writes the specified number of zero bytes to stream.
 		/// \param count Number of zero bytes to write.

 		void PutZeros (uint64 count);

 		/// Writes zeros to align the stream position to a multiple of 2.

 		void PadAlign2 ();

 		/// Writes zeros to align the stream position to a multiple of 4.

 		void PadAlign4 ();

 		/// Get a value of size indicated by tag type from stream and advance
 		/// read position. Byte swap if byte swapping is turned on and tag type
 		/// is larger than a byte. Value is returned as an unsigned 32-bit integer.
 		/// \param tagType Tag type of data stored in stream.
 		/// \retval One unsigned 32-bit integer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		uint32 TagValue_uint32 (uint32 tagType);

 		/// Get a value of size indicated by tag type from stream and advance read
 		/// position. Byte swap if byte swapping is turned on and tag type is larger
 		/// than a byte. Value is returned as a 32-bit integer.
 		/// \param tagType Tag type of data stored in stream.
 		/// \retval One 32-bit integer.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		int32 TagValue_int32 (uint32 tagType);

 		/// Get a value of size indicated by tag type from stream and advance read
 		/// position. Byte swap if byte swapping is turned on and tag type is larger
 		/// than a byte. Value is returned as a dng_urational.
 		/// \param tagType Tag type of data stored in stream.
 		/// \retval One dng_urational.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		dng_urational TagValue_urational (uint32 tagType);

 		/// Get a value of size indicated by tag type from stream and advance read
 		/// position. Byte swap if byte swapping is turned on and tag type is larger
 		/// than a byte. Value is returned as a dng_srational.
 		/// \param tagType Tag type of data stored in stream.
 		/// \retval One dng_srational.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		dng_srational TagValue_srational (uint32 tagType);

 		/// Get a value of size indicated by tag type from stream and advance read
 		/// position. Byte swap if byte swapping is turned on and tag type is larger
 		/// than a byte. Value is returned as a 64-bit IEEE floating-point number.
 		/// \param tagType Tag type of data stored in stream.
 		/// \retval One 64-bit IEEE floating-point number.
 		/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
 		/// if not enough data in stream.

 		real64 TagValue_real64 (uint32 tagType);

 		/// Getter for sniffer associated with stream.
 		/// \retval The sniffer for this stream.

 		dng_abort_sniffer * Sniffer () const
 			{
 			return fSniffer;
 			}

 		/// Putter for sniffer associated with stream.
 		/// \param sniffer The new sniffer to use (or NULL for none).

 		void SetSniffer (dng_abort_sniffer *sniffer)
 			{
 			fSniffer = sniffer;
 			}

 		/// Copy a specified number of bytes to a target stream.
 		/// \param dstStream The target stream.
 		/// \param count The number of bytes to copy.

 		virtual void CopyToStream (dng_stream &dstStream,
 								   uint64 count);

 		/// Makes the target stream a copy of this stream.
 		/// \param dstStream The target stream.

 		void DuplicateStream (dng_stream &dstStream);

 	private:

 		// Hidden copy constructor and assignment operator.

 		dng_stream (const dng_stream &stream);

 		dng_stream & operator= (const dng_stream &stream);

 	};

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

 class TempBigEndian
 	{

 	private:

 		dng_stream & fStream;

 		bool fOldSwap;

 	public:

 		TempBigEndian (dng_stream &stream,
 					   bool bigEndian = true);

 		virtual ~TempBigEndian ();

 	};

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

 class TempLittleEndian: public TempBigEndian
 	{

 	public:

 		TempLittleEndian (dng_stream &stream,
 						  bool littleEndian = true)

 			:	TempBigEndian (stream, !littleEndian)

 			{
 			}

 		virtual ~TempLittleEndian ()
 			{
 			}

 	};

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

 class TempStreamSniffer
 	{

 	private:

 		dng_stream & fStream;

 		dng_abort_sniffer *fOldSniffer;

 	public:

 		TempStreamSniffer (dng_stream &stream,
 					       dng_abort_sniffer *sniffer);

 		virtual ~TempStreamSniffer ();

 	private:

 		// Hidden copy constructor and assignment operator.

 		TempStreamSniffer (const TempStreamSniffer &temp);

 		TempStreamSniffer & operator= (const TempStreamSniffer &temp);

 	};

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

 class PreserveStreamReadPosition
 	{

 	private:

 		dng_stream & fStream;

 		uint64 fPosition;

 	public:

 		PreserveStreamReadPosition (dng_stream &stream)

 			:	fStream	  (stream)
 			,	fPosition (stream.Position ())

 			{
 			}

 		~PreserveStreamReadPosition ()
 			{
 			fStream.SetReadPosition (fPosition);
 			}

 	private:

 		// Hidden copy constructor and assignment operator.

 		PreserveStreamReadPosition (const PreserveStreamReadPosition &rhs);

 		PreserveStreamReadPosition & operator= (const PreserveStreamReadPosition &rhs);

 	};

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

 #endif

 /*****************************************************************************/
	/*****************************************************************************/
	// Copyright 2006-2007 Adobe Systems Incorporated
	// All Rights Reserved.
	//
	// NOTICE: Adobe permits you to use, modify, and distribute this file in
	// accordance with the terms of the Adobe license agreement accompanying it.
	/*****************************************************************************/

	/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_stream.h#2 $ */
	/* $DateTime: 2012/06/01 07:28:57 $ */
	/* $Change: 832715 $ */
	/* $Author: tknoll $ */

	/** Data stream abstraction for serializing and deserializing sequences of
	* basic types and RAW image data.
	*/

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

	#ifndef __dng_stream__
	#define __dng_stream__

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

	#include "dng_classes.h"
	#include "dng_types.h"
	#include "dng_memory.h"
	#include "dng_rational.h"
	#include "dng_utils.h"

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

	// Constants for invalid offset in streams.

	const uint64 kDNGStreamInvalidOffset = (uint64) (int64) -1;

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

	/// Base stream abstraction. Has support for going between stream and pointer
	/// abstraction.

	class dng_stream
	{

	public:

	enum
	{

	kSmallBufferSize = 4 * 1024,
	kBigBufferSize = 64 * 1024,

	kDefaultBufferSize = kSmallBufferSize

	};

	private:

	bool fSwapBytes;

	bool fHaveLength;

	uint64 fLength;

	const uint64 fOffsetInOriginalFile;

	uint64 fPosition;

	dng_memory_data fMemBlock;

	uint8 *fBuffer;

	uint32 fBufferSize;

	uint64 fBufferStart;
	uint64 fBufferEnd;
	uint64 fBufferLimit;

	bool fBufferDirty;

	dng_abort_sniffer *fSniffer;

	protected:

	dng_stream (dng_abort_sniffer *sniffer = NULL,
	uint32 bufferSize = kDefaultBufferSize,
	uint64 offsetInOriginalFile = kDNGStreamInvalidOffset);

	virtual uint64 DoGetLength ();

	virtual void DoRead (void *data,
	uint32 count,
	uint64 offset);

	virtual void DoSetLength (uint64 length);

	virtual void DoWrite (const void *data,
	uint32 count,
	uint64 offset);

	public:

	/// Construct a stream with initial data.
	/// \param data Pointer to initial contents of stream.
	/// \param count Number of bytes data is valid for.
	/// \param offsetInOriginalFile If data came from a file originally,
	/// offset can be saved here for later use.

	dng_stream (const void *data,
	uint32 count,
	uint64 offsetInOriginalFile = kDNGStreamInvalidOffset);

	virtual ~dng_stream ();

	/// Getter for whether stream is swapping byte order on input/output.
	/// \retval If true, data will be swapped on input/output.

	bool SwapBytes () const
	{
	return fSwapBytes;
	}

	/// Setter for whether stream is swapping byte order on input/output.
	/// \param swapBytes If true, stream will swap byte order on input or
	/// output for future reads/writes.

	void SetSwapBytes (bool swapBytes)
	{
	fSwapBytes = swapBytes;
	}

	/// Getter for whether data in stream is big endian.
	/// \retval If true, data in stream is big endian.

	bool BigEndian () const;

	/// Setter for whether data in stream is big endian.
	/// \param bigEndian If true, data in stream is big endian.

	void SetBigEndian (bool bigEndian = true);

	/// Getter for whether data in stream is big endian.
	/// \retval If true, data in stream is big endian.

	bool LittleEndian () const
	{
	return !BigEndian ();
	}

	/// Setter for whether data in stream is big endian.
	/// \param littleEndian If true, data in stream is big endian.

	void SetLittleEndian (bool littleEndian = true)
	{
	SetBigEndian (!littleEndian);
	}

	/// Returns the size of the buffer used by the stream.

	uint32 BufferSize () const
	{
	return fBufferSize;
	}

	/// Getter for length of data in stream.
	/// \retval Length of readable data in stream.

	uint64 Length ()
	{

	if (!fHaveLength)
	{

	fLength = DoGetLength ();

	fHaveLength = true;

	}

	return fLength;

	}

	/// Getter for current offset in stream.
	/// \retval current offset from start of stream.

	uint64 Position () const
	{
	return fPosition;
	}

	/// Getter for current position in original file, taking into account
	/// OffsetInOriginalFile stream data was taken from.
	/// \retval kInvalidOffset if no offset in original file is set, sum
	/// of offset in original file and current position otherwise.

	uint64 PositionInOriginalFile () const;

	/// Getter for offset in original file.
	/// \retval kInvalidOffset if no offset in original file is set,
	/// offset in original file otherwise.

	uint64 OffsetInOriginalFile () const;

	/// Return pointer to stream contents if the stream is entirely
	/// available as a single memory block, NULL otherwise.

	const void * Data () const;

	/// Return the entire stream as a single memory block.
	/// This works for all streams, but requires copying the data to a new buffer.
	/// \param allocator Allocator used to allocate memory.

	dng_memory_block * AsMemoryBlock (dng_memory_allocator &allocator);

	/// Seek to a new position in stream for reading.

	void SetReadPosition (uint64 offset);

	/// Skip forward in stream.
	/// \param delta Number of bytes to skip forward.

	void Skip (uint64 delta)
	{
	SetReadPosition (Position () + delta);
	}

	/// Get data from stream. Exception is thrown and no data is read if
	/// insufficient data available in stream.
	/// \param data Buffer to put data into. Must be valid for count bytes.
	/// \param count Bytes of data to read.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	void Get (void *data, uint32 count);

	/// Seek to a new position in stream for writing.

	void SetWritePosition (uint64 offset);

	/// Force any stored data in stream to be written to underlying storage.

	void Flush ();

	/// Set length of available data.
	/// \param length Number of bytes of avialble data in stream.

	void SetLength (uint64 length);

	/// Write data to stream.
	/// \param data Buffer of data to write to stream.
	/// \param count Bytes of in data.

	void Put (const void *data, uint32 count);

	/// Get an unsigned 8-bit integer from stream and advance read position.
	/// \retval One unsigned 8-bit integer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	uint8 Get_uint8 ()
	{

	// Fast check to see if in buffer

	if (fPosition >= fBufferStart && fPosition < fBufferEnd)
	{

	return fBuffer [fPosition++ - fBufferStart];

	}

	// Not in buffer, let main routine do the work.

	uint8 x;

	Get (&x, 1);

	return x;

	}

	/// Put an unsigned 8-bit integer to stream and advance write position.
	/// \param x One unsigned 8-bit integer.

	void Put_uint8 (uint8 x)
	{

	if (fBufferDirty &&
	fPosition >= fBufferStart &&
	fPosition <= fBufferEnd &&
	fPosition < fBufferLimit)
	{

	fBuffer [fPosition - fBufferStart] = x;

	fPosition++;

	if (fBufferEnd < fPosition)
	fBufferEnd = fPosition;

	fLength = Max_uint64 (Length (), fPosition);

	}

	else
	{

	Put (&x, 1);

	}

	}

	/// Get an unsigned 16-bit integer from stream and advance read position.
	/// Byte swap if byte swapping is turned on.
	/// \retval One unsigned 16-bit integer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	uint16 Get_uint16 ();

	/// Put an unsigned 16-bit integer to stream and advance write position.
	/// Byte swap if byte swapping is turned on.
	/// \param x One unsigned 16-bit integer.

	void Put_uint16 (uint16 x);

	/// Get an unsigned 32-bit integer from stream and advance read position.
	/// Byte swap if byte swapping is turned on.
	/// \retval One unsigned 32-bit integer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	uint32 Get_uint32 ();

	/// Put an unsigned 32-bit integer to stream and advance write position.
	/// Byte swap if byte swapping is turned on.
	/// \param x One unsigned 32-bit integer.

	void Put_uint32 (uint32 x);

	/// Get an unsigned 64-bit integer from stream and advance read position.
	/// Byte swap if byte swapping is turned on.
	/// \retval One unsigned 64-bit integer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	uint64 Get_uint64 ();

	/// Put an unsigned 64-bit integer to stream and advance write position.
	/// Byte swap if byte swapping is turned on.
	/// \param x One unsigned 64-bit integer.

	void Put_uint64 (uint64 x);

	/// Get one 8-bit integer from stream and advance read position.
	/// \retval One 8-bit integer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	int8 Get_int8 ()
	{
	return (int8) Get_uint8 ();
	}

	/// Put one 8-bit integer to stream and advance write position.
	/// \param x One 8-bit integer.

	void Put_int8 (int8 x)
	{
	Put_uint8 ((uint8) x);
	}

	/// Get one 16-bit integer from stream and advance read position.
	/// Byte swap if byte swapping is turned on.
	/// \retval One 16-bit integer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	int16 Get_int16 ()
	{
	return (int16) Get_uint16 ();
	}

	/// Put one 16-bit integer to stream and advance write position.
	/// Byte swap if byte swapping is turned on.
	/// \param x One 16-bit integer.

	void Put_int16 (int16 x)
	{
	Put_uint16 ((uint16) x);
	}

	/// Get one 32-bit integer from stream and advance read position.
	/// Byte swap if byte swapping is turned on.
	/// \retval One 32-bit integer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	int32 Get_int32 ()
	{
	return (int32) Get_uint32 ();
	}

	/// Put one 32-bit integer to stream and advance write position.
	/// Byte swap if byte swapping is turned on.
	/// \param x One 32-bit integer.

	void Put_int32 (int32 x)
	{
	Put_uint32 ((uint32) x);
	}

	/// Get one 64-bit integer from stream and advance read position.
	/// Byte swap if byte swapping is turned on.
	/// \retval One 64-bit integer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	int64 Get_int64 ()
	{
	return (int64) Get_uint64 ();
	}

	/// Put one 64-bit integer to stream and advance write position.
	/// Byte swap if byte swapping is turned on.
	/// \param x One 64-bit integer.

	void Put_int64 (int64 x)
	{
	Put_uint64 ((uint64) x);
	}

	/// Get one 32-bit IEEE floating-point number from stream and advance
	/// read position. Byte swap if byte swapping is turned on.
	/// \retval One 32-bit IEEE floating-point number.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	real32 Get_real32 ();

	/// Put one 32-bit IEEE floating-point number to stream and advance write
	/// position. Byte swap if byte swapping is turned on.
	/// \param x One 32-bit IEEE floating-point number.

	void Put_real32 (real32 x);

	/// Get one 64-bit IEEE floating-point number from stream and advance
	/// read position. Byte swap if byte swapping is turned on.
	/// \retval One 64-bit IEEE floating-point number .
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	real64 Get_real64 ();

	/// Put one 64-bit IEEE floating-point number to stream and advance write
	/// position. Byte swap if byte swapping is turned on.
	/// \param x One64-bit IEEE floating-point number.

	void Put_real64 (real64 x);

	/// Get an 8-bit character string from stream and advance read position.
	/// Routine always reads until a NUL character (8-bits of zero) is read.
	/// (That is, only maxLength bytes will be returned in buffer, but the
	/// stream is always advanced until a NUL is read or EOF is reached.)
	/// \param data Buffer in which string is returned.
	/// \param maxLength Maximum number of bytes to place in buffer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if stream runs out before NUL is seen.

	void Get_CString (char *data,
	uint32 maxLength);

	/// Get a 16-bit character string from stream and advance read position.
	/// 16-bit characters are truncated to 8-bits.
	/// Routine always reads until a NUL character (16-bits of zero) is read.
	/// (That is, only maxLength bytes will be returned in buffer, but the
	/// stream is always advanced until a NUL is read or EOF is reached.)
	/// \param data Buffer to place string in.
	/// \param maxLength Maximum number of bytes to place in buffer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if stream runs out before NUL is seen.

	void Get_UString (char *data,
	uint32 maxLength);

	/// Writes the specified number of zero bytes to stream.
	/// \param count Number of zero bytes to write.

	void PutZeros (uint64 count);

	/// Writes zeros to align the stream position to a multiple of 2.

	void PadAlign2 ();

	/// Writes zeros to align the stream position to a multiple of 4.

	void PadAlign4 ();

	/// Get a value of size indicated by tag type from stream and advance
	/// read position. Byte swap if byte swapping is turned on and tag type
	/// is larger than a byte. Value is returned as an unsigned 32-bit integer.
	/// \param tagType Tag type of data stored in stream.
	/// \retval One unsigned 32-bit integer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	uint32 TagValue_uint32 (uint32 tagType);

	/// Get a value of size indicated by tag type from stream and advance read
	/// position. Byte swap if byte swapping is turned on and tag type is larger
	/// than a byte. Value is returned as a 32-bit integer.
	/// \param tagType Tag type of data stored in stream.
	/// \retval One 32-bit integer.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	int32 TagValue_int32 (uint32 tagType);

	/// Get a value of size indicated by tag type from stream and advance read
	/// position. Byte swap if byte swapping is turned on and tag type is larger
	/// than a byte. Value is returned as a dng_urational.
	/// \param tagType Tag type of data stored in stream.
	/// \retval One dng_urational.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	dng_urational TagValue_urational (uint32 tagType);

	/// Get a value of size indicated by tag type from stream and advance read
	/// position. Byte swap if byte swapping is turned on and tag type is larger
	/// than a byte. Value is returned as a dng_srational.
	/// \param tagType Tag type of data stored in stream.
	/// \retval One dng_srational.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	dng_srational TagValue_srational (uint32 tagType);

	/// Get a value of size indicated by tag type from stream and advance read
	/// position. Byte swap if byte swapping is turned on and tag type is larger
	/// than a byte. Value is returned as a 64-bit IEEE floating-point number.
	/// \param tagType Tag type of data stored in stream.
	/// \retval One 64-bit IEEE floating-point number.
	/// \exception dng_exception with fErrorCode equal to dng_error_end_of_file
	/// if not enough data in stream.

	real64 TagValue_real64 (uint32 tagType);

	/// Getter for sniffer associated with stream.
	/// \retval The sniffer for this stream.

	dng_abort_sniffer * Sniffer () const
	{
	return fSniffer;
	}

	/// Putter for sniffer associated with stream.
	/// \param sniffer The new sniffer to use (or NULL for none).

	void SetSniffer (dng_abort_sniffer *sniffer)
	{
	fSniffer = sniffer;
	}

	/// Copy a specified number of bytes to a target stream.
	/// \param dstStream The target stream.
	/// \param count The number of bytes to copy.

	virtual void CopyToStream (dng_stream &dstStream,
	uint64 count);

	/// Makes the target stream a copy of this stream.
	/// \param dstStream The target stream.

	void DuplicateStream (dng_stream &dstStream);

	private:

	// Hidden copy constructor and assignment operator.

	dng_stream (const dng_stream &stream);

	dng_stream & operator= (const dng_stream &stream);

	};

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

	class TempBigEndian
	{

	private:

	dng_stream & fStream;

	bool fOldSwap;

	public:

	TempBigEndian (dng_stream &stream,
	bool bigEndian = true);

	virtual ~TempBigEndian ();

	};

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

	class TempLittleEndian: public TempBigEndian
	{

	public:

	TempLittleEndian (dng_stream &stream,
	bool littleEndian = true)

	: TempBigEndian (stream, !littleEndian)

	{
	}

	virtual ~TempLittleEndian ()
	{
	}

	};

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

	class TempStreamSniffer
	{

	private:

	dng_stream & fStream;

	dng_abort_sniffer *fOldSniffer;

	public:

	TempStreamSniffer (dng_stream &stream,
	dng_abort_sniffer *sniffer);

	virtual ~TempStreamSniffer ();

	private:

	// Hidden copy constructor and assignment operator.

	TempStreamSniffer (const TempStreamSniffer &temp);

	TempStreamSniffer & operator= (const TempStreamSniffer &temp);

	};

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

	class PreserveStreamReadPosition
	{

	private:

	dng_stream & fStream;

	uint64 fPosition;

	public:

	PreserveStreamReadPosition (dng_stream &stream)

	: fStream (stream)
	, fPosition (stream.Position ())

	{
	}

	~PreserveStreamReadPosition ()
	{
	fStream.SetReadPosition (fPosition);
	}

	private:

	// Hidden copy constructor and assignment operator.

	PreserveStreamReadPosition (const PreserveStreamReadPosition &rhs);

	PreserveStreamReadPosition & operator= (const PreserveStreamReadPosition &rhs);

	};

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

	#endif

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