/*****************************************************************************/
// Copyright 2006-2023 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.
/*****************************************************************************/

#include "dng_utils.h"

#include "dng_area_task.h"
#include "dng_assertions.h"
#include "dng_bottlenecks.h"
#include "dng_flags.h"
#include "dng_globals.h"
#include "dng_host.h"
#include "dng_image.h"
#include "dng_image_writer.h"
#include "dng_memory_stream.h"
#include "dng_mutex.h"
#include "dng_point.h"
#include "dng_rect.h"
#include "dng_simd_type.h"
#include "dng_tag_codes.h"
#include "dng_tag_values.h"
#include "dng_tile_iterator.h"

#if qMacOS
#include <CoreServices/CoreServices.h>
#endif

#if qiPhone || qMacOS
// these provide timers
#include <mach/mach.h>
#include <mach/mach_time.h>
#endif

#if qiPhone || qLinux
#include <signal.h> // for raise
#endif

#if qWinOS
#include <windows.h>
#else
#include <sys/time.h>
#include <stdarg.h> // for va_start/va_end
#endif

#if defined(__EMSCRIPTEN__)
#include "emscripten.h"
#endif

#include <atomic>

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

#if qDNGDebug

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

#if qMacOS
	#if qARM
		#define DNG_DEBUG_BREAK do { } while (0)
	#else
		#define DNG_DEBUG_BREAK __asm__ volatile ("int3")
	#endif
#elif qiPhone
	#if qiPhoneSimulator
		// simulator is either on Intel or arm64
		#if qARM
			#define DNG_DEBUG_BREAK do { } while (0)
		#else
			#define DNG_DEBUG_BREAK __asm__ volatile ("int3")
		#endif
	#else
		// You'll be one level deeper in __kill. Works on Linux, Android too.
		#define DNG_DEBUG_BREAK raise(SIGTRAP)
	#endif
#elif qWinOS
	// DebugBreak has to be emulated on WinRT
	#define DNG_DEBUG_BREAK DebugBreak()  
#elif qAndroid
	#define DNG_DEBUG_BREAK raise(SIGTRAP)
#elif qLinux
	#define DNG_DEBUG_BREAK raise(SIGTRAP)
#else
	#define DNG_DEBUG_BREAK
#endif

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

#endif	// qDNGDebug

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

#if qWinOS

void dng_outputdebugstring (const char *s,
							const char *nl)
	{

	static const bool sDebuggerPresent (IsDebuggerPresent () != 0);

	if (sDebuggerPresent)
		{
		OutputDebugStringA (s);
		if (nl && nl [0])
			{
			OutputDebugStringA (nl);
			}
		}

	}

#endif

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

#if defined(__EMSCRIPTEN__)

void dng_emscripten_log (int emLogType,
						 const char *s)
	{
	
	#if qDNGDebug
	emLogType |= EM_LOG_CONSOLE;
	#endif

	emscripten_log (emLogType,"%s", s);
	
	}

#endif

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

void dng_show_message (const char *s)
	{
	// only append a newline if there isn't already one
	const char* nl = "\n";
	if (s[0] && (s[strlen(s)-1] == '\n'))
		nl = "";
		
	#if qDNGPrintMessages
	
	// display the message
	if (gPrintAsserts)
		fprintf (stderr, "%s%s", s, nl);
		
	#elif qiPhone || qAndroid || qLinux || qWeb
	
	if (gPrintAsserts)
		fprintf (stderr, "%s%s", s, nl);

	#if qDNGDebug
	
	// iOS doesn't print a message to the console like DebugStr and MessageBox do, so we have to do both
	// You'll have to advance the program counter manually past this statement
	if (gBreakOnAsserts)
		DNG_DEBUG_BREAK;
	
	#endif	// qDNGDebug
	
	#elif qMacOS
	
	if (gBreakOnAsserts)
		{
		// truncate the to 255 chars
		char ss [256];
	
		uint32 len = (uint32) strlen (s);
		if (len > 255)
			len = 255;
		strncpy (&(ss [1]), s, len );
		ss [0] = (unsigned char) len;
	
		DebugStr ((unsigned char *) ss);
		}
	 else if (gPrintAsserts)
		{
		// For macOS have non-breaking assert emit to stdout
		// rather than stderr so that message will appear
		// in the Xcode console window.
		//fprintf(stderr, "%s%s", s, nl);
		fprintf (stdout, "%s%s", s, nl);
		}
	
	#elif qWinOS
	
	// display a dialog
	// This is not thread safe.	 Multiple message boxes can be launched.
	// Should also be launched in its own thread so main msg queue isn't thrown off.
	if (gBreakOnAsserts)
		{
		MessageBoxA (NULL, (LPSTR) s, NULL, MB_OK);
		}
	else if (gPrintAsserts)
		{
		fprintf (stderr, "%s%s", s, nl);

		// Emit assert message to MSVS Output window when debugging.
		dng_outputdebugstring (s, nl);
		}

	#endif

	}

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

