CFHDDecoder.cpp

/*! @file CFHDDecoder.cpp

*  @brief This module implements the C functions for the decoder API
*  
*  Interface to the CineForm HD decoder.  The decoder API uses an opaque
*  data type to represent an instance of a decoder.  The decoder reference
*  is returned by the call to @ref CFHD_OpenDecoder.
*
*  @version 1.0.0
*
*  (C) Copyright 2017 GoPro Inc (http://gopro.com/).
*
*  Licensed under either:
*  - Apache License, Version 2.0, http://www.apache.org/licenses/LICENSE-2.0  
*  - MIT license, http://opensource.org/licenses/MIT
*  at your option.
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*/

#include "StdAfx.h"
#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif


#if _WINDOWS

// Export the interface to the decoder
#define DECODERDLL_EXPORTS	1

#elif __APPLE__

#define DECODERDLL_EXPORTS	1

#ifdef DECODERDLL_API
#undef DECODERDLL_API
#endif

#define DECODERDLL_API __attribute__((visibility("default")))
#include <CoreFoundation/CoreFoundation.h>

#else

// Code required by GCC on Linux to define the entry points

#ifdef DECODERDLL_API
#undef DECODERDLL_API
#endif

#define DECODERDLL_API __attribute__((visibility("default")))

#endif

// Include declarations from the codec library
#include "decoder.h"
#include "swap.h"
#include "thumbnail.h"

// Include declarations for the decoder component
#include "CFHDDecoder.h"
#include "CFHDMetadata.h"
#include "IAllocator.h"
#include "ISampleDecoder.h"
#include "SampleDecoder.h"
#include "SampleMetadata.h"

	
#if _WINDOWS
	#ifdef DYNAMICLIB
	BOOL APIENTRY DllMain(HANDLE hModule,
						  DWORD ulReasonForCall,
						  LPVOID lpReserved)
	{
		switch (ulReasonForCall)
		{
		case DLL_PROCESS_ATTACH:
		case DLL_THREAD_ATTACH:
		case DLL_THREAD_DETACH:
		case DLL_PROCESS_DETACH:
			break;
		}
		return TRUE;
	}
    #endif
#else

void _splitpath( const char * fullPath, char * drive, char * dir, char * fname, char * ext)
{
	int			pathLen = 0;
	char	*	namePtr;
	char	*	extPtr;
	char	*	originalNamePtr;

	drive[0] = '\0';
	dir[0] = '\0';
	fname[0] = '\0';
	ext[0] = '\0';
	originalNamePtr = namePtr = (char *)malloc( strlen( fullPath )+1 );
	if(namePtr) {
		strcpy( namePtr, fullPath );
		while( namePtr[0] && strchr( namePtr, '/' ) ) {
			pathLen++;
			namePtr++;
		}
		strncpy( dir, fullPath, pathLen );
		dir[pathLen] = '\0';
		extPtr = strrchr( namePtr, '.');
		if(extPtr) {
			strcpy( ext, extPtr );
			namePtr = strtok(namePtr, extPtr );
		}
		strcpy( fname, namePtr );
		free(originalNamePtr);
	}
}

void _makepath(char * filename,  char * drive, char * dir, char * fname, char * ext)
{
	filename = strcat( fname, ext );
}

#endif


