CFHDDecoder.cpp

		char tail[100] = "\"\n    </data>\n  </LUT>\n</look>\n";
		fwrite(tail,1,strlen(tail),fp);
		fclose(fp);
	}
#endif
}


unsigned int ValidateLookGenCRC(char* path)
{
	int crc = 0;
	FILE *fp = fopen(path,"r");

	if(fp == NULL)
	{
#if OUTPUT
		OutputDebugString("ValidateLookGenCRC : no file");
#endif
		return 0;
	}
	else
	{
		uint32_t len=0,lastlen=0,pos=0;
		char buf[BUFSIZE];
		bool LUTfound = false;
		bool SIZEfound = false;
		bool DATAfound = false;
		bool finished = false;
		int size = 0;
		int rgbpos = 0;
		int entries = 0;
		float *LUT = NULL;
		unsigned char *iLUT = NULL;

		pos = 0;
		do
		{
			lastlen = len;
			if(pos)
				memcpy(buf, &buf[pos], lastlen-pos);

			len = (int)fread(&buf[lastlen-pos],1,BUFSIZE-(lastlen-pos),fp) + (lastlen-pos);

			pos = 0;

			if(!LUTfound)
			{
				do
				{
					if(strncmp(&buf[pos],"<LUT>",5) == 0)
					{
						pos+=5;
						LUTfound = true;
						break;

					}
					pos++;
				} while(pos < len-5);
			}
			else if(!SIZEfound)
			{
				do
				{
					if(strncmp(&buf[pos],"<size>",6) == 0)
					{
						int j = 0;
						pos+=7;
						while(buf[pos+j] >= '0' && buf[pos+j] <= '9') j++;
						buf[pos+j] = 0;

						size = atoi(&buf[pos]);

						if(size > 65)
						{
#if OUTPUT
							OutputDebugString("LUT too big");
#endif
							return 0;
						}
#if OUTPUT
						printf("size = %d\n",size);
#endif
						LUT = (float *)malloc(size*size*size*sizeof(float)*3);
						if(LUT == NULL)
						{
#if OUTPUT
							OutputDebugString("no memory\n");
#endif
							return 0;
						}
						iLUT = (unsigned char *)malloc(size*size*size*sizeof(char)*3);
						if(iLUT == NULL)
						{
#if OUTPUT
							OutputDebugString("no memory\n");
#endif
							return 0;
						}

						SIZEfound = true;
						break;

					}
					pos++;
				} while(pos < len-10);
			}
			else if(!DATAfound)
			{
				do
				{
					if(strncmp(&buf[pos],"<data>",6) == 0)
					{
						int j = 0;
						pos+=6;
						while(	!( (buf[pos+j] >= '0' && buf[pos+j] <= '9') ||
								(buf[pos+j] >= 'a' && buf[pos+j] <= 'f') ||
								(buf[pos+j] >= 'A' && buf[pos+j] <= 'F') ))
							pos++;

						//printf("%s\n",&buf[pos+j]);



						DATAfound = true;
						break;

					}
					pos++;
				} while(pos < len-256);
			}
			else if(DATAfound)
			{
				char hexstring[12] = "00000000";
				do
				{
					while(	!(  (buf[pos] >= '0' && buf[pos] <= '9') ||
								(buf[pos] >= 'a' && buf[pos] <= 'f') ||
								(buf[pos] >= 'A' && buf[pos] <= 'F') ))
					{
							if(buf[pos] == '"' || buf[pos] == '<')
							{
								finished = true;
#if OUTPUT
								OutputDebugString("finished\n");
#endif
								break;
							}
							pos++;
					}

					if(!finished)
					{
						float val;
						hexstring[0] = buf[pos+6];
						hexstring[1] = buf[pos+7];
						hexstring[2] = buf[pos+4];
						hexstring[3] = buf[pos+5];
						hexstring[4] = buf[pos+2];
						hexstring[5] = buf[pos+3];
						hexstring[6] = buf[pos+0];
						hexstring[7] = buf[pos+1];

						//printf("%s",hexstring);
						sscanf(hexstring, "%08x", (int *)&val);
#if OUTPUT && 0
						printf("%6.3f",val);
#endif
						LUT[entries] = val;
						rgbpos++;
						entries++;
						if(rgbpos < 3)
						{
#if OUTPUT && 0
							printf(",");
#endif
						}
						else
						{
#if OUTPUT && 0
							printf("\n");
#endif
							rgbpos = 0;
						}
					}

					pos+=8;
				} while(pos < len-16 && !finished);
			}



		//	printf("len = %d\n", len);
		}
		while(len > 0 && !finished);

		fclose(fp);

		if(finished && (size*size*size*3 == entries))
		{
			// valid 3D LUT
			crc = calccrc((unsigned char *)LUT, entries*4);
			char fullpath[260];
#if	_WINDOWS
			if(0 == ::GetLongPathName(path, fullpath, 259))
				strcat(fullpath, path);
#else
			strcpy(fullpath, path);
#endif

			GenerateLUTfile(crc, LUT, size, fullpath);
		}

		if(LUT)
			free(LUT), LUT=NULL;
	}
	return crc;
}