void dng_show_message_f (const char *fmt, ... )
	{
	
	char buffer [2048];
	
	va_list ap;
	va_start (ap, fmt);

	vsnprintf (buffer, sizeof (buffer), fmt, ap);
	
	va_end (ap);
	
	dng_show_message (buffer);
	
	}

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

uint32 ComputeBufferSize (uint32 pixelType, 
						  const dng_point &tileSize,
						  uint32 numPlanes, 
						  PaddingType paddingType)
	{

	// Convert tile size to uint32.

	if (tileSize.h < 0 || tileSize.v < 0)
		{
		ThrowMemoryFull ("Negative tile size");
		}

	const uint32 tileSizeH = static_cast<uint32> (tileSize.h);
	const uint32 tileSizeV = static_cast<uint32> (tileSize.v);
	
	const uint32 pixelSize = TagTypeSize (pixelType);
	
	// Add padding to width if necessary.

	uint32 paddedWidth = tileSizeH;

	if (paddingType == padSIMDBytes)
		{

		if (!RoundUpForPixelSize (paddedWidth, 
								  pixelSize, 
								  &paddedWidth))
			{
			ThrowOverflow ("Arithmetic overflow computing buffer size");
			}

		}
	
	// Compute buffer size.

	uint32 bufferSize;

	if (!SafeUint32Mult (paddedWidth, tileSizeV, &bufferSize) ||
		!SafeUint32Mult (bufferSize,  pixelSize, &bufferSize) ||
		!SafeUint32Mult (bufferSize,  numPlanes, &bufferSize))
		{
		ThrowOverflow ("Arithmetic overflow computing buffer size");
		}
	
	return bufferSize;

	}

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

real64 TickTimeInSeconds ()
	{
	
	#if qWinOS
	
	// One might think it prudent to cache the frequency here, however
	// low-power CPU modes can, and do, change the value returned.
	// Thus the frequencey needs to be retrieved each time.
	
	// Note that the frequency changing can cause the return
	// result to jump backwards, which is why the TickCountInSeconds
	// (below) also exists.
		
	// Just plug in laptop when doing timings to minimize this.
	//	QPC/QPH is a slow call compared to rtdsc.
	//	but QPC/QPF is not tied to speed step, it's the northbridge timer.
	//	caching the invFrequency also avoids a costly divide
		
	static real64 freqMultiplier = 0.0;

	if (freqMultiplier == 0.0)
		{

		LARGE_INTEGER freq;

		QueryPerformanceFrequency (&freq);

		freqMultiplier = 1.0 / (real64) freq.QuadPart;

		}

	LARGE_INTEGER cycles;

	QueryPerformanceCounter (&cycles);

	return (real64) cycles.QuadPart * freqMultiplier;

	#elif qiPhone || qMacOS
	
	// cache frequency of high-perf timer
	static real64 freqMultiplier = 0.0;
	if (freqMultiplier == 0.0)
		{
			
		mach_timebase_info_data_t freq; 
		mach_timebase_info(&freq);
		
		// converts from nanos to micros
		//	numer = 125, denom = 3 * 1000
		freqMultiplier = ((real64)freq.numer / (real64)freq.denom) * 1.0e-9;
		
		}
	
	return mach_absolute_time() * freqMultiplier;
		
	#elif qAndroid || qLinux || qWeb

	//this is a fast timer to nanos
	struct timespec now;
	clock_gettime(CLOCK_MONOTONIC, &now);
	return now.tv_sec + (real64)now.tv_nsec * 1.0e-9;

	#else

	// Perhaps a better call exists. (e.g. avoid adjtime effects)

	struct timeval tv;
	
	gettimeofday (&tv, NULL);

	return tv.tv_sec + (real64)tv.tv_usec * 1.0e-6;
	
	#endif

	}

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

real64 TickCountInSeconds ()
	{
		
	return TickTimeInSeconds ();
	
	}

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