/*!
	@function CFHD_OpenDecoder

	@brief Open an instance of the CineForm HD decoder and return a reference
	to the decoder through the pointer provided as the first argument.

	@param decoderRefOut
	An opaque reference to a decoder returned by but this function.

	@param allocator
	Optional CFHD_ALLOCATOR structure, for those was wishing to control memory allocations.

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_OpenDecoder(CFHD_DecoderRef *decoderRefOut,
				 CFHD_ALLOCATOR *allocator)
{
	// Check the input arguments
	if (decoderRefOut == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}

	// Allocate a new decoder data structure
	CSampleDecoder *decoderRef = new CSampleDecoder;
	if (decoderRef == NULL) {
		return CFHD_ERROR_OUTOFMEMORY;
	}

	decoderRef->SetAllocator(allocator);

	// Return the decoder data structure
	*decoderRefOut = (CFHD_DecoderRef)decoderRef;

	return CFHD_ERROR_OKAY;
}

/*!
	@function CFHD_GetOutputFormats

	@brief Returns a list of output formats that are appropriate for
	the encoded sample that is provided as an argument.

	@description The CineForm HD codec encodes source video in a variety
	of internal formats depending on the product in which the codec is
	delivered, the video source format, and options provided to the encoder.
	This routine examines the tags that are embedded in the encoded sample
	and selects the output formats that are best for the encoded format,
	in decreasing order of preference.  Output formats that are not
	appropriate to the encoded format are omitted.  For example, raw Bayer
	output formats are not provided if the encoded samples are not
	raw Bayer data.  The list of output formats is ordered to avoid color
	conversion and deeper pixel formats are listed first.

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

	@param samplePtr
	The memory address of a CineForm compressed sample

	@param sampleSize
	The size of a CineForm compressed sample

	@param outputFormatArray
	Pointer to a preallocated array of type CFHD_PixelFormat.
	
	@param outputFormatArrayLength
	Number elements in the preallocated array of type CFHD_PixelFormat.

	@param actualOutputFormatCountOut
	Location to return the number of recommended formats. 

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_GetOutputFormats(CFHD_DecoderRef decoderRef,
					  void *samplePtr,
					  size_t sampleSize,
					  CFHD_PixelFormat *outputFormatArray,
					  int outputFormatArrayLength,
					  int *actualOutputFormatCountOut)
{
	CFHD_Error errorCode = CFHD_ERROR_OKAY;

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

	CSampleDecoder *decoder = (CSampleDecoder *)decoderRef;

	errorCode = decoder->GetOutputFormats(samplePtr,
										  sampleSize,
										  outputFormatArray,
										  outputFormatArrayLength,
										  actualOutputFormatCountOut);

	return errorCode;
}




/*!
	@function CFHD_GetSampleInfo

	@brief Returns requested information about the current sample.

	@description Requesting miscellaneous information from a CineForm
	sample, by Tag-Value pair.
		
	@param decoderRef
	An opaque reference to a decoder created by a call to @ref CFHD_OpenDecoder.

	@param samplePtr
	The memory address of a CineForm compressed sample

	@param sampleSize
	The size of a CineForm compressed sample

	@param tag
	The request the desired data. 

	@param value
	pointer to an buffer that holds the return value.

	@param buffer_size
	size of the buffer for the return value.

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_GetSampleInfo(	CFHD_DecoderRef decoderRef,
					void *samplePtr,
					size_t sampleSize,
					CFHD_SampleInfoTag tag,
					void *value,
					size_t buffer_size)
{
	CFHD_Error errorCode = CFHD_ERROR_OKAY;

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

	CSampleDecoder *decoder = (CSampleDecoder *)decoderRef;

	errorCode = decoder->GetSampleInfo(samplePtr,
									  sampleSize,
									  tag,
									  value,
									  buffer_size);

	return errorCode;
}


/*!
	@function CFHD_PrepareToDecode

	@brief Initializes an instance of the CineForm HD decoder that was
	created by a call to @ref CFHD_OpenDecoder.

	@description The caller can specify the exact dimensions of the decoded
	frame or pass zero for either the output width or output height arguments
	to allow this routine to choose the best output dimensions.  Typically,
	the output dimensions will be the same as the encoded dimensions,
	with a reduction as specified by the decoded resolution argument.
	Likewise, the caller can specify an output pixel format	or allow the routine
	to select the best format.
	The function @ref CFHD_GetOutputFormats provides a list of output formats in
	decreasing order of preference and this function will use the first output
	format from that list if an output format is not specified.  The actual
	output dimensions and pixel format are returned.

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

	@param outputWidth
	The desired width of the decoded frame.  Pass zero to allow this routine
	to choose the best output width.

	@param outputHeight
	The desired width of the decoded frame.  Pass zero to allow this routine
	to choose the best output height.

	@param outputFormat
	The desired output format passed as a four character code.  The requested
	output format will be used if it is one of the formats that would be returned
	by a call to @ref CFHD_GetOutputFormats.  See the pixel formats defined in the
	enumeration CFHD_PixelFormat.  The decoder will always output frames in the
	specified pixel format if possible; otherwise, the call to this routine will
	return an error code.

	@param decodedResolution
	The desired resolution for decoding relative to the encoded frame size.
	See the posible resolutions defined in the enumeration CFHD_DecodedResolution.
	If this argument is non-zero, it must specify a valid decoded resolution such
	as full or half resolution.  The decoder will divide the encoded dimensions
	by the divisor implied by this parameter to determine the actual output dimensions.

	@param decodingFlags
	Flags that specify options for initializing the decoder.  See the flags defined in
	the enumeration for CFHD_DecodingFlags.  The decoding flags are not currently used.
	Pass zero for this argument.

	@param samplePtr
	Pointer to an encoded sample that is representative of the samples that
	will be passed to the decoder.  The sample is parsed to obtain information
	about how the video was encoded.  This information guides this routine in
	initializing the decoder.

	@param sampleSize
	Normally this size of the sample in bytes, if you intend to go on to decode the frame.  
	However, if you was only initializing a decode, and wish to reduce disk overhead,
	you can set the size to a little as 512, as that is sufficient to pass all the need 
	information from the sample header.

	@param actualWidthOut
	Pointer to a variable that will receive the actual width of the decoded
	frames.  The caller can pass NULL, but it is recommended that the caller
	always use the actual dimensions and output format to allocate buffers
	for the decoded frames.

	@param actualHeightOut
	Pointer to a variable that will receive the actual height of the decoded
	frames.  The caller can pass NULL, but it is recommended that the caller
	always use the actual dimensions and output format to allocate buffers
	for the decoded frames.

	@param actualFormatOut
	Pointer to a variable that will receive the actual pixel format of the
	decoded frames.  The caller can pass NULL, but should use the output pixel
	format to determine the size of the output pixels for allocating the buffers
	that will receive the decoded frames.
	
	@details If the output width or height are zero, the decoder will compute
	the output width and height by using the encoded width and height obtained
	from the video sample passed as an argument and reducing the width and height
	as specified by the decoded resolution argument.  This makes it very easy to
	initialize the decoder so that it provides frames at close to the desired
	size needed by the application as efficiently as possible.  It is anticipated
	that in this scenario the application will provide it own scaling routines if
	necessary.

	@bug Arbitrary scaling is not supported by the decoder in this version of the
	codec SDK.

	@return Returns a CFHD error code.
*/

