New: Import/Export of Cineon and DPX image files. The first is Kodak's

standard for film scanning, 10 bits/channel and logarithmic. DPX is
derived from Cineon as the ANSI/SMPTE industry standard.
DPX supports 16 bits color/channel, linear as well as logarithmic.

Code has been gratefully copied from CinePaint and was integrated in
Blender by Joe Eagar.

According to CinePaint's dev Robin Rowe the DPX code defaults to log
colorspace. Can't find in the code clues yet how to enable/disable that.
However, tests with write/read of DPX seems to show no visible loss by
log conversion code. Might be because it uses the entire 16 bit range...

CinePaint dpx files have been succesfully imported in a Quantel IQ HD/2K
finishing/grading set without problem, so for now I guess we can
use it! :)

Changes in code: added tests for image magic numbers before entering
the actual reading code. Prevents error prints, and makes it faster too.
(Note; this because Blender doesn't check for extensions, but calls
reading functions on every file until one accepts it. :)

1 files changed, 801 insertions, 0 deletions

diff --git a/source/blender/imbuf/intern/cineon/cineonlib.c b/source/blender/imbuf/intern/cineon/cineonlib.c
new file mode 100644
index 00000000000..5253646be4d
--- /dev/null
+++ b/source/blender/imbuf/intern/cineon/cineonlib.c
@@ -0,0 +1,801 @@
+/*
+ *	 Cineon image file format library routines.
+ *
+ *	 Copyright 1999,2000,2001 David Hodson <hodsond@acm.org>
+ *
+ *	 This program is free software; you can redistribute it and/or modify it
+ *	 under the terms of the GNU General Public License as published by the Free
+ *	 Software Foundation; either version 2 of the License, or (at your option)
+ *	 any later version.
+ *
+ *	 This program is distributed in the hope that it will be useful, but
+ *	 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ *	 or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU General Public License
+ *	 for more details.
+ *
+ *	 You should have received a copy of the GNU General Public License
+ *	 along with this program; if not, write to the Free Software
+ *	 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include "cineonlib.h"
+#include "cineonfile.h"
+
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>				 /* strftime() */
+#include <sys/types.h>
+#ifdef WIN32
+#include <winsock.h>
+#else
+#include <netinet/in.h>	 /* htonl() */
+#endif
+#include <string.h>			 /* memset */
+#include "cin_debug_stuff.h"
+#include "logmemfile.h"
+
+static void
+fillCineonFileInfo(CineonFile* cineon, CineonFileInformation* fileInfo, const char* filename) {
+
+	time_t fileClock;
+	struct tm* fileTime;
+
+	fileInfo->magic_num = htonl(CINEON_FILE_MAGIC);
+	fileInfo->image_offset = htonl(cineon->imageOffset);
+	fileInfo->gen_hdr_size = htonl(
+		sizeof(CineonFileInformation) +
+		sizeof(CineonImageInformation) +
+		sizeof(CineonFormatInformation) +
+		sizeof(CineonOriginationInformation));
+	fileInfo->ind_hdr_size = 0;
+	fileInfo->user_data_size = 0;
+	fileInfo->file_size = htonl(cineon->imageOffset + cineon->height * cineon->lineBufferLength);
+	strcpy(fileInfo->vers, "V4.5");
+	strncpy(fileInfo->file_name, filename, 99);
+	fileInfo->file_name[99] = 0;
+
+	fileClock = time(0);
+	fileTime = localtime(&fileClock);
+	strftime(fileInfo->create_date, 12, "%Y:%m:%d", fileTime);
+	/* Question: is %Z in strftime guaranteed to return 3 chars? */
+	strftime(fileInfo->create_time, 12, "%H:%M:%S%Z", fileTime);
+	fileInfo->create_time[11] = 0;
+}
+
+static void
+dumpCineonFileInfo(CineonFileInformation* fileInfo) {
+	d_printf("\n--File Information--\n");
+	d_printf("Magic: %8.8lX\n", ntohl(fileInfo->magic_num));
+	d_printf("Image Offset %ld\n", ntohl(fileInfo->image_offset));
+	d_printf("Generic Header size %ld\n", ntohl(fileInfo->gen_hdr_size));
+	d_printf("Industry Header size %ld\n", ntohl(fileInfo->ind_hdr_size));
+	d_printf("User Data size %ld\n", ntohl(fileInfo->user_data_size));
+	d_printf("File size %ld\n", ntohl(fileInfo->file_size));
+	d_printf("Version \"%s\"\n", fileInfo->vers);
+	d_printf("File name \"%s\"\n", fileInfo->file_name);
+	d_printf("Creation date \"%s\"\n", fileInfo->create_date);
+	d_printf("Creation time \"%s\"\n", fileInfo->create_time);
+}
+
+static void
+fillCineonChannelInfo(CineonFile* cineon, CineonChannelInformation* chan, int des) {
+
+	chan->designator1 = 0;
+	chan->designator2 = des;
+	chan->bits_per_pixel = 10;
+	chan->pixels_per_line = htonl(cineon->width);
+	chan->lines_per_image = htonl(cineon->height);
+	chan->ref_low_data = htonl(0);
+	chan->ref_low_quantity = htonf(0.0);
+	chan->ref_high_data = htonl(1023);
+	chan->ref_high_quantity = htonf(2.046);
+}
+
+static void
+dumpCineonChannelInfo(CineonChannelInformation* chan) {
+	d_printf("	Metric selector: %d", chan->designator1);
+	switch (chan->designator1) {
+		case 0: d_printf(" (Universal)\n"); break;
+		default: d_printf(" (Vendor specific)\n"); break;
+	}
+	d_printf("	Metric: %d,", chan->designator2);
+	switch (chan->designator2) {
+		case 0: d_printf(" B&W (printing density?)\n"); break;
+		case 1: d_printf(" Red printing density\n"); break;
+		case 2: d_printf(" Green printing density\n"); break;
+		case 3: d_printf(" Blue printing density\n"); break;
+		case 4: d_printf(" Red CCIR XA/11\n"); break;
+		case 5: d_printf(" Green CCIR XA/11\n"); break;
+		case 6: d_printf(" Blue CCIR XA/11\n"); break;
+		default: d_printf(" (unknown)\n"); break;
+	}
+	d_printf("	Bits per pixel %d\n", chan->bits_per_pixel);
+	d_printf("	Pixels per line %ld\n", ntohl(chan->pixels_per_line));
+	d_printf("	Lines per image %ld\n", ntohl(chan->lines_per_image));
+	d_printf("	Ref low data %ld\n", ntohl(chan->ref_low_data));
+	d_printf("	Ref low quantity %f\n", ntohf(chan->ref_low_quantity));
+	d_printf("	Ref high data %ld\n", ntohl(chan->ref_high_data));
+	d_printf("	Ref high quantity %f\n", ntohf(chan->ref_high_quantity));
+}
+
+static void
+fillCineonImageInfo(CineonFile* cineon, CineonImageInformation* imageInfo) {
+
+	imageInfo->orientation = 0;
+	imageInfo->channels_per_image = cineon->depth;
+
+	if (cineon->depth == 1) {
+		fillCineonChannelInfo(cineon, &imageInfo->channel[0], 0);
+
+	} else if (cineon->depth == 3) {
+		fillCineonChannelInfo(cineon, &imageInfo->channel[0], 1);
+		fillCineonChannelInfo(cineon, &imageInfo->channel[1], 2);
+		fillCineonChannelInfo(cineon, &imageInfo->channel[2], 3);
+	}
+
+	imageInfo->white_point_x = htonf(undefined());
+	imageInfo->white_point_y = htonf(undefined());
+	imageInfo->red_primary_x = htonf(undefined());
+	imageInfo->red_primary_y = htonf(undefined());
+	imageInfo->green_primary_x = htonf(undefined());
+	imageInfo->green_primary_y = htonf(undefined());
+	imageInfo->blue_primary_x = htonf(undefined());
+	imageInfo->blue_primary_y = htonf(undefined());
+
+	strcpy(imageInfo->label, "David's Cineon writer.");
+
+}
+
+static void
+dumpCineonImageInfo(CineonImageInformation* imageInfo) {
+
+	int i;
+	d_printf("\n--Image Information--\n");
+	d_printf("Image orientation %d,", imageInfo->orientation);
+	switch (imageInfo->orientation) {
+		case 0: d_printf(" LRTB\n"); break;
+		case 1: d_printf(" LRBT\n"); break;
+		case 2: d_printf(" RLTB\n"); break;
+		case 3: d_printf(" RLBT\n"); break;
+		case 4: d_printf(" TBLR\n"); break;
+		case 5: d_printf(" TBRL\n"); break;
+		case 6: d_printf(" BTLR\n"); break;
+		case 7: d_printf(" BTRL\n"); break;
+		default: d_printf(" (unknown)\n"); break;
+	}
+	d_printf("Channels %d\n", imageInfo->channels_per_image);
+	for (i = 0; i < imageInfo->channels_per_image; ++i) {
+		d_printf("	--Channel %d--\n", i);
+		dumpCineonChannelInfo(&imageInfo->channel[i]);
+	}
+
+	d_printf("White point x %f\n", ntohf(imageInfo->white_point_x));
+	d_printf("White point y %f\n", ntohf(imageInfo->white_point_y));
+	d_printf("Red primary x %f\n", ntohf(imageInfo->red_primary_x));
+	d_printf("Red primary y %f\n", ntohf(imageInfo->red_primary_y));
+	d_printf("Green primary x %f\n", ntohf(imageInfo->green_primary_x));
+	d_printf("Green primary y %f\n", ntohf(imageInfo->green_primary_y));
+	d_printf("Blue primary x %f\n", ntohf(imageInfo->blue_primary_x));
+	d_printf("Blue primary y %f\n", ntohf(imageInfo->blue_primary_y));
+	d_printf("Label \"%s\"\n", imageInfo->label);
+}
+
+static void
+fillCineonFormatInfo(CineonFile* cineon, CineonFormatInformation* formatInfo) {
+
+	formatInfo->interleave = 0;
+	formatInfo->packing = 5;
+	formatInfo->signage = 0;
+	formatInfo->sense = 0;
+	formatInfo->line_padding = htonl(0);
+	formatInfo->channel_padding = htonl(0);
+}
+
+static void
+dumpCineonFormatInfo(CineonFormatInformation* formatInfo) {
+	d_printf("\n--Format Information--\n");
+	d_printf("Interleave %d,", formatInfo->interleave);
+	switch (formatInfo->interleave) {
+		case 0: d_printf(" pixel interleave\n"); break;
+		case 1: d_printf(" line interleave\n"); break;
+		case 2: d_printf(" channel interleave\n"); break;
+		default: d_printf(" (unknown)\n"); break;
+	}
+	d_printf("Packing %d,", formatInfo->packing);
+	if (formatInfo->packing & 0x80) { 
+		d_printf(" multi pixel,");
+	} else {
+		d_printf(" single pixel,");
+	}
+	switch (formatInfo->packing & 0x7F) {
+		case 0: d_printf(" tight\n"); break;
+		case 1: d_printf(" byte packed left\n"); break;
+		case 2: d_printf(" byte packed right\n"); break;
+		case 3: d_printf(" word packed left\n"); break;
+		case 4: d_printf(" word packed right\n"); break;
+		case 5: d_printf(" long packed left\n"); break;
+		case 6: d_printf(" long packed right\n"); break;
+		default: d_printf(" (unknown)\n"); break;
+	}
+	d_printf("Sign %d,", formatInfo->signage);
+	if (formatInfo->signage) { 
+		d_printf(" signed\n");
+	} else {
+		d_printf(" unsigned\n");
+	}
+	d_printf("Sense %d,", formatInfo->signage);
+	if (formatInfo->signage) { 
+		d_printf(" negative\n");
+	} else {
+		d_printf(" positive\n");
+	}
+	d_printf("End of line padding %ld\n", ntohl(formatInfo->line_padding));
+	d_printf("End of channel padding %ld\n", ntohl(formatInfo->channel_padding));
+}
+
+static void
+fillCineonOriginationInfo(CineonFile* cineon,
+	CineonOriginationInformation* originInfo, CineonFileInformation* fileInfo) {
+
+	originInfo->x_offset = htonl(0);
+	originInfo->y_offset = htonl(0);
+	strcpy(originInfo->file_name, fileInfo->file_name);
+	strcpy(originInfo->create_date, fileInfo->create_date);
+	strcpy(originInfo->create_time, fileInfo->create_time);
+	strncpy(originInfo->input_device, "David's Cineon writer", 64);
+	strncpy(originInfo->model_number, "Software", 32);
+	strncpy(originInfo->serial_number, "001", 32);
+	originInfo->x_input_samples_per_mm = htonf(undefined());
+	originInfo->y_input_samples_per_mm =	htonf(undefined());
+	/* this should probably be undefined, too */
+	originInfo->input_device_gamma = htonf(1.0);
+}
+
+static void
+dumpCineonOriginationInfo(CineonOriginationInformation* originInfo) {
+	d_printf("\n--Origination Information--\n");
+	d_printf("X offset %ld\n", ntohl(originInfo->x_offset));
+	d_printf("Y offset %ld\n", ntohl(originInfo->y_offset));
+	d_printf("File name \"%s\"\n", originInfo->file_name);
+	d_printf("Creation date \"%s\"\n", originInfo->create_date);
+	d_printf("Creation time \"%s\"\n", originInfo->create_time);
+	d_printf("Input device \"%s\"\n", originInfo->input_device);
+	d_printf("Model number \"%s\"\n", originInfo->model_number);
+	d_printf("Serial number \"%s\"\n", originInfo->serial_number);
+	d_printf("Samples per mm in x %f\n", ntohf(originInfo->x_input_samples_per_mm));
+	d_printf("Samples per mm in y %f\n", ntohf(originInfo->y_input_samples_per_mm));
+	d_printf("Input device gamma %f\n", ntohf(originInfo->input_device_gamma));
+}
+
+int
+initCineonGenericHeader(CineonFile* cineon, CineonGenericHeader* header, const char* imagename) {
+
+	fillCineonFileInfo(cineon, &header->fileInfo, imagename);
+	fillCineonImageInfo(cineon, &header->imageInfo);
+	fillCineonFormatInfo(cineon, &header->formatInfo);
+	fillCineonOriginationInfo(cineon, &header->originInfo, &header->fileInfo);
+
+	return 0;
+}
+
+void
+dumpCineonGenericHeader(CineonGenericHeader* header) {
+	dumpCineonFileInfo(&header->fileInfo);
+	dumpCineonImageInfo(&header->imageInfo);
+	dumpCineonFormatInfo(&header->formatInfo);
+	dumpCineonOriginationInfo(&header->originInfo);
+}
+
+static int verbose = 0;
+void
+cineonSetVerbose(int verbosity) {
+	verbose = verbosity;
+}
+
+static void
+verboseMe(CineonFile* cineon) {
+
+	d_printf("size %d x %d x %d\n", cineon->width, cineon->height, cineon->depth);
+	d_printf("ImageStart %d, lineBufferLength %d, implied length %d\n",
+		cineon->imageOffset, cineon->lineBufferLength * 4,
+		cineon->imageOffset + cineon->lineBufferLength * 4 * cineon->height);
+}
+
+int
+cineonGetRowBytes(CineonFile* cineon, unsigned short* row, int y) {
+
+	int longsRead;
+	int pixelIndex;
+	int longIndex;
+	int numPixels = cineon->width * cineon->depth;
+
+
+	/* only seek if not reading consecutive lines */
+	if (y != cineon->fileYPos) {
+		int lineOffset = cineon->imageOffset + y * cineon->lineBufferLength * 4;
+		if (verbose) d_printf("Seek in getRowBytes\n");
+		if (logimage_fseek(cineon, lineOffset, SEEK_SET) != 0) {
+			if (verbose) d_printf("Couldn't seek to line %d at %d\n", y, lineOffset);
+			return 1;
+		}
+		cineon->fileYPos = y;
+	}
+
+	longsRead = logimage_fread(cineon->lineBuffer, 4, cineon->lineBufferLength, cineon);
+	if (longsRead != cineon->lineBufferLength) {
+		if (verbose) 
+	{	d_printf("Couldn't read line %d length %d\n", y, cineon->lineBufferLength * 4);
+		perror("cineonGetRowBytes");
+	}
+		return 1;
+	}
+
+	/* remember where we left the car, honey */
+	++cineon->fileYPos;
+
+	/* convert longwords to pixels */
+	pixelIndex = 0;
+	for (longIndex = 0; longIndex < cineon->lineBufferLength; ++longIndex) {
+		unsigned int t = ntohl(cineon->lineBuffer[longIndex]);
+		t = t >> 2;
+		cineon->pixelBuffer[pixelIndex+2] = (unsigned short) t & 0x3ff;
+		t = t >> 10;
+		cineon->pixelBuffer[pixelIndex+1] = (unsigned short) t & 0x3ff;
+		t = t >> 10;
+		cineon->pixelBuffer[pixelIndex] = (unsigned short) t & 0x3ff;
+		pixelIndex += 3;
+	}
+
+	/* extract required pixels */
+	for (pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
+		/* row[pixelIndex] = cineon->lut10[cineon->pixelBuffer[pixelIndex]]; */
+		row[pixelIndex] = cineon->pixelBuffer[pixelIndex] << 6;
+	}
+
+	return 0;
+}
+
+int
+cineonSetRowBytes(CineonFile* cineon, const unsigned short* row, int y) {
+
+	int pixelIndex;
+	int numPixels = cineon->width * cineon->depth;
+	int longIndex;
+	int longsWritten;
+
+	/* put new pixels into pixelBuffer */
+	for (pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
+		/* cineon->pixelBuffer[pixelIndex] = cineon->lut8[row[pixelIndex]]; */
+		cineon->pixelBuffer[pixelIndex] = row[pixelIndex] >> 6;
+	}
+
+	/* pack into longwords */
+	pixelIndex = 0;
+	for (longIndex = 0; longIndex < cineon->lineBufferLength; ++longIndex) {
+		unsigned int t =
+				(cineon->pixelBuffer[pixelIndex] << 22) |
+				(cineon->pixelBuffer[pixelIndex+1] << 12) |
+				(cineon->pixelBuffer[pixelIndex+2] << 2);
+		cineon->lineBuffer[longIndex] = htonl(t);
+		pixelIndex += 3;
+	}
+
+	/* only seek if not reading consecutive lines */
+	if (y != cineon->fileYPos) {
+		int lineOffset = cineon->imageOffset + y * cineon->lineBufferLength * 4;
+		if (verbose) d_printf("Seek in setRowBytes\n");
+		if (logimage_fseek(cineon, lineOffset, SEEK_SET) != 0) {
+			if (verbose) d_printf("Couldn't seek to line %d at %d\n", y, lineOffset);
+			return 1;
+		}
+		cineon->fileYPos = y;
+	}
+
+	longsWritten = fwrite(cineon->lineBuffer, 4, cineon->lineBufferLength, cineon->file);
+	if (longsWritten != cineon->lineBufferLength) {
+		if (verbose) d_printf("Couldn't write line %d length %d\n", y, cineon->lineBufferLength * 4);
+		return 1;
+	}
+
+	++cineon->fileYPos;
+
+	return 0;
+}
+
+int
+cineonGetRow(CineonFile* cineon, unsigned short* row, int y) {
+
+	int longsRead;
+	int pixelIndex;
+	int longIndex;
+/*	int numPixels = cineon->width * cineon->depth;
+*/
+	/* only seek if not reading consecutive lines */
+	if (y != cineon->fileYPos) {
+		int lineOffset = cineon->imageOffset + y * cineon->lineBufferLength * 4;
+		if (verbose) d_printf("Seek in getRow\n");
+		if (logimage_fseek(cineon, lineOffset, SEEK_SET) != 0) {
+			if (verbose) d_printf("Couldn't seek to line %d at %d\n", y, lineOffset);
+			return 1;
+		}
+		cineon->fileYPos = y;
+	}
+
+	longsRead = logimage_fread(cineon->lineBuffer, 4, cineon->lineBufferLength, cineon);
+	if (longsRead != cineon->lineBufferLength) {
+		if (verbose) d_printf("Couldn't read line %d length %d\n", y, cineon->lineBufferLength * 4);
+		return 1;
+	}
+
+	/* remember where we left the car, honey */
+	++cineon->fileYPos;
+
+	/* convert longwords to pixels */
+	pixelIndex = 0;
+	for (longIndex = 0; longIndex < cineon->lineBufferLength; ++longIndex) {
+		unsigned int t = ntohl(cineon->lineBuffer[longIndex]);
+		t = t >> 2;
+		row[pixelIndex+2] = (unsigned short) t & 0x3ff;
+		t = t >> 10;
+		row[pixelIndex+1] = (unsigned short) t & 0x3ff;
+		t = t >> 10;
+		row[pixelIndex] = (unsigned short) t & 0x3ff;
+		pixelIndex += 3;
+	}
+
+	return 0;
+}
+
+int
+cineonSetRow(CineonFile* cineon, const unsigned short* row, int y) {
+
+	int pixelIndex;
+/*	int numPixels = cineon->width * cineon->depth;
+*/	int longIndex;
+	int longsWritten;
+
+	/* pack into longwords */
+	pixelIndex = 0;
+	for (longIndex = 0; longIndex < cineon->lineBufferLength; ++longIndex) {
+		unsigned int t =
+				(row[pixelIndex] << 22) |
+				(row[pixelIndex+1] << 12) |
+				(row[pixelIndex+2] << 2);
+		cineon->lineBuffer[longIndex] = htonl(t);
+		pixelIndex += 3;
+	}
+
+	/* only seek if not reading consecutive lines */
+	if (y != cineon->fileYPos) {
+		int lineOffset = cineon->imageOffset + y * cineon->lineBufferLength * 4;
+		if (verbose) d_printf("Seek in setRowBytes\n");
+		if (logimage_fseek(cineon, lineOffset, SEEK_SET) != 0) {
+			if (verbose) d_printf("Couldn't seek to line %d at %d\n", y, lineOffset);
+			return 1;
+		}
+		cineon->fileYPos = y;
+	}
+
+	longsWritten = fwrite(cineon->lineBuffer, 4, cineon->lineBufferLength, cineon->file);
+	if (longsWritten != cineon->lineBufferLength) {
+		if (verbose) d_printf("Couldn't write line %d length %d\n", y, cineon->lineBufferLength * 4);
+		return 1;
+	}
+
+	++cineon->fileYPos;
+
+	return 0;
+}
+
+CineonFile* 
+cineonOpen(const char* filename) {
+
+	CineonGenericHeader header;
+
+	CineonFile* cineon = (CineonFile* )malloc(sizeof(CineonFile));
+	if (cineon == 0) {
+		if (verbose) d_printf("Failed to malloc cineon file structure.\n");
+		return 0;
+	}
+
+	/* for close routine */
+	cineon->file = 0;
+	cineon->lineBuffer = 0;
+	cineon->pixelBuffer = 0;
+	cineon->membuffer = 0;
+	cineon->memcursor = 0;
+	cineon->membuffersize = 0;
+	
+	cineon->file = fopen(filename, "rb");
+	if (cineon->file == 0) {
+		if (verbose) d_printf("Failed to open file \"%s\".\n", filename);
+		cineonClose(cineon);
+		return 0;
+	}
+	cineon->reading = 1;
+
+	if (logimage_fread(&header, sizeof(CineonGenericHeader), 1, cineon) == 0) {
+		if (verbose) d_printf("Not enough data for header in \"%s\".\n", filename);
+		cineonClose(cineon);
+		return 0;
+	}
+
+	/* let's assume cineon files are always network order */
+	if (header.fileInfo.magic_num != ntohl(CINEON_FILE_MAGIC)) {
+		if (verbose) d_printf("Bad magic number %8.8lX in \"%s\".\n",
+			ntohl(header.fileInfo.magic_num), filename);
+		cineonClose(cineon);
+		return 0;
+	}
+
+	if (header.formatInfo.packing != 5) {
+		if (verbose) d_printf("Can't understand packing %d\n", header.formatInfo.packing);
+		cineonClose(cineon);
+		return 0;
+	}
+
+	cineon->width = ntohl(header.imageInfo.channel[0].pixels_per_line);
+	cineon->height = ntohl(header.imageInfo.channel[0].lines_per_image);
+	cineon->depth = header.imageInfo.channels_per_image;
+	/* cineon->bitsPerPixel = 10; */
+	cineon->bitsPerPixel = header.imageInfo.channel[0].bits_per_pixel;
+	cineon->imageOffset = ntohl(header.fileInfo.image_offset);
+
+	cineon->lineBufferLength = pixelsToLongs(cineon->width * cineon->depth);
+	cineon->lineBuffer = malloc(cineon->lineBufferLength * 4);
+	if (cineon->lineBuffer == 0) {
+		if (verbose) d_printf("Couldn't malloc line buffer of size %d\n", cineon->lineBufferLength * 4);
+		cineonClose(cineon);
+		return 0;
+	}
+
+	cineon->pixelBuffer = malloc(cineon->lineBufferLength * 3 * sizeof(unsigned short));
+	if (cineon->pixelBuffer == 0) {
+		if (verbose) d_printf("Couldn't malloc pixel buffer of size %d\n",
+				(cineon->width * cineon->depth) * sizeof(unsigned short));
+		cineonClose(cineon);
+		return 0;
+	}
+	cineon->pixelBufferUsed = 0;
+
+	if (logimage_fseek(cineon, cineon->imageOffset, SEEK_SET) != 0) {
+		if (verbose) d_printf("Couldn't seek to image data at %d\n", cineon->imageOffset);
+		cineonClose(cineon);
+		return 0;
+	}
+	cineon->fileYPos = 0;
+
+	logImageGetByteConversionDefaults(&cineon->params);
+	setupLut(cineon);
+
+	cineon->getRow = &cineonGetRowBytes;
+	cineon->setRow = 0;
+	cineon->close = &cineonClose;
+
+	if (verbose) {
+		verboseMe(cineon);
+	}
+
+	return cineon;
+}
+
+int cineonIsMemFileCineon(unsigned char *mem)
+{
+	unsigned int num;
+	memcpy(&num, mem, sizeof(unsigned int));
+	
+	if (num != ntohl(CINEON_FILE_MAGIC)) {
+		return 0;
+	} else return 1;
+}
+
+CineonFile* 
+cineonOpenFromMem(unsigned char *mem, unsigned int size) {
+
+	CineonGenericHeader header;
+	int i;
+	
+	CineonFile* cineon = (CineonFile* )malloc(sizeof(CineonFile));
+	if (cineon == 0) {
+		if (verbose) d_printf("Failed to malloc cineon file structure.\n");
+		return 0;
+	}
+
+	/* for close routine */
+	cineon->file = 0;
+	cineon->lineBuffer = 0;
+	cineon->pixelBuffer = 0;
+	cineon->membuffer = mem;
+	cineon->membuffersize = size;
+	cineon->memcursor = mem;
+	
+	cineon->file = 0;
+	cineon->reading = 1;
+	verbose = 1;
+	if (size < sizeof(CineonGenericHeader)) {
+		if (verbose) d_printf("Not enough data for header!\n");
+		cineonClose(cineon);
+		return 0;
+	}
+
+	logimage_fread(&header, sizeof(CineonGenericHeader), 1, cineon);
+
+	/* let's assume cineon files are always network order */
+	if (header.fileInfo.magic_num != ntohl(CINEON_FILE_MAGIC)) {
+		if (verbose) d_printf("Bad magic number %8.8lX in\n", ntohl(header.fileInfo.magic_num));
+
+		cineonClose(cineon);
+		return 0;
+	}
+
+	if (header.formatInfo.packing != 5) {
+		if (verbose) d_printf("Can't understand packing %d\n", header.formatInfo.packing);
+		cineonClose(cineon);
+		return 0;
+	}
+
+	cineon->width = ntohl(header.imageInfo.channel[0].pixels_per_line);
+	cineon->height = ntohl(header.imageInfo.channel[0].lines_per_image);
+	cineon->depth = header.imageInfo.channels_per_image;
+	/* cineon->bitsPerPixel = 10; */
+	cineon->bitsPerPixel = header.imageInfo.channel[0].bits_per_pixel;
+	cineon->imageOffset = ntohl(header.fileInfo.image_offset);
+
+	cineon->lineBufferLength = pixelsToLongs(cineon->width * cineon->depth);
+	cineon->lineBuffer = malloc(cineon->lineBufferLength * 4);
+	if (cineon->lineBuffer == 0) {
+		if (verbose) d_printf("Couldn't malloc line buffer of size %d\n", cineon->lineBufferLength * 4);
+		cineonClose(cineon);
+		return 0;
+	}
+
+	cineon->pixelBuffer = malloc(cineon->lineBufferLength * 3 * sizeof(unsigned short));
+	if (cineon->pixelBuffer == 0) {
+		if (verbose) d_printf("Couldn't malloc pixel buffer of size %d\n",
+				(cineon->width * cineon->depth) * sizeof(unsigned short));
+		cineonClose(cineon);
+		return 0;
+	}
+	cineon->pixelBufferUsed = 0;
+
+	i = cineon->imageOffset;
+	
+	if (i >= size) {
+		if (verbose) d_printf("Couldn't seek to image data at %d\n", cineon->imageOffset);
+		cineonClose(cineon);
+		return 0;
+	}
+	cineon->fileYPos = 0;
+
+	logImageGetByteConversionDefaults(&cineon->params);
+	setupLut(cineon);
+
+	cineon->getRow = &cineonGetRowBytes;
+	cineon->setRow = 0;
+	cineon->close = &cineonClose;
+
+	if (verbose) {
+		verboseMe(cineon);
+	}
+
+	return cineon;
+}
+
+
+int
+cineonGetSize(const CineonFile* cineon, int* width, int* height, int* depth) {
+	*width = cineon->width;
+	*height = cineon->height;
+	*depth = cineon->depth;
+	return 0;
+}
+
+CineonFile*
+cineonCreate(const char* filename, int width, int height, int depth) {
+
+	/* Note: always write files in network order */
+	/* By the spec, it shouldn't matter, but ... */
+
+	CineonGenericHeader header;
+	const char* shortFilename = 0;
+
+	CineonFile* cineon = (CineonFile*)malloc(sizeof(CineonFile));
+	if (cineon == 0) {
+		if (verbose) d_printf("Failed to malloc cineon file structure.\n");
+		return 0;
+	}
+
+	memset(&header, 0, sizeof(header));
+
+	/* for close routine */
+	cineon->file = 0;
+	cineon->lineBuffer = 0;
+	cineon->pixelBuffer = 0;
+
+	cineon->file = fopen(filename, "wb");
+	if (cineon->file == 0) {
+		if (verbose) d_printf("Couldn't open file %s\n", filename);
+		cineonClose(cineon);
+		return 0;
+	}
+	cineon->reading = 0;
+
+	cineon->width = width;
+	cineon->height = height;
+	cineon->depth = depth;
+	cineon->bitsPerPixel = 10;
+	cineon->imageOffset = sizeof(CineonGenericHeader);
+
+	cineon->lineBufferLength = pixelsToLongs(cineon->width * cineon->depth);
+	cineon->lineBuffer = malloc(cineon->lineBufferLength * 4);
+	if (cineon->lineBuffer == 0) {
+		if (verbose) d_printf("Couldn't malloc line buffer of size %d\n", cineon->lineBufferLength * 4);
+		cineonClose(cineon);
+		return 0;
+	}
+
+	cineon->pixelBuffer = malloc(cineon->lineBufferLength * 3 * sizeof(unsigned short));
+	if (cineon->pixelBuffer == 0) {
+		if (verbose) d_printf("Couldn't malloc pixel buffer of size %d\n",
+				(cineon->width * cineon->depth) * sizeof(unsigned short));
+		cineonClose(cineon);
+		return 0;
+	}
+	cineon->pixelBufferUsed = 0;
+
+	/* find trailing part of filename */
+	shortFilename = strrchr(filename, '/');
+	if (shortFilename == 0) {
+		shortFilename = filename;
+	} else {
+		++shortFilename;
+	}
+
+	if (initCineonGenericHeader(cineon, &header, shortFilename) != 0) {
+		cineonClose(cineon);
+		return 0;
+	}
+
+	if (fwrite(&header, sizeof(header), 1, cineon->file) == 0) {
+		if (verbose) d_printf("Couldn't write image header\n");
+		cineonClose(cineon);
+		return 0;
+	}
+	cineon->fileYPos = 0;
+
+	logImageGetByteConversionDefaults(&cineon->params);
+	setupLut(cineon);
+
+	cineon->getRow = 0;
+	cineon->setRow = &cineonSetRowBytes;
+	cineon->close = &cineonClose;
+
+	return cineon;
+}
+
+void
+cineonClose(CineonFile* cineon) {
+
+	if (cineon == 0) {
+		return;
+	}
+
+	if (cineon->file) {
+		fclose(cineon->file);
+		cineon->file = 0;
+	}
+
+	if (cineon->lineBuffer) {
+		free(cineon->lineBuffer);
+		cineon->lineBuffer = 0;
+	}
+
+	if (cineon->pixelBuffer) {
+		free(cineon->pixelBuffer);
+		cineon->pixelBuffer = 0;
+	}
+
+	free(cineon);
+}