static std::atomic_int sTimerLevel (0);

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

void DNGIncrementTimerLevel ()
	{
	
	// This isn't thread coherent, multiple threads can create/destroy cr_timer
	//	 causing the tabbing to be invalid.	 Imagecore disables this.
	
	if (!gImagecore)
		{
		
		sTimerLevel++;
		
		}
		
	}

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

int32 DNGDecrementTimerLevel ()
	{

	if (gImagecore)
		{
		
		return 0;
		
		}
		
	else
		{
		
		return (int32) (--sTimerLevel);
		
		}
		
	}

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

dng_timer::dng_timer (const char *message)

	:	fMessage   (message				)
	,	fStartTime (TickTimeInSeconds ())
	
	{

	DNGIncrementTimerLevel ();
	
	}

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

dng_timer::~dng_timer ()
	{
	
	uint32 level = Pin_int32 (0, DNGDecrementTimerLevel (), 10);
	
	if (!gDNGShowTimers)
		return;

	real64 totalTime = TickTimeInSeconds () - fStartTime;
	
	#if defined(qCRLogging) && qCRLogging && defined(cr_logi)
		
	if (gImagecore)
		{
		// Imagecore force includes cr_log and overrides DNG to go to its logging under a mutex.
		// don't use indenting or fprintf to stderr, want these buffered
		cr_logi("timer", "%s: %0.3f sec\n", fMessage, totalTime);
		return;
		}
		
	#endif
		
	fprintf (stderr, "%*s%s: %0.3f sec\n", level*2, "", fMessage, totalTime);
	
	}

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

real64 MaxSquaredDistancePointToRect (const dng_point_real64 &point,
									  const dng_rect_real64 &rect)
	{
	
	real64 distSqr = DistanceSquared (point, 
									  rect.TL ());

	distSqr = Max_real64 (distSqr,
						  DistanceSquared (point, 
										   rect.BL ()));

	distSqr = Max_real64 (distSqr,
						  DistanceSquared (point, 
										   rect.BR ()));

	distSqr = Max_real64 (distSqr,
						  DistanceSquared (point, 
										   rect.TR ()));

	return distSqr;
	
	}

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

real64 MaxDistancePointToRect (const dng_point_real64 &point,
							   const dng_rect_real64 &rect)
	{

	return sqrt (MaxSquaredDistancePointToRect (point, 
												rect));

	}

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

dng_dither::dng_dither ()

	:	fNoiseBuffer ()

	{
	
	const uint32 kSeed = 1;

	fNoiseBuffer.Allocate (kRNGSize2D * sizeof (uint16));

	uint16 *buffer = fNoiseBuffer.Buffer_uint16 ();
		
	uint32 seed = kSeed;

	for (uint32 i = 0; i < kRNGSize2D; i++)
		{
		
		// The correct math for 16 to 8-bit dither would be:
		//
		// y = (x * 255 + r) / 65535;  (0 <= r <= 65534)
		//
		// The bottlnecks are using a faster approximation of
		// this math (using a power of two for the division):
		//
		// y = (x * 255 + r) / 65536;  (255 <= r <= 65535)
		//
		// To insure that all exact 8 bit values in 16 bit space
		// round trip exactly to the same 8-bit, we need to limit
		// r values to the range 255 to 65535.
		//
		// This results in the dither effect being slightly
		// imperfect, but correct round-tripping of 8-bit values
		// is far more important.
		
		uint16 value;
		
		do
			{
			
			seed = DNG_Random (seed);
			
			value = (uint16) seed;
			
			}
		while (value < 255);

		buffer [i] = value;

		}
	
	}

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

const dng_dither & dng_dither::Get ()
	{
	
	static dng_dither dither;
	
	return dither;
	
	}

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