CFHDDECODER_API CFHD_Error
CFHD_PrepareToDecode(CFHD_DecoderRef decoderRef,
					 int outputWidth,
					 int outputHeight,
					 CFHD_PixelFormat outputFormat,
					 CFHD_DecodedResolution decodedResolution,
					 CFHD_DecodingFlags decodingFlags,
					 void *samplePtr,
					 size_t sampleSize,
					 int *actualWidthOut,
					 int *actualHeightOut,
					 CFHD_PixelFormat *actualFormatOut)
{
	CFHD_Error errorCode = CFHD_ERROR_OKAY;

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

	CSampleDecoder *decoder = (CSampleDecoder *)decoderRef;

	errorCode = decoder->PrepareDecoder(outputWidth,
										outputHeight,
										outputFormat,
										decodedResolution,
										decodingFlags,
										samplePtr,
										sampleSize,
										actualWidthOut,
										actualHeightOut,
										actualFormatOut);
	if (errorCode != CFHD_ERROR_OKAY) {
		return errorCode;
	}

	return errorCode;
}

/*-- not include in Doxygen
	@function CFHD_ParseSampleHeader

	@brief Parse the header in the encoded video sample. OBSOLETED by CFHD_GetSampleInfo()

	@description The sample header is parsed to obtain information about the
	video sample without decoding the video sample. 
	
	@param samplePtr
	The memory address of a CineForm compressed sample

	@param sampleSize
	The size of a CineForm compressed sample

	@param sampleHeader
	The address of a pre-allocated structure of type CFHD_SampleHeader

*/
CFHDDECODER_API CFHD_Error
CFHD_ParseSampleHeader(void *samplePtr,
					   size_t sampleSize,
					   CFHD_SampleHeader *sampleHeader)
{
	CFHD_Error errorCode = CFHD_ERROR_OKAY;

	// Catch any errors in the decoder
	try
	{
		CFHD_EncodedFormat encodedFormat = CFHD_ENCODED_FORMAT_YUV_422;
		CFHD_FieldType fieldType = CFHD_FIELD_TYPE_UNKNOWN;

		// Initialize a bitstream to the sample data
		BITSTREAM bitstream;
		InitBitstreamBuffer(&bitstream, (uint8_t  *)samplePtr, sampleSize, BITSTREAM_ACCESS_READ);

		// Clear the fields in the sample header
		SAMPLE_HEADER header;
		memset(&header, 0, sizeof(SAMPLE_HEADER));

		// Decode the sample header
		bool result = ::ParseSampleHeader(&bitstream, &header);
		if (!result)
		{
			// The frame dimensions must be obtained from the encoded sample
			if (header.width == 0 || header.height == 0)
			{
				assert(0);
				errorCode = CFHD_ERROR_BADSAMPLE;
				goto finish;
			}

			// Try to fill in missing information with default values
			if (header.encoded_format == ENCODED_FORMAT_UNKNOWN)
			{
				// The encoded format is probably YUV 4:2:2
				header.encoded_format = ENCODED_FORMAT_YUV_422;
			}

			// It is okay if the original input format is not known
		}

		// Copy the sample header information to the output

		encodedFormat = CSampleDecoder::EncodedFormat(header.encoded_format);
		sampleHeader->SetEncodedFormat(encodedFormat);

		fieldType = CSampleDecoder::FieldType(&header);
		sampleHeader->SetFieldType(fieldType);

		sampleHeader->SetFrameSize(header.width, header.height);
	}
	catch (...)
	{
#if _WINDOWS
		char message[256];
		sprintf_s(message, sizeof(message), "CSampleDecoder::PrepareDecoder caught internal codec error\n");
		OutputDebugString(message);
#endif
		return CFHD_ERROR_INTERNAL;
	}

finish:

	return errorCode;
}

