source/dng_opcode_list.cpp

/*****************************************************************************/
// Copyright 2008-2009 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_opcode_list.cpp#1 $ */ 
/* $DateTime: 2012/05/30 13:28:51 $ */
/* $Change: 832332 $ */
/* $Author: tknoll $ */

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

#include "dng_opcode_list.h"

#include "dng_globals.h"
#include "dng_host.h"
#include "dng_memory_stream.h"
#include "dng_negative.h"
#include "dng_tag_values.h"
#include "dng_utils.h"

#include <algorithm>

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

dng_opcode_list::dng_opcode_list (uint32 stage)
	
	:	fList        ()
	,	fAlwaysApply (false)
	,	fStage		 (stage)
	
	{
	
	}
	
/******************************************************************************/

dng_opcode_list::~dng_opcode_list ()
	{
	
	Clear ();
	
	}
			
/******************************************************************************/

void dng_opcode_list::Clear ()
	{
	
	for (size_t index = 0; index < fList.size (); index++)
		{
		
		if (fList [index])
			{
		
			delete fList [index];
			
			fList [index] = NULL;
			
			}
		
		}
		
	fList.clear ();
	
	fAlwaysApply = false;
	
	}
			
/******************************************************************************/

void dng_opcode_list::Swap (dng_opcode_list &otherList)
	{
	
	fList.swap (otherList.fList);
	
	std::swap (fAlwaysApply, otherList.fAlwaysApply);
		
	std::swap (fStage, otherList.fStage);
		
	}

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

uint32 dng_opcode_list::MinVersion (bool includeOptional) const
	{
	
	uint32 result = dngVersion_None;
	
	for (size_t index = 0; index < fList.size (); index++)
		{
		
		if (includeOptional || !fList [index]->Optional ())
			{
			
			result = Max_uint32 (result, fList [index]->MinVersion ());
			
			}
		
		}
	
	return result;
	
	}

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

void dng_opcode_list::Apply (dng_host &host,
							 dng_negative &negative,
							 AutoPtr<dng_image> &image)
	{
	
	for (uint32 index = 0; index < Count (); index++)
		{
		
		dng_opcode &opcode (Entry (index));
		
		if (opcode.AboutToApply (host, negative))
			{
						
			opcode.Apply (host,
						  negative,
						  image);
			
			}
		
		}

	}

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

void dng_opcode_list::Append (AutoPtr<dng_opcode> &opcode)
	{
	
	if (opcode->OpcodeID () == dngOpcode_Private)
		{
		SetAlwaysApply ();
		}
		
	opcode->SetStage (fStage);
	
	fList.push_back (NULL);

	fList [fList.size () - 1] = opcode.Release ();
	
	}
		
/*****************************************************************************/

dng_memory_block * dng_opcode_list::Spool (dng_host &host) const
	{
	
	if (IsEmpty ())
		{
		return NULL;
		}
		
	if (AlwaysApply ())
		{
		ThrowProgramError ();
		}
		
	dng_memory_stream stream (host.Allocator ());
	
	stream.SetBigEndian ();
	
	stream.Put_uint32 ((uint32) fList.size ());
	
	for (size_t index = 0; index < fList.size (); index++)
		{
		
		stream.Put_uint32 (fList [index]->OpcodeID   ());
		stream.Put_uint32 (fList [index]->MinVersion ());
		stream.Put_uint32 (fList [index]->Flags      ());
		
		fList [index]->PutData (stream);
	
		}
	
	return stream.AsMemoryBlock (host.Allocator ());
	
	}
		
/*****************************************************************************/

void dng_opcode_list::FingerprintToStream (dng_stream &stream) const
	{
	
	if (IsEmpty ())
		{
		return;
		}
		
	stream.Put_uint32 ((uint32) fList.size ());
	
	for (size_t index = 0; index < fList.size (); index++)
		{
		
		stream.Put_uint32 (fList [index]->OpcodeID   ());
		stream.Put_uint32 (fList [index]->MinVersion ());
		stream.Put_uint32 (fList [index]->Flags      ());
		
		if (fList [index]->OpcodeID () != dngOpcode_Private)
			{
		
			fList [index]->PutData (stream);
			
			}
	
		}
		
	}

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

void dng_opcode_list::Parse (dng_host &host,
							 dng_stream &stream,
							 uint32 byteCount,
							 uint64 streamOffset)
	{
	
	Clear ();
	
	TempBigEndian tempBigEndian (stream);
	
	stream.SetReadPosition (streamOffset);
	
	uint32 count = stream.Get_uint32 ();
	
	#if qDNGValidate
	
	if (gVerbose)
		{
		
		if (count == 1)
			{
			printf ("1 opcode\n");
			}
			
		else
			{
			printf ("%u opcodes\n", (unsigned) count);
			}
	
		}
		
	#endif
	
	for (uint32 index = 0; index < count; index++)
		{
		
		uint32 opcodeID = stream.Get_uint32 ();
		
		AutoPtr<dng_opcode> opcode (host.Make_dng_opcode (opcodeID,
														  stream));
														  
		Append (opcode);
		
		}
		
	if (stream.Position () != streamOffset + byteCount)
		{
		
		ThrowBadFormat ("Error parsing opcode list");
		
		}
	
	}
		
/*****************************************************************************/