void HistogramArea (dng_host & /* host */,
					const dng_image &image,
					const dng_rect &area,
					uint32 *hist,
					uint32 maxValue,
					uint32 plane)
	{
	
	DNG_ASSERT (image.PixelType () == ttShort, "Unsupported pixel type");
	
	DoZeroBytes (hist, (maxValue + 1) * (uint32) sizeof (uint32));
	
	dng_rect tile;
	
	dng_tile_iterator iter (image, area);
	
	while (iter.GetOneTile (tile))
		{
		
		dng_const_tile_buffer buffer (image, tile);
		
		const void *sPtr = buffer.ConstPixel (tile.t,
											  tile.l,
											  plane);
		
		uint32 count0 = 1;
		uint32 count1 = tile.H ();
		uint32 count2 = tile.W ();
		
		int32 step0 = 0;
		int32 step1 = buffer.fRowStep;
		int32 step2 = buffer.fColStep;
		
		OptimizeOrder (sPtr,
					   buffer.fPixelSize,
					   count0,
					   count1,
					   count2,
					   step0,
					   step1,
					   step2);
					   
		DNG_ASSERT (count0 == 1, "OptimizeOrder logic error");
		
		const uint16 *s1 = (const uint16 *) sPtr;
				
		for (uint32 row = 0; row < count1; row++)
			{
			
			if (maxValue == 0x0FFFF && step2 == 1)
				{
				
				for (uint32 col = 0; col < count2; col++)
					{
					
					uint32 x = s1 [col];
					
					hist [x] ++;
					
					}
					
				}
				
			else
				{
			
				const uint16 *s2 = s1;
			
				for (uint32 col = 0; col < count2; col++)
					{
					
					uint32 x = s2 [0];
					
					if (x <= maxValue)
						{
					
						hist [x] ++;
						
						}
					
					s2 += step2;
					
					}
					
				}
				
			s1 += step1;
			
			}
		
		}
		
	}
		
/*****************************************************************************/

template <SIMDType simd>
class dng_limit_float_depth_task: public dng_area_task
	{
	
	private:
	
		const dng_image &fSrcImage;
		
		dng_image &fDstImage;
		
		uint32 fBitDepth;
		
		real32 fScale;
			
	public:
	
		dng_limit_float_depth_task (const dng_image &srcImage,
									dng_image &dstImage,
									uint32 bitDepth,
									real32 scale);
							 
		virtual dng_rect RepeatingTile1 () const
			{
			return fSrcImage.RepeatingTile ();
			}
			
		virtual dng_rect RepeatingTile2 () const
			{
			return fDstImage.RepeatingTile ();
			}
							 
		virtual void Process (uint32 threadIndex,
							  const dng_rect &tile,
							  dng_abort_sniffer *sniffer);
								  
	};

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

template <SIMDType simd>
dng_limit_float_depth_task<simd>::dng_limit_float_depth_task
	(const dng_image &srcImage,
	 dng_image &dstImage,
	 uint32 bitDepth,
	 real32 scale)

	:	dng_area_task ("dng_limit_float_depth_task")
										
	,	fSrcImage (srcImage)
	,	fDstImage (dstImage)
	,	fBitDepth (bitDepth)
	,	fScale	  (scale)
	
	{
	
	}

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

template <SIMDType simd>

#ifdef __INTEL_LLVM_COMPILER
__attribute__((SET_CPU_FEATURE(simd)))
#endif // __INTEL_LLVM_COMPILER