/*!
	@function CFHD_GetPixelSize

	@brief Return the size of the specified pixel format in bytes. 
	
	@description Return the size of a pixle in byte is it uniquely 
	addressable.  Note that the pixel size is not defined for some
	image formats such as v210.  This routine returns zero for pixel
	formats that do not have a size that is an integer number of bytes.
	When the pixel size is not well-defined, it cannot be used to
	compute the pitch of the image rows.  See @ref CFHD_GetImagePitch.

	@param pixelFormat
	CFHD_PixelFormat of the decoding pixel type 

	@param pixelSizeOut
	pointer to return the pixel size

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_GetPixelSize(CFHD_PixelFormat pixelFormat, uint32_t *pixelSizeOut)
{
	CFHD_Error ret = CFHD_ERROR_OKAY;
	if (pixelSizeOut == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}
	
	// Catch any errors in the decoder
	try
	{
		*pixelSizeOut = (uint32_t)GetPixelSize(pixelFormat);
	}
	catch (...)
	{
		*pixelSizeOut = 0;
		ret = CFHD_ERROR_BADFORMAT;
	}

	return ret;
/*
	uint32_t pixelSize = 0;

	switch (pixelFormat)
	{
	case CFHD_PIXEL_FORMAT_YUY2:
	case CFHD_PIXEL_FORMAT_2VUY:
	case CFHD_PIXEL_FORMAT_BYR2:
	case CFHD_PIXEL_FORMAT_BYR4:	
	case CFHD_PIXEL_FORMAT_CT_10BIT_2_8:		// Avid format with two planes of 2-bit and 8-bit pixels
		pixelSize = 2;
		break;

	case CFHD_PIXEL_FORMAT_V210:
		pixelSize = 0;				// 3 is close, but no true pixel size can be returned.
		break;

	case CFHD_PIXEL_FORMAT_BGRA:
	case CFHD_PIXEL_FORMAT_BGRa:
	case CFHD_PIXEL_FORMAT_R408:
	case CFHD_PIXEL_FORMAT_V408:
	case CFHD_PIXEL_FORMAT_R210:
	case CFHD_PIXEL_FORMAT_DPX0:
	case CFHD_PIXEL_FORMAT_RG30:
	case CFHD_PIXEL_FORMAT_AB10:
	case CFHD_PIXEL_FORMAT_AR10:
	case CFHD_PIXEL_FORMAT_YU64:
	case CFHD_PIXEL_FORMAT_CT_SHORT_2_14:		// Avid fixed point 2.14 pixel format
	case CFHD_PIXEL_FORMAT_CT_USHORT_10_6:		// Avid fixed point 10.6 pixel format
	case CFHD_PIXEL_FORMAT_CT_SHORT:			// Avid 16-bit signed pixels
		pixelSize = 4;
		break;

	case CFHD_PIXEL_FORMAT_RG48:
	case CFHD_PIXEL_FORMAT_WP13:
		pixelSize = 6;
		break;

	case CFHD_PIXEL_FORMAT_B64A:
	case CFHD_PIXEL_FORMAT_W13A:
		pixelSize = 8;
		break;

	default:
		//TODO: Add more pixel formats
		assert(0);
		return CFHD_ERROR_INVALID_ARGUMENT;
		break;
	}

	*pixelSizeOut = pixelSize;
*/
	return CFHD_ERROR_OKAY;
}