#endif 


/*!
	@function CFHD_SetActiveMetadata

	@brief Recursively add active metadata for the decoder to use.

	@description Decoder will use the active metadata store in the sample, or in
	the color database or overrided by the Tags added by this function.  If you
	want the decoder to use the original camera data with a few change, initialize
	the metadata engine with @ref CFHD_InitSampleMetadata with the track set to
	METADATATYPE_ORIGINAL. Then call CFHD_SetActiveMetadata we the tag you want it
	to act upon (new whilebalanc, Look etc.)

	@param decoderRef An opaque reference to a decoder created by a
	call to @ref CFHD_OpenDecoder.

	@param metadataRef Reference to a metadata interface returned by a call
	to @ref CFHD_OpenMetadata.

	@param tag The FOURCC of the Tag you wish to add for active decoder
	control.

	@param type The data type of active metadata.

	@param data Pointer to the data.

	@param size The number of bytes of data.

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_SetActiveMetadata(	CFHD_DecoderRef decoderRef,
						CFHD_MetadataRef metadataRef,
						unsigned int tag,
						CFHD_MetadataType type,
						void *data,
						unsigned int size)
{
	CFHD_Error errorCode = CFHD_ERROR_OKAY;

	// Check the input arguments
	if (metadataRef == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}
	if (decoderRef == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}

	if ((tag == 0 && type != METADATATYPE_CINEFORM) || data == NULL || size == 0) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}

	CSampleMetadata *metadata = (CSampleMetadata *)metadataRef;
	CSampleDecoder *decoder = (CSampleDecoder *)decoderRef;

	//Hack, pass the decoders custom allocator on to CSampleMetadata
	metadata->SetAllocator(decoder->GetAllocator());

	//if(metadata->m_overrideSize == 0)
	{
		if(metadata->m_metadataTrack & METADATAFLAG_MODIFIED)
		{			
			int data = 1;
			int typesizebytes = ('H'<<24)|4;

			metadata->AddMetaData(TAG_FORCE_DATABASE, typesizebytes, (void *)&data);

			data = 0;
			metadata->AddMetaData(TAG_IGNORE_DATABASE, typesizebytes, (void *)&data);
		}
		else
		{			
			int data = 1;
			int typesizebytes = ('H'<<24)|4;

			metadata->AddMetaData(TAG_IGNORE_DATABASE, typesizebytes, (void *)&data);

			data = 0;
			metadata->AddMetaData(TAG_FORCE_DATABASE, typesizebytes, (void *)&data);
		}
	}

	unsigned int typesizebytes = 0;

	switch(type)
	{
		case METADATATYPE_STRING:
			typesizebytes = 'c' << 24;
			break;
		case METADATATYPE_UINT32:
			typesizebytes = 'L' << 24;
			break;
		case METADATATYPE_UINT16:
			typesizebytes = 'S' << 24;
			break;
		case METADATATYPE_UINT8:
			typesizebytes = 'B' << 24;
			break;
		case METADATATYPE_FLOAT:
			typesizebytes = 'f' << 24;
			break;
		case METADATATYPE_DOUBLE:
			typesizebytes = 'd' << 24;
			break;
		case METADATATYPE_GUID:
			typesizebytes = 'G' << 24;
			break;
		case METADATATYPE_XML:
			typesizebytes = 'x' << 24;
			break;
		case METADATATYPE_LONG_HEX:
			typesizebytes = 'H' << 24;
			break;
		case METADATATYPE_HIDDEN:
			typesizebytes = 'h' << 24;
			break;
		case METADATATYPE_TAG:
			typesizebytes = 'T' << 24;
			break;
		case METADATATYPE_UNKNOWN:
		default:
			break;
	}

	typesizebytes |= size;

	if(tag == TAG_CHANNELS_ACTIVE)
	{
		decoder->SetChannelsActive(*((uint32_t *)data));
	}
	if(tag == TAG_CHANNELS_MIX)
	{
		decoder->SetChannelMix(*((uint32_t *)data));
	}
	
	if(tag == TAG_LOOK_FILE)
	{
		uint32_t crc = 0;
		static char lastpath[260] = "";
		static char lastLUTfilename[40] = "";
		static uint32_t lastLUTcrc = 0;

		if(lastLUTcrc && 0 == strcmp(lastpath, (char *)data))
		{
			typesizebytes = ('c'<<24)|39;
			metadata->AddMetaData(TAG_LOOK_FILE, typesizebytes, (void *)&lastLUTfilename[0]);
			typesizebytes = ('H'<<24)|4;
			metadata->AddMetaData(TAG_LOOK_CRC, typesizebytes, (void *)&lastLUTcrc);
		}
		else 
		{
			char drive[260];
			char dir[260];
			char fname[260];
			char ext[64];
			char filename[260];
			
//DANREMOVE			crc = ValidateLookGenCRC((char *)data);

#ifdef _WINDOWS
			strcpy_s(lastpath, sizeof(lastpath), (char *)data);
			_splitpath_s((char *)data, drive, sizeof(drive), dir, sizeof(dir), fname, sizeof(fname), ext, sizeof(ext));
			_makepath_s(filename, sizeof(filename), NULL, NULL, fname, ext);
#else
			strcpy(lastpath, (char *)data);
			_splitpath((char *)data, drive, dir, fname, ext);
			_makepath(filename, NULL, NULL, fname, ext);
#endif


			if(strlen(filename) < 40)
			{
				typesizebytes = ('c'<<24)|39;
				metadata->AddMetaData(TAG_LOOK_FILE, typesizebytes, (void *)&filename[0]);

#ifdef _WINDOWS
				strcpy_s(lastLUTfilename, sizeof(lastLUTfilename), filename); 
#else
				strcpy(lastLUTfilename, filename);
#endif
				
				if(crc)
				{
					typesizebytes = ('H'<<24)|4;
					metadata->AddMetaData(TAG_LOOK_CRC, typesizebytes, (void *)&crc);
					lastLUTcrc = crc;
				}
			}
		}
	}
	else if(type == METADATATYPE_CINEFORM)
	{
		uint32_t *ptr = (uint32_t*)data;
		while(size>=12 && size < 4096)
		{

			uint32_t tag = *ptr++; size-=4;
			uint32_t typesizebytes = *ptr++; size-=4;
			uint32_t *newdata = ptr;
			uint32_t tagsize = typesizebytes & 0xffffff;

			metadata->AddMetaData(tag, typesizebytes, newdata);

			tagsize += 3;
			tagsize &=~3;
			size-=tagsize; ptr += tagsize/4;
		}
	}
	else if(tag == TAG_UNIQUE_FRAMENUM)
	{
		metadata->m_currentUFRM = *(uint32_t *)data;
	}
	else
	{
		if(metadata->m_metadataTrack & METADATAFLAG_LEFT_EYE)
		{
			metadata->AddMetaDataChannel(tag, typesizebytes, data, 1);
		}
		else if(metadata->m_metadataTrack & METADATAFLAG_RIGHT_EYE)
		{
			metadata->AddMetaDataChannel(tag, typesizebytes, data, 2);
		}
		else
		{
			metadata->AddMetaData(tag, typesizebytes, data);
		}
	}

	if(metadata->m_overrideSize)
	{
		decoder->SetDecoderOverrides(metadata->m_overrideData, metadata->m_overrideSize);
	}

	return errorCode;
}


CFHDDECODER_API CFHD_Error
CFHD_ClearActiveMetadata(	CFHD_DecoderRef decoderRef,
							CFHD_MetadataRef metadataRef)
{
	CFHD_Error errorCode = CFHD_ERROR_OKAY;

	// Check the input arguments
	if (metadataRef == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}
	if (decoderRef == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}

	CSampleMetadata *metadata = (CSampleMetadata *)metadataRef;
	CSampleDecoder *decoder = (CSampleDecoder *)decoderRef;

	metadata->FreeDatabase();
	decoder->SetDecoderOverrides(NULL, 0);

	return errorCode;
}



/*!
	@function CFHD_GetThumbnail

	@brief The generate a thumbnail 

	@description Extract the base wavelet into a using image thumbnail without 
	decompressing the sample

	@param decoderRef An opaque reference to a decoder created by a
	call to @ref CFHD_OpenDecoder.

	@param samplePtr
	Pointer to a sample containing one frame of encoded video in the
	CineForm HD format.

	@param sampleSize
	Size of the encoded sample.

	@param outputBuffer
	Buffer that will receive the thumbnail of size 1/8 x 1/8 the original frame.  

	@param outputBufferSize
	Size must be at least ((w+7)/8) * ((h+7)/8) * 4 for 10-bit RGB format.

	@param flags
	future usage
	
	@param retWidth
	If successful contains thumbnail width.

	@param retHeight
	If successful contains thumbnail Height.

	@param retSize
	If successful contains thumbnail size in bytes.

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_GetThumbnail(CFHD_DecoderRef decoderRef,
				  void *samplePtr,
				  size_t sampleSize,
				  void *outputBuffer,
				  size_t outputBufferSize,
				  uint32_t flags,
				  size_t *retWidth = NULL,
				  size_t *retHeight = NULL,
				  size_t *retSize = NULL)
{
	CFHD_Error errorCode = CFHD_ERROR_OKAY;

	// Check the input arguments
	if (decoderRef == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}
	if (samplePtr == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}
	if (outputBuffer == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}

	CSampleDecoder *decoder = reinterpret_cast<CSampleDecoder *>(decoderRef);

	// Have the thumbnail flags been set?
	if (flags == THUMBNAIL_FLAGS_NONE)
	{
		// Use the default thumbnail flags
		flags = THUMBNAIL_FLAGS_DEFAULT;
	}

	errorCode = decoder->GetThumbnail(
					samplePtr,
					sampleSize,
					outputBuffer,
					outputBufferSize,
					flags,
					retWidth,
					retHeight,
					retSize);

	return errorCode;
}



/*!
	@function CFHD_CreateImageDeveloper

	@brief Allocate a decoder for image development use upon uncompressed image data only.

	@description Do not pass a compressed image to this handle.

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_CreateImageDeveloper(CFHD_DecoderRef decoderRef, 
						  uint32_t imageWidth, 
						  uint32_t imageHeight,
						  uint32_t sourceVideoChannels, 
						  CFHD_PixelFormat pixelFormatSrc,
						  CFHD_PixelFormat pixelFormatDst) //1 or 2 for 3D double high stacked 
{
	CFHD_Error errorCode = CFHD_ERROR_OKAY;

	// Check the input arguments
	if (decoderRef == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}
	
	CSampleDecoder *decoder = (CSampleDecoder *)decoderRef;

	int actualWidthOut,actualHeightOut;
	CFHD_PixelFormat actualFormatOut;

	errorCode = decoder->PrepareDecoder(imageWidth,
										imageHeight,
										pixelFormatDst,
										(CFHD_DecodedResolution)sourceVideoChannels, // Reuse of the decode resolution for 2D vs 3D
										(CFHD_DecodingFlags)pixelFormatSrc,  // Reuse the the decoding flags
										NULL,//samplePtr,
										0,//sampleSize,
										&actualWidthOut,
										&actualHeightOut,
										&actualFormatOut);
	if (errorCode != CFHD_ERROR_OKAY) {
		return errorCode;
	}

	return CFHD_ERROR_OKAY;
}



#ifdef __cplusplus
}
#endif