void dng_limit_float_depth_task<simd>::Process (uint32 /* threadIndex */,
												const dng_rect &tile,
												dng_abort_sniffer * /* sniffer */)
	{

	INTEL_COMPILER_NEEDED_NOTE


#ifdef __INTEL_COMPILER
		SET_CPU_FEATURE(simd);
#endif // __INTEL_COMPILER


	dng_const_tile_buffer srcBuffer (fSrcImage, tile);
	dng_dirty_tile_buffer dstBuffer (fDstImage, tile);
	
	uint32 count0 = tile.H ();
	uint32 count1 = tile.W ();
	uint32 count2 = fDstImage.Planes ();
	
	int32 sStep0 = srcBuffer.fRowStep;
	int32 sStep1 = srcBuffer.fColStep;
	int32 sStep2 = srcBuffer.fPlaneStep;
	
	int32 dStep0 = dstBuffer.fRowStep;
	int32 dStep1 = dstBuffer.fColStep;
	int32 dStep2 = dstBuffer.fPlaneStep;

	const void *sPtr = srcBuffer.ConstPixel (tile.t,
											 tile.l,
											 0);
											 
		  void *dPtr = dstBuffer.DirtyPixel (tile.t,
											 tile.l,
											 0);

	OptimizeOrder (sPtr,
				   dPtr,
				   srcBuffer.fPixelSize,
				   dstBuffer.fPixelSize,
				   count0,
				   count1,
				   count2,
				   sStep0,
				   sStep1,
				   sStep2,
				   dStep0,
				   dStep1,
				   dStep2);
				   
	const real32 *sPtr0 = (const real32 *) sPtr;
		  real32 *dPtr0 = (		 real32 *) dPtr;
		  
	real32 scale = fScale;
		  
	bool limit16 = (fBitDepth == 16);
	bool limit24 = (fBitDepth == 24);
				   
	for (uint32 index0 = 0; index0 < count0; index0++)
		{
		
		const real32 *sPtr1 = sPtr0;
			  real32 *dPtr1 = dPtr0;
			  
		for (uint32 index1 = 0; index1 < count1; index1++)
			{
			
			// If the scale is a NOP, and the data is packed solid, we can just do memory
			// copy.
			
			if (scale == 1.0f && sStep2 == 1 && dStep2 == 1)
				{
				
				if (dPtr1 != sPtr1)			// srcImage != dstImage
					{
				
					memcpy (dPtr1, sPtr1, count2 * (uint32) sizeof (real32));
					
					}
				
				}
				
			else
				{
			
				const real32 *sPtr2 = sPtr1;
					  real32 *dPtr2 = dPtr1;
				INTEL_PRAGMA_SIMD_ASSERT_VECLEN_FLOAT(simd)
				for (uint32 index2 = 0; index2 < count2; index2++)
					{
					
					real32 x = sPtr2 [0];
					
					x *= scale;
					
					dPtr2 [0] = x;
					
					sPtr2 += sStep2;
					dPtr2 += dStep2;
					
					}
					
				}
				
			// The data is now in the destination buffer.
				
			if (limit16)
				{

				//start by using intrinsic __m256__mm256_cvtph_ps_(__m128i_a)
				//once the intrinsic is written, merge this branch with previous one

				uint32 *dPtr2 = (uint32 *) dPtr1;

				INTEL_PRAGMA_SIMD_ASSERT_VECLEN_INT32(simd)

				for (uint32 index2 = 0; index2 < count2; index2++)
					{
					
					uint32 x = dPtr2 [0];
					
					uint16 y = DNG_FloatToHalf (x);
					
					x = DNG_HalfToFloat (y);
											
					dPtr2 [0] = x;
					
					dPtr2 += dStep2;
					
					}
					
				}
				
			else if (limit24)
				{
			
				uint32 *dPtr2 = (uint32 *) dPtr1;
					  
				for (uint32 index2 = 0; index2 < count2; index2++)
					{
					
					uint32 x = dPtr2 [0];
											
					uint8 temp [3];
					
					DNG_FloatToFP24 (x, temp);
					
					x = DNG_FP24ToFloat (temp);
					
					dPtr2 [0] = x;
					
					dPtr2 += dStep2;
					
					}
					
				}
			  
			sPtr1 += sStep1;
			dPtr1 += dStep1;
			
			}
				   
		sPtr0 += sStep0;
		dPtr0 += dStep0;
		
		}
					
	}

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

template <SIMDType simd>
void LimitFloatBitDepth (dng_host &host,
						 const dng_image &srcImage,
						 dng_image &dstImage,
						 uint32 bitDepth,
						 real32 scale)
	{
	
	DNG_ASSERT (srcImage.PixelType () == ttFloat, "Floating point image expected");
	DNG_ASSERT (dstImage.PixelType () == ttFloat, "Floating point image expected");
	
	dng_limit_float_depth_task<simd> task (srcImage,
										   dstImage,
										   bitDepth,
										   scale);
									 
	host.PerformAreaTask (task, dstImage.Bounds ());
	
	}

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

template
void LimitFloatBitDepth<Scalar> (dng_host &host,
								 const dng_image &srcImage,
								 dng_image &dstImage,
								 uint32 bitDepth,
								 real32 scale);

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

#if qDNGIntelCompiler

template
void LimitFloatBitDepth<AVX2> (dng_host &host,
							   const dng_image &srcImage,
							   dng_image &dstImage,
							   uint32 bitDepth,
							   real32 scale);

#endif	// qDNGIntelCompiler

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

void LimitFloatBitDepth (dng_host &host,
						 const dng_image &srcImage,
						 dng_image &dstImage,
						 uint32 bitDepth,
						 real32 scale)
	{
	
	// Kludge: Turning this off for now because the AVX2 path produces
	// slightly different results from the Scalar routine causing a mis-match
	// in raw digest values when building HDR merge result negatives which
	// causes the client to display a "file appears to be damaged" warning.
	// -bury 11/13/2017
	
	#if (qDNGIntelCompiler && qDNGExperimental && 0)

	if (gDNGMaxSIMD >= AVX2)
		{

		LimitFloatBitDepth<AVX2> (host,
								  srcImage,
								  dstImage,
								  bitDepth,
								  scale);

		}

	else

	#endif	// qDNGIntelCompiler && qDNGExperimental

		{

		LimitFloatBitDepth<Scalar> (host,
									srcImage,
									dstImage,
									bitDepth,
									scale);

		}

	}

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