/*!
	@function CFHD_GetImagePitch

	@brief Return the allocated length of each image row in bytes.

	@description This routine must be used to determine the pitch for 
	pixel formats such as v210 where the pixel size is not defined.

	@param imageWidth
	width of the image. 

	@param pixelFormat
	CFHD_PixelFormat of the decoding pixel type 

	@param imagePitchOut
	pointer to return the rowsize/pitch in bytes	

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_GetImagePitch(uint32_t imageWidth, CFHD_PixelFormat pixelFormat, int32_t *imagePitchOut)
{
	int32_t imagePitch = GetFramePitch(imageWidth, pixelFormat);
	if (imagePitchOut)
	{
		// Return the image pitch (in bytes)
		*imagePitchOut = imagePitch;
		return CFHD_ERROR_OKAY;
	}
	return CFHD_ERROR_INVALID_ARGUMENT;
}

/*!
	@function CFHD_GetImageSize

	@brief Return the size of an image in bytes. 

	@description This image size returned by this routine can be used to allocate a 
	buffer for a decoded 2D or 3D image.

	@param imageWidth
	width of the image. 

	@param imageHeight
	Height of the image. In the case of a 3D image, this is the height of a single eye. 

	@param pixelFormat
	CFHD_PixelFormat of the decoding pixel type 

	@param videoselect
	CFHD_VideoSelect type to specifty if you are decoding left/right or both eyes

	@param stereotype
	CFHD_Stereo3DType type to specifty 3D format if decoding both eyes.

	@param imageSizeOut
	pointer to return the image size in bytes	

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_GetImageSize(uint32_t imageWidth, uint32_t imageHeight, CFHD_PixelFormat pixelFormat, 
				  CFHD_VideoSelect videoselect,	CFHD_Stereo3DType stereotype, uint32_t *imageSizeOut)
{
	uint32_t imagePitch = GetFramePitch(imageWidth, pixelFormat);
	uint32_t imageSize = imagePitch * imageHeight;

	if(stereotype == STEREO3D_TYPE_DEFAULT && videoselect == VIDEO_SELECT_BOTH_EYES)
		imageSize *= 2;

	if (imageSizeOut)
	{
		// Return the size of the image (in bytes)
		*imageSizeOut = imageSize;
		return CFHD_ERROR_OKAY;
	}
	return CFHD_ERROR_INVALID_ARGUMENT;
}

/*!
	@function CFHD_DecodeSample

	@brief Decode one frame of CineForm HD video.

	@description The decoder must have been initialized by a call to
	CFHD_PrepareToDecode.  The decoded frame will have the dimensions
	and format returned by the call to CFHD_PrepareToDecode.

	@param decoderRef
	A reference to a decoder that was initialized by a call to
	CFHD_PrepareToDecode.

	@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 decoded frame.  The buffer must start on an address
	that is aligned to 16 bytes.

	@param outputPitch
	Pitch of the output buffer in bytes.  The pitch must be at least as large as the
	size of one row of decoded pixels.  Since each output row must start on an address
	that is aligned to 16 bytes, the pitch must be a multiple of 16 bytes.

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_DecodeSample(CFHD_DecoderRef decoderRef,
				  void *samplePtr,
				  size_t sampleSize,
				  void *outputBuffer,
				  int outputPitch)
{
	CFHD_Error errorCode = CFHD_ERROR_OKAY;

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

	CSampleDecoder *decoder = (CSampleDecoder *)decoderRef;

	// Test the memory buffer provided for the required size
	try
	{
		uint32_t length = 0;
		uint8_t *test_mem = (uint8_t *)outputBuffer;

		decoder->GetRequiredBufferSize(length);

		test_mem[0] = 0;
		if(length > 0)
		{
			int len = length;
			if(outputPitch > 0)
				test_mem[len - 1] = 0;	
			if(outputPitch < 0)
				test_mem[-(len + outputPitch)] = 0;	
		}
	}
	catch (...)
	{
#ifdef _WINDOWS
		OutputDebugString("Target memory buffer is an invalid size");
#endif
		return CFHD_ERROR_DECODE_BUFFER_SIZE;
	}

	errorCode = decoder->DecodeSample(samplePtr, sampleSize, outputBuffer, outputPitch);
	if (errorCode != CFHD_ERROR_OKAY) {
		return errorCode;
	}


	return CFHD_ERROR_OKAY;
}

/*!
	@function CFHD_SetLicense

	@brief Now obselete, this was used to license the commerical version, but it is no longer required.
	The interface is maintained for backward compatibility.

	@description The license key is used to control trial periods and decode resolution limits.

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

	@param licenseKey Pointer to an array of 16 bytes contain the license key.

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_SetLicense(CFHD_DecoderRef decoderRef,
				const unsigned char *licenseKey)
{
	CFHD_Error errorCode = CFHD_ERROR_OKAY;
	
	// Check the input arguments
	if (decoderRef == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}
	if (licenseKey == NULL) {
		return CFHD_ERROR_INVALID_ARGUMENT;
	}
	
	CSampleDecoder *decoder = (CSampleDecoder *)decoderRef;

	errorCode = decoder->SetLicense(licenseKey);
	
	return errorCode;
}

/*!
	@function CFHD_CloseDecoder

	@brief Release all resources held by the decoder.

	@description Do not attempt to use the decoder after it has been
	closed by a call to this routine.

	@return Returns a CFHD error code.
*/
CFHDDECODER_API CFHD_Error
CFHD_CloseDecoder(CFHD_DecoderRef decoderRef)
{
	//CFHD_Error errorCode = CFHD_ERROR_OKAY;

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

	CSampleDecoder *decoder = (CSampleDecoder *)decoderRef;

	delete decoder;

	return CFHD_ERROR_OKAY;
}


