blob: ff0c5b86798ac8108bd5a7f7696b008f7c2f57c0 [file] [log] [blame]
// ==========================================================
// Kodak PhotoCD Loader
//
// Design and implementation by
// - Floris van den Berg (flvdberg@wxs.nl)
//
// Based on pascal code developed by Alex Kwak
//
// This file is part of FreeImage 3
//
// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
// THIS DISCLAIMER.
//
// Use at your own risk!
// ==========================================================
#include "FreeImage.h"
#include "Utilities.h"
// ==========================================================
// Internal functions
// ==========================================================
static int
clamp(double x) {
int a = (int)floor(x + 0.5);
return (a < 0) ? 0 : (a > 255) ? 255 : a;
}
static void
YUV2RGB(int y, int cb, int cr, int &r, int &g, int &b) {
double c11 = 0.0054980 * 256.0;
double c12 = 0.0000001 * 256.0;
double c13 = 0.0051681 * 256.0;
double c21 = 0.0054980 * 256.0;
double c22 = -0.0015446 * 256.0;
double c23 = -0.0026325 * 256.0;
double c31 = 0.0054980 * 256.0;
double c32 = 0.0079533 * 256.0;
double c33 = 0.0000001 * 256.0;
r = clamp(c11 * y + c12 * (cb - 156) + c13 * (cr - 137));
g = clamp(c21 * y + c22 * (cb - 156) + c23 * (cr - 137));
b = clamp(c31 * y + c32 * (cb - 156) + c33 * (cr - 137));
}
static BOOL
VerticalOrientation(FreeImageIO *io, fi_handle handle) {
char buffer[128];
io->read_proc(buffer, 128, 1, handle);
return (buffer[72] & 63) == 8;
}
// ==========================================================
// Plugin Interface
// ==========================================================
static int s_format_id;
// ==========================================================
// Plugin Implementation
// ==========================================================
static const char * DLL_CALLCONV
Format() {
return "PCD";
}
static const char * DLL_CALLCONV
Description() {
return "Kodak PhotoCD";
}
static const char * DLL_CALLCONV
Extension() {
return "pcd";
}
static const char * DLL_CALLCONV
RegExpr() {
return NULL;
}
static const char * DLL_CALLCONV
MimeType() {
return "image/x-photo-cd";
}
static BOOL DLL_CALLCONV
SupportsExportDepth(int depth) {
return FALSE;
}
static BOOL DLL_CALLCONV
SupportsExportType(FREE_IMAGE_TYPE type) {
return FALSE;
}
static BOOL DLL_CALLCONV
SupportsNoPixels() {
return TRUE;
}
// ----------------------------------------------------------
static FIBITMAP * DLL_CALLCONV
Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
FIBITMAP *dib = NULL;
unsigned width;
unsigned height;
const unsigned bpp = 24;
int scan_line_add = 1;
int start_scan_line = 0;
BYTE *y1 = NULL, *y2 = NULL, *cbcr = NULL;
BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS;
// to make absolute seeks possible we store the current position in the file
long offset_in_file = io->tell_proc(handle);
long seek = 0;
// decide which bitmap in the cabinet to load
switch (flags) {
case PCD_BASEDIV4 :
seek = 0x2000;
width = 192;
height = 128;
break;
case PCD_BASEDIV16 :
seek = 0xB800;
width = 384;
height = 256;
break;
default :
seek = 0x30000;
width = 768;
height = 512;
break;
}
try {
// allocate the dib and write out the header
dib = FreeImage_AllocateHeader(header_only, width, height, bpp, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
if(!dib) throw FI_MSG_ERROR_DIB_MEMORY;
if(header_only) {
return dib;
}
// check if the PCD is bottom-up
if (VerticalOrientation(io, handle)) {
scan_line_add = -1;
start_scan_line = height - 1;
}
// temporary stuff to load PCD
BYTE *y1 = (BYTE*)malloc(width * sizeof(BYTE));
BYTE *y2 = (BYTE*)malloc(width * sizeof(BYTE));
BYTE *cbcr = (BYTE*)malloc(width * sizeof(BYTE));
if(!y1 || !y2 || !cbcr) throw FI_MSG_ERROR_MEMORY;
BYTE *yl[] = { y1, y2 };
// seek to the part where the bitmap data begins
io->seek_proc(handle, offset_in_file, SEEK_SET);
io->seek_proc(handle, seek, SEEK_CUR);
// read the data
for (unsigned y = 0; y < height / 2; y++) {
io->read_proc(y1, width, 1, handle);
io->read_proc(y2, width, 1, handle);
io->read_proc(cbcr, width, 1, handle);
for (int i = 0; i < 2; i++) {
BYTE *bits = FreeImage_GetScanLine(dib, start_scan_line);
for (unsigned x = 0; x < width; x++) {
int r, g, b;
YUV2RGB(yl[i][x], cbcr[x / 2], cbcr[(width / 2) + (x / 2)], r, g, b);
bits[FI_RGBA_BLUE] = (BYTE)b;
bits[FI_RGBA_GREEN] = (BYTE)g;
bits[FI_RGBA_RED] = (BYTE)r;
bits += 3;
}
start_scan_line += scan_line_add;
}
}
free(cbcr);
free(y2);
free(y1);
return dib;
} catch(const char *text) {
if(dib) FreeImage_Unload(dib);
if(cbcr) free(cbcr);
if(y2) free(y2);
if(y1) free(y1);
FreeImage_OutputMessageProc(s_format_id, text);
return NULL;
}
}
// ==========================================================
// Init
// ==========================================================
void DLL_CALLCONV
InitPCD(Plugin *plugin, int format_id) {
s_format_id = format_id;
plugin->format_proc = Format;
plugin->description_proc = Description;
plugin->extension_proc = Extension;
plugin->regexpr_proc = RegExpr;
plugin->open_proc = NULL;
plugin->close_proc = NULL;
plugin->pagecount_proc = NULL;
plugin->pagecapability_proc = NULL;
plugin->load_proc = Load;
plugin->save_proc = NULL;
plugin->validate_proc = NULL;
plugin->mime_proc = MimeType;
plugin->supports_export_bpp_proc = SupportsExportDepth;
plugin->supports_export_type_proc = SupportsExportType;
plugin->supports_icc_profiles_proc = NULL;
plugin->supports_no_pixels_proc = SupportsNoPixels;
}