uint32 MinBackwardVersionForCompression (uint32 compression)
	{
	
	if (compression == ccLossyJPEG)
		return dngVersion_1_4_0_0;

	if (compression == ccJXL)
		return dngVersion_1_7_0_0;

	return dngVersion_1_1_0_0;
	
	}

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

tiff_tag * dng_image_sequence_info::MakeTag (dng_memory_allocator &allocator) const
	{

	dng_memory_stream stream (allocator);

	TempBigEndian tempEndian (stream);

	// Write Sequence ID.

	if (fSequenceID.NotEmpty ())
		stream.Put (fSequenceID.Get (),
					fSequenceID.Length ());

	stream.PutZeros (1);

	// Write Sequence Type.

	if (fSequenceType.NotEmpty ())
		stream.Put (fSequenceType.Get (),
					fSequenceType.Length ());

	stream.PutZeros (1);

	// Write frame info.

	if (fFrameInfo.NotEmpty ())
		stream.Put (fFrameInfo.Get (),
					fFrameInfo.Length ());

	stream.PutZeros (1);

	// Write index, count, and final.

	stream.Put_uint32 (fIndex);
	stream.Put_uint32 (fCount);
	stream.Put_uint8 (fIsFinal);

	stream.SetReadPosition (0);

	const_dng_memory_block_sptr block (stream.AsMemoryBlock (allocator));

	AutoPtr<tag_owned_data_ptr> tag
		(new tag_owned_data_ptr (tcImageSequenceInfo,
								 ttUndefined,
								 block->LogicalSize (),
								 block));

	return tag.Release ();
	
	}

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

bool dng_image_stats::IsValidForPlaneCount (uint32 planeCount) const
	{
	
	DNG_REQUIRE (planeCount > 0, "Invalid plane count");

	if (fWeightedAverage.size () >= 2)
		return false;

	if (fWeights.size () != 0 &&
		fWeights.size () != size_t (planeCount))
		return false;
	
	if (fColorAverage.size () != 0 &&
		fColorAverage.size () != size_t (planeCount))
		return false;

	// Check weighted samples.
		
	if (!fWeightedSamples.empty ())
		{

		// Check too many samples.

		if (fWeightedSamples.size () > kMaxSamples)
			return false;
		
		// Check non-increasing order.

		real32 fPrev = fWeightedSamples.front ().fFrac;

		for (size_t i = 1; i < fWeightedSamples.size (); i++)
			{

			real32 fCurrent = fWeightedSamples [i].fFrac;
			
			if (fCurrent <= fPrev)
				return false;

			fPrev = fCurrent;

			}
		
		}

	// Check color samples.

	if (!fColorSamples.empty ())
		{

		// Check too many samples.

		if (fColorSamples.size () > kMaxSamples)
			return false;
		
		// Check non-increasing order and invalid plane count.

		real32 fPrev = fColorSamples.front ().fFrac;

		for (size_t i = 1; i < fColorSamples.size (); i++)
			{

			const auto &sample = fColorSamples [i];
			
			if (sample.fFrac <= fPrev)
				return false;

			fPrev = sample.fFrac;

			// Also check plane count.

			if (sample.fValues.size () != size_t (planeCount))
				return false;

			}
		
		}

	// Looks ok.

	return true;
	
	}

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

uint32 dng_image_stats::TagCount () const
	{

	uint32 count = 0;
	
	count += (!fWeightedAverage.empty () ? 1 : 0);
	count += (!fWeightedSamples.empty () ? 1 : 0);
	count += (!fWeights		   .empty () ? 1 : 0);
	count += (!fColorAverage   .empty () ? 1 : 0);
	count += (!fColorSamples   .empty () ? 1 : 0);

	return count;
	
	}

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

static void Put (dng_stream &stream,
				 uint32 tagCode,
				 const std::vector<real32> &values)
	{

	if (!values.empty ())
		{

		// Sanity check on values size.

		DNG_REQUIRE (values.size () <= 16,
					 "values vector too large");

		// Child tag code.

		stream.Put_uint32 (tagCode);

		// Byte length of child tag data.
		
		stream.Put_uint32 (uint32 (4 * values.size ()));

		// Child tag data.

		for (const auto x : values)
			stream.Put_real32 (x);
		
		}
	
	}

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