#ifdef _WINDOWS
#include "CFHDMetadata.h"
#else
#include "CFHDMetadata.h"
#endif
#include "AVIExtendedHeader.h"
#include "SampleMetadata.h"
#include "../Codec/metadata.h"



// Return the pathname of the LUT directory and the filename of the database directory
extern void InitGetLUTPaths(char *pPathStr,	//!< Pathname to the LUT directory
	size_t pathSize,	//!< Size of the LUT pathname (in bytes)
	char *pDBStr,		//!< Filename of the database directory
	size_t DBSize		//!< Size of the database filename (in bytes)
);



#define BUFSIZE	1024
/* Table of CRCs of all 8-bit messages. */
uint32_t crc_table[256];

/* Flag: has the table been computed? Initially false. */
int crc_table_computed = 0;

/* Make the table for a fast CRC. */
void make_crc_table(void)
{
 uint32_t c;
 int n, k;

 for (n = 0; n < 256; n++) {
   c = (uint32_t) n;
   for (k = 0; k < 8; k++) {
     if (c & 1)
       c = 0xedb88320L ^ (c >> 1);
     else
       c = c >> 1;
   }
   crc_table[n] = c;
 }
 crc_table_computed = 1;
}

/* Update a running CRC with the bytes buf[0..len-1]--the CRC
  should be initialized to all 1's, and the transmitted value
  is the 1's complement of the final running CRC (see the
  crc() routine below)). */

