Page MenuHome
Files F25068

dpx_colormagement_v1.diff
Public
Actions

Authored By
Julien Enche (trap)
Nov 13 2013, 5:23 PM
Size
27 KB
Subscribers
None

dpx_colormagement_v1.diff
View Options

Index: release/datafiles/colormanagement/config.ocio
===================================================================
--- release/datafiles/colormanagement/config.ocio (révision 55381)
+++ release/datafiles/colormanagement/config.ocio (copie de travail)
@@ -36,6 +36,7 @@
- !<View> {name: Film, colorspace: srgb8}
- !<View> {name: Raw, colorspace: Raw}
- !<View> {name: Log, colorspace: lg10}
+ - !<View> {name: Cineon, colorspace: Cineon}
DCI-P3:
- !<View> {name: RRT, colorspace: rrt_p3dci}
- !<View> {name: Film, colorspace: p3dci8}
@@ -67,6 +68,18 @@
isdata: false
allocation: lg2
allocationvars: [-8.5, 5]
+
+ - !<ColorSpace>
+ name: Cineon
+ family:
+ equalitygroup:
+ bitdepth: 32f
+ description: |
+ Cineon (Log Film Scan)
+ isdata: false
+ allocation: uniform
+ allocationvars: [-0.125, 1.125]
+ to_reference: !<FileTransform> {src: cineon.spi1d, interpolation: linear}
- !<ColorSpace>
name: Raw
Index: source/blender/editors/space_image/image_buttons.c
===================================================================
--- source/blender/editors/space_image/image_buttons.c (révision 55381)
+++ source/blender/editors/space_image/image_buttons.c (copie de travail)
@@ -826,7 +826,7 @@
uiItemR(col, imfptr, "use_jpeg2k_ycc", 0, NULL, ICON_NONE);
}
- if (imf->imtype == R_IMF_IMTYPE_DPX) {
+/* if (imf->imtype == R_IMF_IMTYPE_DPX) {
uiItemR(col, imfptr, "use_cineon_log", 0, NULL, ICON_NONE);
}
@@ -840,7 +840,7 @@
uiItemR(col, imfptr, "cineon_gamma", 0, NULL, ICON_NONE);
#endif
}
-
+*/
/* color management */
if (color_management &&
(!BKE_imtype_requires_linear_float(imf->imtype) ||
Index: source/blender/imbuf/intern/IMB_colormanagement_intern.h
===================================================================
--- source/blender/imbuf/intern/IMB_colormanagement_intern.h (révision 55381)
+++ source/blender/imbuf/intern/IMB_colormanagement_intern.h (copie de travail)
@@ -93,6 +93,7 @@
struct ColorSpace *colormanage_colorspace_get_indexed(int index);
void colorspace_set_default_role(char *colorspace, int size, int role);
+int colorspace_set_named(char *colorspace, int size, const char *name);
void colormanage_imbuf_set_default_spaces(struct ImBuf *ibuf);
void colormanage_imbuf_make_linear(struct ImBuf *ibuf, const char *from_colorspace);
Index: source/blender/imbuf/intern/cineon/cineon_dpx.c
===================================================================
--- source/blender/imbuf/intern/cineon/cineon_dpx.c (révision 55381)
+++ source/blender/imbuf/intern/cineon/cineon_dpx.c (copie de travail)
@@ -50,6 +50,7 @@
#include "MEM_guardedalloc.h"
+
static struct ImBuf *imb_load_dpx_cineon(unsigned char *mem, size_t size, int use_cineon, int flags,
char colorspace[IM_MAX_SPACE])
{
@@ -57,8 +58,6 @@
LogImageFile *image;
int width, height, depth;
- colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_FLOAT);
-
logImageSetVerbose((G.f & G_DEBUG) ? 1 : 0);
image = logImageOpenFromMemory(mem, size);
@@ -68,6 +67,18 @@
return 0;
}
+ switch (logImageGetColorSpace(image)) {
+ case transfer_PrintingDensity:
+ case transfer_Logarithmic:
+ if (!colorspace_set_named(colorspace, IM_MAX_SPACE, "Cineon")) {
+ colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_BYTE);
+ }
+ break;
+
+ default:
+ colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_BYTE);
+ }
+
logImageGetSize(image, &width, &height, &depth);
ibuf = IMB_allocImBuf(width, height, 32, IB_rectfloat | flags);
@@ -77,7 +88,7 @@
}
if (!(flags & IB_test)) {
- if (logImageGetDataRGBA(image, ibuf->rect_float, 1) != 0) {
+ if (logImageGetDataRGBA(image, ibuf->rect_float) != 0) {
logImageClose(image);
IMB_freeImBuf(ibuf);
return 0;
@@ -100,7 +111,7 @@
float *fbuf;
float *fbuf_ptr;
unsigned char *rect_ptr;
- int x, y, depth, bitspersample, rvalue;
+ int x, y, depth, bitspersample, transfer, rvalue;
if (flags & IB_mem) {
printf("DPX/Cineon: saving in memory is not supported.\n");
@@ -124,8 +135,21 @@
else
bitspersample = 8;
+ if (ibuf->float_colorspace) {
+ if (strcmp(ibuf->float_colorspace->name, "Cineon") == 0)
+ transfer = transfer_PrintingDensity;
+ else if (strcmp(ibuf->float_colorspace->name, "Linear") == 0)
+ transfer = transfer_Linear;
+ else if (strcmp(ibuf->float_colorspace->name, "sRGB") == 0)
+ transfer = transfer_Linear;
+ else
+ transfer = transfer_UserDefined;
+ }
+ else
+ transfer = transfer_Linear;
+
logImage = logImageCreate(filename, use_cineon, ibuf->x, ibuf->y, bitspersample, (depth == 4),
- (ibuf->ftype & CINEON_LOG), -1, -1, -1, "Blender");
+ transfer, -1, -1, -1, "Blender");
if (logImage == 0) {
printf("DPX/Cineon: error creating file.\n");
@@ -145,7 +169,7 @@
memcpy(dst_ptr, src_ptr, 4 * ibuf->x * sizeof(float));
}
- rvalue = (logImageSetDataRGBA(logImage, fbuf, 1) == 0);
+ rvalue = (logImageSetDataRGBA(logImage, fbuf) == 0);
MEM_freeN(fbuf);
}
@@ -169,7 +193,7 @@
fbuf_ptr[3] = (depth == 4) ? ((float)rect_ptr[3] / 255.0f) : 1.0f;
}
}
- rvalue = (logImageSetDataRGBA(logImage, fbuf, 0) == 0);
+ rvalue = (logImageSetDataRGBA(logImage, fbuf) == 0);
MEM_freeN(fbuf);
}
Index: source/blender/imbuf/intern/cineon/dpxlib.c
===================================================================
--- source/blender/imbuf/intern/cineon/dpxlib.c (révision 55381)
+++ source/blender/imbuf/intern/cineon/dpxlib.c (copie de travail)
@@ -382,7 +382,7 @@
}
LogImageFile *dpxCreate(const char *filename, int width, int height, int bitsPerSample, int hasAlpha,
- int isLogarithmic, int referenceWhite, int referenceBlack, float gamma,
+ int transfer, int referenceWhite, int referenceBlack, float gamma,
const char *creator)
{
DpxMainHeader header;
@@ -432,16 +432,12 @@
dpx->element[0].descriptor = descriptor_RGBA;
}
- if (isLogarithmic == 0) {
- dpx->element[0].transfer = transfer_Linear;
+ dpx->element[0].transfer = transfer;
+ if (transfer != transfer_PrintingDensity)
dpx->element[0].refHighQuantity = dpx->element[0].maxValue;
- }
- else {
- dpx->element[0].transfer = transfer_PrintingDensity;
+ else
dpx->element[0].refHighQuantity = 2.048f;
- }
-
dpx->element[0].refLowQuantity = 0;
dpx->element[0].refLowData = 0;
dpx->element[0].refHighData = dpx->element[0].maxValue;
Index: source/blender/imbuf/intern/cineon/dpxlib.h
===================================================================
--- source/blender/imbuf/intern/cineon/dpxlib.h (révision 55381)
+++ source/blender/imbuf/intern/cineon/dpxlib.h (copie de travail)
@@ -151,7 +151,7 @@
void dpxSetVerbose(int verbosity);
LogImageFile *dpxOpen(const unsigned char *byteStuff, int fromMemory, size_t bufferSize);
-LogImageFile *dpxCreate(const char *filename, int width, int height, int bitsPerSample, int hasAlpha, int isLogarithmic, int referenceWhite, int referenceBlack, float gamma, const char *creator);
+LogImageFile *dpxCreate(const char *filename, int width, int height, int bitsPerSample, int hasAlpha, int transfer, int referenceWhite, int referenceBlack, float gamma, const char *creator);
#ifdef __cplusplus
}
Index: source/blender/imbuf/intern/cineon/logImageCore.c
===================================================================
--- source/blender/imbuf/intern/cineon/logImageCore.c (révision 55381)
+++ source/blender/imbuf/intern/cineon/logImageCore.c (copie de travail)
@@ -56,8 +56,8 @@
static int logImageElementGetData12(LogImageFile *dpx, LogImageElement logElement, float *data);
static int logImageElementGetData12Packed(LogImageFile *dpx, LogImageElement logElement, float *data);
static int logImageElementGetData16(LogImageFile *dpx, LogImageElement logElement, float *data);
-static int convertLogElementToRGBA(float *src, float *dst, LogImageFile *logImage, LogImageElement logElement, int dstIsLinearRGB);
-static int convertRGBAToLogElement(float *src, float *dst, LogImageFile *logImage, LogImageElement logElement, int srcIsLinearRGB);
+static int convertLogElementToRGBA(float *src, float *dst, LogImageFile *logImage, LogImageElement logElement);
+static int convertRGBAToLogElement(float *src, float *dst, LogImageFile *logImage, LogImageElement logElement);
/*
@@ -90,13 +90,11 @@
return (magicNum == CINEON_FILE_MAGIC || magicNum == swap_uint(CINEON_FILE_MAGIC, 1));
}
-LogImageFile *logImageOpenFromFile(const char *filename, int cineon)
+LogImageFile *logImageOpenFromFile(const char *filename)
{
unsigned int magicNum;
FILE *f = BLI_fopen(filename, "rb");
- (void)cineon;
-
if (f == 0)
return 0;
@@ -157,6 +155,10 @@
*depth = logImage->depth;
}
+int logImageGetColorSpace(LogImageFile *logImage)
+{
+ return logImage->element[0].transfer;
+}
/*
* Helper
@@ -197,7 +199,7 @@
* Data writing
*/
-int logImageSetDataRGBA(LogImageFile *logImage, float *data, int dataIsLinearRGB)
+int logImageSetDataRGBA(LogImageFile *logImage, float *data)
{
float *elementData;
int returnValue;
@@ -206,7 +208,7 @@
if (elementData == 0)
return 1;
- if (convertRGBAToLogElement(data, elementData, logImage, logImage->element[0], dataIsLinearRGB) != 0) {
+ if (convertRGBAToLogElement(data, elementData, logImage, logImage->element[0]) != 0) {
MEM_freeN(elementData);
return 1;
}
@@ -363,7 +365,7 @@
* Data reading
*/
-int logImageGetDataRGBA(LogImageFile *logImage, float *data, int dataIsLinearRGB)
+int logImageGetDataRGBA(LogImageFile *logImage, float *data)
{
/* Fills data with 32 bits float RGBA values */
int i, j, returnValue, sortedElementData[8], hasAlpha;
@@ -408,7 +410,7 @@
/* only one element, easy case, no need to do anything */
if (logImage->numElements == 1) {
- returnValue = convertLogElementToRGBA(elementData[0], data, logImage, logImage->element[0], dataIsLinearRGB);
+ returnValue = convertLogElementToRGBA(elementData[0], data, logImage, logImage->element[0]);
MEM_freeN(elementData[0]);
}
else {
@@ -551,7 +553,7 @@
if (elementData[i] != 0)
MEM_freeN(elementData[i]);
- returnValue = convertLogElementToRGBA(mergedData, data, logImage, mergedElement, dataIsLinearRGB);
+ returnValue = convertLogElementToRGBA(mergedData, data, logImage, mergedElement);
MEM_freeN(mergedData);
}
return returnValue;
@@ -918,231 +920,64 @@
}
}
-static void getLinToLogLut(float *lut, LogImageFile *logImage, LogImageElement logElement)
+static int convertRGBA_RGB(float *src, float *dst, LogImageFile *logImage, LogImageElement logElement)
{
- float gain, negativeFilmGamma, offset, step;
unsigned int i;
+ float *src_ptr = src;
+ float *dst_ptr = dst;
+ (void) logElement;
- negativeFilmGamma = 0.6;
- step = logElement.refHighQuantity / logElement.maxValue;
- gain = logElement.maxValue / (1.0f - powf(10, (logImage->referenceBlack - logImage->referenceWhite) * step / negativeFilmGamma * logImage->gamma / 1.7f));
- offset = gain - logElement.maxValue;
-
- for (i = 0; i < (int)(logElement.maxValue + 1); i++)
- lut[i] = (logImage->referenceWhite + log10f(powf((i + offset) / gain, 1.7f / logImage->gamma)) / (step / negativeFilmGamma)) / logElement.maxValue;
-}
-
-static void getLogToLinLut(float *lut, LogImageFile *logImage, LogImageElement logElement)
-{
- float breakPoint, gain, kneeGain, kneeOffset, negativeFilmGamma, offset, step, softClip;
- /* float filmGamma; unused */
- unsigned int i;
-
- /* Building the Log -> Lin LUT */
- step = logElement.refHighQuantity / logElement.maxValue;
- negativeFilmGamma = 0.6;
-
- /* these are default values */
- /* filmGamma = 2.2f; unused */
- softClip = 0;
-
- breakPoint = logImage->referenceWhite - softClip;
- gain = logElement.maxValue / (1.0f - powf(10, (logImage->referenceBlack - logImage->referenceWhite) * step / negativeFilmGamma * logImage->gamma / 1.7f));
- offset = gain - logElement.maxValue;
- kneeOffset = powf(10, (breakPoint - logImage->referenceWhite) * step / negativeFilmGamma * logImage->gamma / 1.7f) * gain - offset;
- kneeGain = (logElement.maxValue - kneeOffset) / powf(5 * softClip, softClip / 100);
-
- for (i = 0; i < (int)(logElement.maxValue + 1); i++) {
- if (i < logImage->referenceBlack)
- lut[i] = 0.0f;
- else if (i > breakPoint)
- lut[i] = (powf(i - breakPoint, softClip / 100) * kneeGain + kneeOffset) / logElement.maxValue;
- else
- lut[i] = (powf(10, ((float)i - logImage->referenceWhite) * step / negativeFilmGamma * logImage->gamma / 1.7f) * gain - offset) / logElement.maxValue;
+ for (i = 0; i < logImage->width * logImage->height; i++) {
+ *(dst_ptr++) = *(src_ptr++);
+ *(dst_ptr++) = *(src_ptr++);
+ *(dst_ptr++) = *(src_ptr++);
+ src_ptr++;
}
-}
-static void getLinToSrgbLut(float *lut, LogImageElement logElement)
-{
- unsigned int i;
- float col;
-
- for (i = 0; i < (int)(logElement.maxValue + 1); i++) {
- col = (float)i / logElement.maxValue;
- if (col < 0.0031308f)
- lut[i] = (col < 0.0f) ? 0.0f : col * 12.92f;
- else
- lut[i] = 1.055f * powf(col, 1.0f / 2.4f) - 0.055f;
- }
+ return 0;
}
-static void getSrgbToLinLut(float *lut, LogImageElement logElement)
+static int convertRGB_RGBA(float *src, float *dst, LogImageFile *logImage, LogImageElement logElement)
{
unsigned int i;
- float col;
-
- for (i = 0; i < (int)(logElement.maxValue + 1); i++) {
- col = (float)i / logElement.maxValue;
- if (col < 0.04045f)
- lut[i] = (col < 0.0f) ? 0.0f : col * (1.0f / 12.92f);
- else
- lut[i] = powf((col + 0.055f) * (1.0f / 1.055f), 2.4f);
- }
-}
-
-static int convertRGBA_RGB(float *src, float *dst, LogImageFile *logImage,
- LogImageElement logElement, int elementIsSource)
-{
- unsigned int i;
- float lut[65536];
float *src_ptr = src;
float *dst_ptr = dst;
+ (void) logElement;
- switch (logElement.transfer) {
- case transfer_UserDefined:
- case transfer_Linear:
- case transfer_Logarithmic:
- for (i = 0; i < logImage->width * logImage->height; i++) {
- *(dst_ptr++) = *(src_ptr++);
- *(dst_ptr++) = *(src_ptr++);
- *(dst_ptr++) = *(src_ptr++);
- src_ptr++;
- }
- return 0;
+ for (i = 0; i < logImage->width * logImage->height; i++) {
+ *(dst_ptr++) = *(src_ptr++);
+ *(dst_ptr++) = *(src_ptr++);
+ *(dst_ptr++) = *(src_ptr++);
+ *(dst_ptr++) = 1.0f;
+ }
- case transfer_PrintingDensity:
- if (elementIsSource == 1)
- getLogToLinLut((float *)&lut, logImage, logElement);
- else
- getLinToLogLut((float *)&lut, logImage, logElement);
-
- for (i = 0; i < logImage->width * logImage->height; i++) {
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- src_ptr++;
- }
- return 0;
-
- default:
- return 1;
- }
+ return 0;
}
-static int convertRGB_RGBA(float *src, float *dst, LogImageFile *logImage,
- LogImageElement logElement, int elementIsSource)
+static int convertRGBA_RGBA(float *src, float *dst, LogImageFile *logImage, LogImageElement logElement)
{
- unsigned int i;
- float lut[65536];
- float *src_ptr = src;
- float *dst_ptr = dst;
-
- switch (logElement.transfer) {
- case transfer_UserDefined:
- case transfer_Linear:
- case transfer_Logarithmic:
- for (i = 0; i < logImage->width * logImage->height; i++) {
- *(dst_ptr++) = *(src_ptr++);
- *(dst_ptr++) = *(src_ptr++);
- *(dst_ptr++) = *(src_ptr++);
- *(dst_ptr++) = 1.0f;
- }
- return 0;
-
- case transfer_PrintingDensity:
- if (elementIsSource == 1)
- getLogToLinLut((float *)&lut, logImage, logElement);
- else
- getLinToLogLut((float *)&lut, logImage, logElement);
-
- for (i = 0; i < logImage->width * logImage->height; i++) {
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(dst_ptr++) = 1.0f;
- }
- return 0;
-
- default:
- return 1;
- }
+ (void) logElement;
+ memcpy(dst, src, 4 * logImage->width * logImage->height * sizeof(float));
+ return 0;
}
-static int convertRGBA_RGBA(float *src, float *dst, LogImageFile *logImage,
- LogImageElement logElement, int elementIsSource)
+static int convertABGR_RGBA(float *src, float *dst, LogImageFile *logImage, LogImageElement logElement)
{
unsigned int i;
- float lut[65536];
float *src_ptr = src;
float *dst_ptr = dst;
+ (void) logElement;
- switch (logElement.transfer) {
- case transfer_UserDefined:
- case transfer_Linear:
- case transfer_Logarithmic:
- memcpy(dst, src, 4 * logImage->width * logImage->height * sizeof(float));
- return 0;
-
- case transfer_PrintingDensity:
- if (elementIsSource == 1)
- getLogToLinLut((float *)&lut, logImage, logElement);
- else
- getLinToLogLut((float *)&lut, logImage, logElement);
-
- for (i = 0; i < logImage->width * logImage->height; i++) {
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(dst_ptr++) = *(src_ptr++);
- }
- return 0;
-
- default:
- return 1;
+ for (i = 0; i < logImage->width * logImage->height; i++) {
+ src_ptr += 4;
+ *(dst_ptr++) = *(src_ptr--);
+ *(dst_ptr++) = *(src_ptr--);
+ *(dst_ptr++) = *(src_ptr--);
+ *(dst_ptr++) = *(src_ptr--);
+ src_ptr += 4;
}
-}
-static int convertABGR_RGBA(float *src, float *dst, LogImageFile *logImage,
- LogImageElement logElement, int elementIsSource)
-{
- unsigned int i;
- float lut[65536];
- float *src_ptr = src;
- float *dst_ptr = dst;
-
- switch (logElement.transfer) {
- case transfer_UserDefined:
- case transfer_Linear:
- case transfer_Logarithmic:
- for (i = 0; i < logImage->width * logImage->height; i++) {
- src_ptr += 4;
- *(dst_ptr++) = *(src_ptr--);
- *(dst_ptr++) = *(src_ptr--);
- *(dst_ptr++) = *(src_ptr--);
- *(dst_ptr++) = *(src_ptr--);
- src_ptr += 4;
- }
- return 0;
-
- case transfer_PrintingDensity:
- if (elementIsSource == 1)
- getLogToLinLut((float *)&lut, logImage, logElement);
- else
- getLinToLogLut((float *)&lut, logImage, logElement);
-
- for (i = 0; i < logImage->width * logImage->height; i++) {
- src_ptr += 4;
- *(dst_ptr++) = lut[float_uint(*(src_ptr--), logElement.maxValue)];
- *(dst_ptr++) = lut[float_uint(*(src_ptr--), logElement.maxValue)];
- *(dst_ptr++) = lut[float_uint(*(src_ptr--), logElement.maxValue)];
- *(dst_ptr++) = *(src_ptr--);
- src_ptr += 4;
- }
- return 0;
-
- default:
- return 1;
- }
+ return 0;
}
static int convertCbYCr_RGBA(float *src, float *dst, LogImageFile *logImage, LogImageElement logElement)
@@ -1303,26 +1138,22 @@
}
static int convertLogElementToRGBA(float *src, float *dst, LogImageFile *logImage,
- LogImageElement logElement, int dstIsLinearRGB)
+ LogImageElement logElement)
{
int rvalue;
- unsigned int i;
- float *src_ptr;
- float *dst_ptr;
- float lut[65536];
/* Convert data in src to linear RGBA in dst */
switch (logElement.descriptor) {
case descriptor_RGB:
- rvalue = convertRGB_RGBA(src, dst, logImage, logElement, 1);
+ rvalue = convertRGB_RGBA(src, dst, logImage, logElement);
break;
case descriptor_RGBA:
- rvalue = convertRGBA_RGBA(src, dst, logImage, logElement, 1);
+ rvalue = convertRGBA_RGBA(src, dst, logImage, logElement);
break;
case descriptor_ABGR:
- rvalue = convertABGR_RGBA(src, dst, logImage, logElement, 1);
+ rvalue = convertABGR_RGBA(src, dst, logImage, logElement);
break;
case descriptor_Luminance:
@@ -1353,62 +1184,21 @@
return 1;
}
- if (rvalue == 1)
- return 1;
- else if (dstIsLinearRGB) {
- /* convert data from sRGB to Linear RGB via lut */
- getSrgbToLinLut((float *)&lut, logElement);
- src_ptr = dst; // no error here
- dst_ptr = dst;
- for (i = 0; i < logImage->width * logImage->height; i++) {
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(dst_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- dst_ptr++; src_ptr++;
- }
- }
- return 0;
+ return rvalue;
}
static int convertRGBAToLogElement(float *src, float *dst, LogImageFile *logImage,
- LogImageElement logElement, int srcIsLinearRGB)
+ LogImageElement logElement)
{
- unsigned int i;
int rvalue;
- float *srgbSrc;
- float *srgbSrc_ptr;
- float *src_ptr = src;
- float lut[65536];
- if (srcIsLinearRGB != 0) {
- /* we need to convert src to sRGB */
- srgbSrc = (float *)MEM_mallocN(4 * logImage->width * logImage->height * sizeof(float), __func__);
- if (srgbSrc == 0)
- return 1;
-
- memcpy(srgbSrc, src, 4 * logImage->width * logImage->height * sizeof(float));
- srgbSrc_ptr = srgbSrc;
-
- /* convert data from Linear RGB to sRGB via lut */
- getLinToSrgbLut((float *)&lut, logElement);
- for (i = 0; i < logImage->width * logImage->height; i++) {
- *(srgbSrc_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(srgbSrc_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- *(srgbSrc_ptr++) = lut[float_uint(*(src_ptr++), logElement.maxValue)];
- srgbSrc_ptr++; src_ptr++;
- }
- }
- else
- srgbSrc = src;
-
- /* Convert linear RGBA data in src to format described by logElement in dst */
switch (logElement.descriptor) {
case descriptor_RGB:
- rvalue = convertRGBA_RGB(srgbSrc, dst, logImage, logElement, 0);
+ rvalue = convertRGBA_RGB(src, dst, logImage, logElement);
break;
case descriptor_RGBA:
- rvalue = convertRGBA_RGBA(srgbSrc, dst, logImage, logElement, 0);
+ rvalue = convertRGBA_RGBA(src, dst, logImage, logElement);
break;
/* these ones are not supported for the moment */
@@ -1423,9 +1213,5 @@
rvalue = 1;
}
- if (srcIsLinearRGB != 0) {
- MEM_freeN(srgbSrc);
- }
-
return rvalue;
}
Index: source/blender/imbuf/intern/cineon/logImageCore.h
===================================================================
--- source/blender/imbuf/intern/cineon/logImageCore.h (révision 55381)
+++ source/blender/imbuf/intern/cineon/logImageCore.h (copie de travail)
@@ -190,8 +190,10 @@
int logImageIsDpx(const void *buffer);
int logImageIsCineon(const void *buffer);
LogImageFile *logImageOpenFromMemory(const unsigned char *buffer, unsigned int size);
-LogImageFile *logImageOpenFromFile(const char *filename, int cineon);
+LogImageFile *logImageOpenFromFile(const char *filename);
void logImageGetSize(LogImageFile *logImage, int *width, int *height, int *depth);
+int logImageGetColorSpace(LogImageFile *logImage);
+int logImageSetColorSpace(LogImageFile *logImage);
LogImageFile *logImageCreate(const char *filename, int cineon, int width, int height, int bitsPerSample,
int isLogarithmic, int hasAlpha, int referenceWhite, int referenceBlack,
float gamma, const char *creator);
@@ -199,8 +201,8 @@
/* Data handling */
unsigned int getRowLength(int width, LogImageElement logElement);
-int logImageSetDataRGBA(LogImageFile *logImage, float *data, int dataIsLinearRGB);
-int logImageGetDataRGBA(LogImageFile *logImage, float *data, int dataIsLinearRGB);
+int logImageSetDataRGBA(LogImageFile *logImage, float *data);
+int logImageGetDataRGBA(LogImageFile *logImage, float *data);
/*
* Inline routines
Index: source/blender/imbuf/intern/cineon/logmemfile.c
===================================================================
--- source/blender/imbuf/intern/cineon/logmemfile.c (révision 55381)
+++ source/blender/imbuf/intern/cineon/logmemfile.c (copie de travail)
@@ -36,16 +36,18 @@
int logimage_fseek(LogImageFile *logFile, intptr_t offset, int origin)
{
if (logFile->file)
- fseek(logFile->file, offset, origin);
+ return fseek(logFile->file, offset, origin);
else { /* we're seeking in memory */
if (origin == SEEK_SET) {
if (offset > logFile->memBufferSize)
return 1;
+
logFile->memCursor = logFile->memBuffer + offset;
}
else if (origin == SEEK_END) {
if (offset > logFile->memBufferSize)
return 1;
+
logFile->memCursor = (logFile->memBuffer + logFile->memBufferSize) - offset;
}
else if (origin == SEEK_CUR) {
@@ -55,8 +57,8 @@
logFile->memCursor += offset;
}
+ return 0;
}
- return 0;
}
int logimage_fwrite(void *buffer, size_t size, unsigned int count, LogImageFile *logFile)
@@ -65,7 +67,7 @@
return fwrite(buffer, size, count, logFile->file);
else { /* we're writing to memory */
/* do nothing as this isn't supported yet */
- return count;
+ return 0;
}
}
@@ -85,8 +87,10 @@
total_size = size * count;
}
- if (total_size != 0)
+ if (total_size != 0) {
memcpy(buf, logFile->memCursor, total_size);
+ logFile->memCursor += total_size;
+ }
return count;
}
@@ -94,33 +98,51 @@
int logimage_read_uchar(unsigned char *x, LogImageFile *logFile)
{
- uintptr_t pos = (uintptr_t)logFile->memCursor - (uintptr_t)logFile->memBuffer;
- if (pos + sizeof(unsigned char) > logFile->memBufferSize)
- return 1;
+ if (logFile->file) {
+ return (logimage_fread(x, sizeof(unsigned char), 1, logFile) != 1);
+ }
+ else {
+ /* faster */
+ uintptr_t pos = (uintptr_t)logFile->memCursor - (uintptr_t)logFile->memBuffer;
+ if (pos + sizeof(unsigned char) > logFile->memBufferSize)
+ return 1;
- *x = *(unsigned char *)logFile->memCursor;
- logFile->memCursor += sizeof(unsigned char);
- return 0;
+ *x = *(unsigned char *)logFile->memCursor;
+ logFile->memCursor += sizeof(unsigned char);
+ return 0;
+ }
}
int logimage_read_ushort(unsigned short *x, LogImageFile *logFile)
{
- uintptr_t pos = (uintptr_t)logFile->memCursor - (uintptr_t)logFile->memBuffer;
- if (pos + sizeof(unsigned short) > logFile->memBufferSize)
- return 1;
+ if (logFile->file) {
+ return (logimage_fread(x, sizeof(unsigned short), 1, logFile) != 1);
+ }
+ else {
+ /* faster */
+ uintptr_t pos = (uintptr_t)logFile->memCursor - (uintptr_t)logFile->memBuffer;
+ if (pos + sizeof(unsigned short) > logFile->memBufferSize)
+ return 1;
- *x = *(unsigned short *)logFile->memCursor;
- logFile->memCursor += sizeof(unsigned short);
- return 0;
+ *x = *(unsigned short *)logFile->memCursor;
+ logFile->memCursor += sizeof(unsigned short);
+ return 0;
+ }
}
int logimage_read_uint(unsigned int *x, LogImageFile *logFile)
{
- uintptr_t pos = (uintptr_t)logFile->memCursor - (uintptr_t)logFile->memBuffer;
- if (pos + sizeof(unsigned int) > logFile->memBufferSize)
- return 1;
+ if (logFile->file) {
+ return (logimage_fread(x, sizeof(unsigned int), 1, logFile) != 1);
+ }
+ else {
+ /* faster */
+ uintptr_t pos = (uintptr_t)logFile->memCursor - (uintptr_t)logFile->memBuffer;
+ if (pos + sizeof(unsigned int) > logFile->memBufferSize)
+ return 1;
- *x = *(unsigned int *)logFile->memCursor;
- logFile->memCursor += sizeof(unsigned int);
- return 0;
+ *x = *(unsigned int *)logFile->memCursor;
+ logFile->memCursor += sizeof(unsigned int);
+ return 0;
+ }
}
Index: source/blender/imbuf/intern/colormanagement.c
===================================================================
--- source/blender/imbuf/intern/colormanagement.c (révision 55381)
+++ source/blender/imbuf/intern/colormanagement.c (copie de travail)
@@ -876,6 +876,16 @@
}
}
+int colorspace_set_named(char *colorspace, int size, const char *name)
+{
+ if (colorspace && colorspace[0] == '\0' && colormanage_colorspace_get_named(name)) {
+ BLI_strncpy(colorspace, name, size);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
void colormanage_imbuf_set_default_spaces(ImBuf *ibuf)
{
ibuf->rect_colorspace = colormanage_colorspace_get_named(global_role_default_byte);

File Metadata

Mime Type
text/x-diff
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
dc/98/cd6487c19102a426f1bc711f6e43

Event Timeline