static void Put (dng_stream &stream,
				 uint32 tagCode,
				 const std::vector<dng_image_stats::weighted_sample> &samples)
	{

	if (!samples.empty ())
		{

		// Sanity check on samples size.

		DNG_REQUIRE (samples.size () <= dng_image_stats::kMaxSamples,
					 "samples vector too large");

		// Child tag code.

		stream.Put_uint32 (tagCode);

		// Byte length of child tag data.
		
		stream.Put_uint32 (uint32 (4 + 8 * samples.size ()));

		// Child tag data.

		// Write number of samples.

		stream.Put_uint32 (uint32 (samples.size ()));

		// Write data for each sample.

		for (const auto &sample : samples)
			{
			stream.Put_real32 (sample.fFrac);
			stream.Put_real32 (sample.fValue);
			}
		
		}
	
	}

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

static void Put (dng_stream &stream,
				 uint32 tagCode,
				 const std::vector<dng_image_stats::color_sample> &samples)
	{

	if (!samples.empty ())
		{

		// Sanity check on samples size.

		DNG_REQUIRE (samples.size () <= dng_image_stats::kMaxSamples,
					 "samples vector too large");

		// Child tag code.

		stream.Put_uint32 (tagCode);

		// Byte length of child tag data.

		uint32 bytes = 4;

		for (const auto &sample : samples)
			bytes += (4 + 4 * uint32 (sample.fValues.size ()));
		
		stream.Put_uint32 (bytes);

		// Child tag data.

		// Write number of samples.

		stream.Put_uint32 (uint32 (samples.size ()));

		// Write data for each sample.

		for (const auto &sample : samples)
			{
			
			stream.Put_real32 (sample.fFrac);
			
			for (const auto &x : sample.fValues)
				stream.Put_real32 (x);
			
			}
		
		}
	
	}

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

tiff_tag * dng_image_stats::MakeTag (dng_memory_allocator &allocator) const
	{
	
	dng_memory_stream stream (allocator);

	// Tag data is big-endian byte order.

	TempBigEndian tempEndian (stream);

	// Write the number of tags.

	uint32 count = TagCount ();

	stream.Put_uint32 (count);

	// Write child tag table.

	Put (stream, kTag_WeightedAverage , fWeightedAverage);
	Put (stream, kTag_WeightedSamples , fWeightedSamples);
	Put (stream, kTag_Weights		  , fWeights);
	Put (stream, kTag_ColorAverage	  , fColorAverage);
	Put (stream, kTag_ColorSamples	  , fColorSamples);
	
	// Make a tag from the data.

	stream.SetReadPosition (0);

	const_dng_memory_block_sptr block (stream.AsMemoryBlock (allocator));

	AutoPtr<tag_owned_data_ptr> tag
		(new tag_owned_data_ptr (tcImageStats,
								 ttUndefined,
								 block->LogicalSize (),
								 block));

	return tag.Release ();
	
	}

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

bool dng_image_stats::operator== (const dng_image_stats &src) const
	{
	
	return (fWeightedAverage   == src.fWeightedAverage &&
			fWeightedSamples   == src.fWeightedSamples &&
			fWeights		   == src.fWeights		   &&
			fColorAverage	   == src.fColorAverage	   &&
			fColorSamples	   == src.fColorSamples);
	
	}

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