uint32_t update_crc(uint32_t crc, unsigned char *buf,
                        int len)
{
 uint32_t c = crc;
 int n;

 if (!crc_table_computed)
   make_crc_table();
 for (n = 0; n < len; n++) {
   c = crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
 }
 return c;
}

/* Return the CRC of the bytes buf[0..len-1]. */
uint32_t calccrc(unsigned char *buf, int len)
{
 return update_crc(0xffffffffL, buf, len) ^ 0xffffffffL;
}

#define BINARY_LUT	1

#if 0
void GenerateLUTfile(unsigned int crc, float *LUT, int size, char *displayname)
{
	char PathStr[260];
	char DBStr[64];
	InitGetLUTPaths(PathStr, (size_t)sizeof(PathStr), DBStr, (size_t)sizeof(DBStr));
	//GetLUTPath(PathStr);

	char crcname[32];
#if BINARY_LUT
	sprintf(crcname,"%08X.cflook", crc);
#else
	sprintf(crcname,"%08X.look", crc);
#endif

	char lutfile[260];
	sprintf(lutfile, "%s\\%s", PathStr, crcname);


#define MAKEID(a,b,c,d) ((a<<24)|(b<<16)|(c<<8)|(d))
#define MAKEID_SWAP(d,c,b,a) ((a<<24)|(b<<16)|(c<<8)|(d))

	FILE *fp = fopen(lutfile,"r");
	if (fp != NULL)
	{
		//int endianswap = 0;
		int regen = 0;
		CFLook_Header CFLKhdr;

		fread(&CFLKhdr,1,sizeof(CFLKhdr),fp);

		if(MAKEID('C','F','L','K') == CFLKhdr.CFLK_ID)
		{
			//endianswap = true;
			if (CFLOOK_VERSION != SwapInt32(CFLKhdr.version)) {
				regen = 1;
			}
		}
		if(MAKEID_SWAP('C','F','L','K') == CFLKhdr.CFLK_ID)
		{
			if(CFLOOK_VERSION != CFLKhdr.version)
				regen = 1;
		}

		fclose(fp);

		if(regen == 0)
			return;
	}
#if BINARY_LUT // binary look file

	fp = fopen(lutfile,"wb");
	if (fp != NULL)
	{
		CFLook_Header CFLKhdr;

		CFLKhdr.CFLK_ID = MAKEID_SWAP('C','F','L','K');	// CFLK identifier
		CFLKhdr.version = CFLOOK_VERSION; // version of this CFLK header
		CFLKhdr.hdrsize = 6*4+40;// header size, number of byte before the 3D LUT.
		CFLKhdr.lutsize = size;// size 'n' for an n x n x n 3D-LUT
		CFLKhdr.input_curve = CURVE_LOG_90;// CURVE_TYPE input to the LUT
		CFLKhdr.output_curve = CURVE_GAMMA_2pt2;// CURVE_TYPE output from the LUT



		char drive[260], dir[260], fname[260], ext[64];

		_splitpath(displayname, drive, dir, fname, ext);
		strncpy(CFLKhdr.displayname, fname, 39);

		fwrite(&CFLKhdr,1,sizeof(CFLook_Header),fp);
		fwrite(LUT,4,size*size*size*3,fp);
		fclose(fp);
	}
#else // simplified text IRIDAS look 32 LUT
	else if(fp = fopen(lutfile,"w"))
	{
		char space[16] = "\n      ";
		char header[100];

		sprintf(header,"<?xml version=\"1.0\" ?>\n<look>\n  <LUT>\n    <size>\"%d\"</size>\n    <data>\"", size);
		fwrite(header,1,strlen(header),fp);

		for(int i=0; i<size*size*size*3; i++)
		{
			char hexval[10];
			unsigned char *ptr = (unsigned char *)&LUT[i];

			if((i&7)==0)
				fwrite(space,1,strlen(space),fp);


			sprintf(hexval,"%02X%02X%02X%02X", ptr[0], ptr[1], ptr[2], ptr[3]);
			fwrite(hexval,1,8,fp);

		}