void dng_image_stats::Parse (dng_stream &stream)
	{
	
	// Tag data is big-endian byte order.

	TempBigEndian tempEndian (stream);

	// Read the number of tags.

	uint32 count = stream.Get_uint32 ();

	// There are only 5 possible tags, and no tag may be repeated. Therefore,
	// more than 5 tags is an error.

	if (count > 5)
		ThrowBadFormat ("too many tags in dng_image_stats");

	// Read each child tag.

	for (uint32 i = 0; i < count; i++)
		{
		
		// Read child tag code.

		uint32 childTagCode = stream.Get_uint32 ();

		// Read byte length of child tag data.

		uint32 length = stream.Get_uint32 ();

		// Byte length must be positive.

		if (length == 0)
			ThrowBadFormat ("child tag byte length must be > 0");
		
		// Byte length must be multiple of 4.

		if ((length & 3) != 0)
			ThrowBadFormat ("child tag byte length expected to be multiple of 4");

		// Check maximum value of byte length.

		constexpr uint32 kMaxBytes = 4 + kMaxSamples * 4 * (kMaxColorPlanes + 1);

		if (length > kMaxBytes)
			ThrowBadFormat ("child tag byte length too large");

		// Read all floats.

		std::vector<real32> *data = nullptr;

		switch (childTagCode)
			{
			
			case kTag_WeightedAverage:
				{
				data = &fWeightedAverage;
				break;
				}
				
			case kTag_Weights:
				{
				data = &fWeights;
				break;
				}
			
			case kTag_ColorAverage:
				{
				data = &fColorAverage;
				break;
				}
				
			default:
				break;
			
			}

		if (data)
			{

			const uint32 numFloats = (length >> 2);

			data->resize (numFloats);

			for (uint32 c = 0; c < numFloats; c++)
				(*data) [c] = stream.Get_real32 ();

			}

		else if (childTagCode == kTag_WeightedSamples)
			{

			const uint32 sampleCount = stream.Get_uint32 ();

			// Check sample count requirements.

			if (sampleCount == 0)
				ThrowBadFormat ("too few samples for weighted samples");

			if (sampleCount > kMaxSamples)
				ThrowBadFormat ("too many samples for weighted samples");

			// Check byte length.

			if (4 + (8 * sampleCount) != length)
				ThrowBadFormat ("mismatch byte length for weighted samples");

			// Read the child tag data.

			fWeightedSamples.resize (sampleCount);

			for (auto &sample : fWeightedSamples)
				{

				sample.fFrac  = stream.Get_real32 ();
				sample.fValue = stream.Get_real32 ();
				
				}
			
			}

		else if (childTagCode == kTag_ColorSamples)
			{
			
			const uint32 sampleCount = stream.Get_uint32 ();

			// Check sample count requirements.

			if (sampleCount == 0)
				ThrowBadFormat ("too few samples for color samples");

			if (sampleCount > kMaxSamples)
				ThrowBadFormat ("too many samples for color samples");

			// Infer plane count.

			const uint32 planes = ((length - 4) / sampleCount / 4) - 1;

			if (planes == 0)
				ThrowBadFormat ("unexpected 0 plane count for color samples");

			if (planes > kMaxColorPlanes)
				ThrowBadFormat ("too large plane count for color samples");

			if (4 + (sampleCount * 4 * (planes + 1)) != length)
				ThrowBadFormat ("mismatched plane count for color samples");

			// Read the child tag data.

			fColorSamples.resize (sampleCount);

			for (auto &sample : fColorSamples)
				{

				sample.fFrac = stream.Get_real32 ();

				sample.fValues.resize (planes);

				for (auto &value : sample.fValues)
					value = stream.Get_real32 ();

				}
			
			}

		else
			{
			
			ThrowBadFormat ("unsupported child tag code");
			
			}

		}
	
	}

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

#if qDNGValidate

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

static void DumpTag (const char *name,
					 const std::vector<real32> &values)
	{

	if (!values.empty ())
		{
	
		printf ("  %s: %.4f",
				name,
				values.front ());

		for (size_t i = 1; i < values.size (); i++)
			printf (", %.4f", values [i]);

		printf ("\n");

		}
	
	}

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

void dng_image_stats::Dump () const
	{

	printf ("ImageStats: %u child tag(s)\n", TagCount ());

	DumpTag ("weights", fWeights);
	
	DumpTag ("weighted average", fWeightedAverage);
	
	DumpTag ("color average", fColorAverage);

	if (!fWeightedSamples.empty ())
		{

		printf ("  weighted samples:\n");
		
		for (const auto &s : fWeightedSamples)
			{
			
			printf ("    frac: %.6f, value: %.6lf\n",
					s.fFrac,
					s.fValue);
			
			}
		
		}
	
	if (!fColorSamples.empty ())
		{

		printf ("  color samples:\n");
		
		for (const auto &s : fColorSamples)
			{
			
			printf ("    frac: %.6f, values: ",
					s.fFrac);

			if (s.fValues.empty ())
				continue;

			printf ("%.6f", s.fValues.front ());

			for (size_t i = 1; i < s.fValues.size (); i++)
				printf (", %.6f", s.fValues [i]);

			printf ("\n");
			
			}
		
		}
	
	}

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

#endif	// qDNGValidate

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