ClangFormat: apply to source, most of intern
Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
This commit is contained in:
@@ -48,7 +48,7 @@
|
||||
/* needed constants */
|
||||
#define MINELEN 8
|
||||
#define MAXELEN 0x7fff
|
||||
#define MINRUN 4 /* minimum run length */
|
||||
#define MINRUN 4 /* minimum run length */
|
||||
#define RED 0
|
||||
#define GRN 1
|
||||
#define BLU 2
|
||||
@@ -58,98 +58,105 @@ typedef unsigned char RGBE[4];
|
||||
typedef float fCOLOR[3];
|
||||
|
||||
/* copy source -> dest */
|
||||
#define COPY_RGBE(c1, c2) (c2[RED] = c1[RED], c2[GRN] = c1[GRN], c2[BLU] = c1[BLU], c2[EXP] = c1[EXP])
|
||||
#define COPY_RGBE(c1, c2) \
|
||||
(c2[RED] = c1[RED], c2[GRN] = c1[GRN], c2[BLU] = c1[BLU], c2[EXP] = c1[EXP])
|
||||
|
||||
/* read routines */
|
||||
static const unsigned char *oldreadcolrs(RGBE *scan, const unsigned char *mem, int xmax, const unsigned char *mem_eof)
|
||||
static const unsigned char *oldreadcolrs(RGBE *scan,
|
||||
const unsigned char *mem,
|
||||
int xmax,
|
||||
const unsigned char *mem_eof)
|
||||
{
|
||||
size_t i, rshift = 0, len = xmax;
|
||||
while (len > 0) {
|
||||
if (UNLIKELY(mem_eof - mem < 4)) {
|
||||
return NULL;
|
||||
}
|
||||
scan[0][RED] = *mem++;
|
||||
scan[0][GRN] = *mem++;
|
||||
scan[0][BLU] = *mem++;
|
||||
scan[0][EXP] = *mem++;
|
||||
if (scan[0][RED] == 1 && scan[0][GRN] == 1 && scan[0][BLU] == 1) {
|
||||
for (i = scan[0][EXP] << rshift; i > 0; i--) {
|
||||
COPY_RGBE(scan[-1], scan[0]);
|
||||
scan++;
|
||||
len--;
|
||||
}
|
||||
rshift += 8;
|
||||
}
|
||||
else {
|
||||
scan++;
|
||||
len--;
|
||||
rshift = 0;
|
||||
}
|
||||
}
|
||||
return mem;
|
||||
size_t i, rshift = 0, len = xmax;
|
||||
while (len > 0) {
|
||||
if (UNLIKELY(mem_eof - mem < 4)) {
|
||||
return NULL;
|
||||
}
|
||||
scan[0][RED] = *mem++;
|
||||
scan[0][GRN] = *mem++;
|
||||
scan[0][BLU] = *mem++;
|
||||
scan[0][EXP] = *mem++;
|
||||
if (scan[0][RED] == 1 && scan[0][GRN] == 1 && scan[0][BLU] == 1) {
|
||||
for (i = scan[0][EXP] << rshift; i > 0; i--) {
|
||||
COPY_RGBE(scan[-1], scan[0]);
|
||||
scan++;
|
||||
len--;
|
||||
}
|
||||
rshift += 8;
|
||||
}
|
||||
else {
|
||||
scan++;
|
||||
len--;
|
||||
rshift = 0;
|
||||
}
|
||||
}
|
||||
return mem;
|
||||
}
|
||||
|
||||
static const unsigned char *freadcolrs(RGBE *scan, const unsigned char *mem, int xmax, const unsigned char *mem_eof)
|
||||
static const unsigned char *freadcolrs(RGBE *scan,
|
||||
const unsigned char *mem,
|
||||
int xmax,
|
||||
const unsigned char *mem_eof)
|
||||
{
|
||||
if (UNLIKELY(mem_eof - mem < 4)) {
|
||||
return NULL;
|
||||
}
|
||||
if (UNLIKELY(mem_eof - mem < 4)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (UNLIKELY((xmax < MINELEN) | (xmax > MAXELEN))) {
|
||||
return oldreadcolrs(scan, mem, xmax, mem_eof);
|
||||
}
|
||||
if (UNLIKELY((xmax < MINELEN) | (xmax > MAXELEN))) {
|
||||
return oldreadcolrs(scan, mem, xmax, mem_eof);
|
||||
}
|
||||
|
||||
int val = *mem++;
|
||||
if (val != 2) {
|
||||
return oldreadcolrs(scan, mem - 1, xmax, mem_eof);
|
||||
}
|
||||
int val = *mem++;
|
||||
if (val != 2) {
|
||||
return oldreadcolrs(scan, mem - 1, xmax, mem_eof);
|
||||
}
|
||||
|
||||
scan[0][GRN] = *mem++;
|
||||
scan[0][BLU] = *mem++;
|
||||
scan[0][GRN] = *mem++;
|
||||
scan[0][BLU] = *mem++;
|
||||
|
||||
val = *mem++;
|
||||
val = *mem++;
|
||||
|
||||
if (scan[0][GRN] != 2 || scan[0][BLU] & 128) {
|
||||
scan[0][RED] = 2;
|
||||
scan[0][EXP] = val;
|
||||
return oldreadcolrs(scan + 1, mem, xmax - 1, mem_eof);
|
||||
}
|
||||
if (scan[0][GRN] != 2 || scan[0][BLU] & 128) {
|
||||
scan[0][RED] = 2;
|
||||
scan[0][EXP] = val;
|
||||
return oldreadcolrs(scan + 1, mem, xmax - 1, mem_eof);
|
||||
}
|
||||
|
||||
if (UNLIKELY(((scan[0][BLU] << 8) | val) != xmax)) {
|
||||
return NULL;
|
||||
}
|
||||
if (UNLIKELY(((scan[0][BLU] << 8) | val) != xmax)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < 4; i++) {
|
||||
if (UNLIKELY(mem_eof - mem < 2)) {
|
||||
return NULL;
|
||||
}
|
||||
for (size_t j = 0; j < xmax; ) {
|
||||
int code = *mem++;
|
||||
if (code > 128) {
|
||||
code &= 127;
|
||||
if (UNLIKELY(code + j > xmax)) {
|
||||
return NULL;
|
||||
}
|
||||
val = *mem++;
|
||||
while (code--) {
|
||||
scan[j++][i] = (unsigned char)val;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (UNLIKELY(mem_eof - mem < code)) {
|
||||
return NULL;
|
||||
}
|
||||
if (UNLIKELY(code + j > xmax)) {
|
||||
return NULL;
|
||||
}
|
||||
while (code--) {
|
||||
scan[j++][i] = *mem++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (size_t i = 0; i < 4; i++) {
|
||||
if (UNLIKELY(mem_eof - mem < 2)) {
|
||||
return NULL;
|
||||
}
|
||||
for (size_t j = 0; j < xmax;) {
|
||||
int code = *mem++;
|
||||
if (code > 128) {
|
||||
code &= 127;
|
||||
if (UNLIKELY(code + j > xmax)) {
|
||||
return NULL;
|
||||
}
|
||||
val = *mem++;
|
||||
while (code--) {
|
||||
scan[j++][i] = (unsigned char)val;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (UNLIKELY(mem_eof - mem < code)) {
|
||||
return NULL;
|
||||
}
|
||||
if (UNLIKELY(code + j > xmax)) {
|
||||
return NULL;
|
||||
}
|
||||
while (code--) {
|
||||
scan[j++][i] = *mem++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return mem;
|
||||
return mem;
|
||||
}
|
||||
|
||||
/* helper functions */
|
||||
@@ -157,250 +164,270 @@ static const unsigned char *freadcolrs(RGBE *scan, const unsigned char *mem, int
|
||||
/* rgbe -> float color */
|
||||
static void RGBE2FLOAT(RGBE rgbe, fCOLOR fcol)
|
||||
{
|
||||
if (rgbe[EXP] == 0) {
|
||||
fcol[RED] = fcol[GRN] = fcol[BLU] = 0;
|
||||
}
|
||||
else {
|
||||
float f = ldexp(1.0, rgbe[EXP] - (COLXS + 8));
|
||||
fcol[RED] = f * (rgbe[RED] + 0.5f);
|
||||
fcol[GRN] = f * (rgbe[GRN] + 0.5f);
|
||||
fcol[BLU] = f * (rgbe[BLU] + 0.5f);
|
||||
}
|
||||
if (rgbe[EXP] == 0) {
|
||||
fcol[RED] = fcol[GRN] = fcol[BLU] = 0;
|
||||
}
|
||||
else {
|
||||
float f = ldexp(1.0, rgbe[EXP] - (COLXS + 8));
|
||||
fcol[RED] = f * (rgbe[RED] + 0.5f);
|
||||
fcol[GRN] = f * (rgbe[GRN] + 0.5f);
|
||||
fcol[BLU] = f * (rgbe[BLU] + 0.5f);
|
||||
}
|
||||
}
|
||||
|
||||
/* float color -> rgbe */
|
||||
static void FLOAT2RGBE(fCOLOR fcol, RGBE rgbe)
|
||||
{
|
||||
int e;
|
||||
float d = (fcol[RED] > fcol[GRN]) ? fcol[RED] : fcol[GRN];
|
||||
if (fcol[BLU] > d) d = fcol[BLU];
|
||||
if (d <= 1e-32f)
|
||||
rgbe[RED] = rgbe[GRN] = rgbe[BLU] = rgbe[EXP] = 0;
|
||||
else {
|
||||
d = (float)frexp(d, &e) * 256.0f / d;
|
||||
rgbe[RED] = (unsigned char)(fcol[RED] * d);
|
||||
rgbe[GRN] = (unsigned char)(fcol[GRN] * d);
|
||||
rgbe[BLU] = (unsigned char)(fcol[BLU] * d);
|
||||
rgbe[EXP] = (unsigned char)(e + COLXS);
|
||||
}
|
||||
int e;
|
||||
float d = (fcol[RED] > fcol[GRN]) ? fcol[RED] : fcol[GRN];
|
||||
if (fcol[BLU] > d)
|
||||
d = fcol[BLU];
|
||||
if (d <= 1e-32f)
|
||||
rgbe[RED] = rgbe[GRN] = rgbe[BLU] = rgbe[EXP] = 0;
|
||||
else {
|
||||
d = (float)frexp(d, &e) * 256.0f / d;
|
||||
rgbe[RED] = (unsigned char)(fcol[RED] * d);
|
||||
rgbe[GRN] = (unsigned char)(fcol[GRN] * d);
|
||||
rgbe[BLU] = (unsigned char)(fcol[BLU] * d);
|
||||
rgbe[EXP] = (unsigned char)(e + COLXS);
|
||||
}
|
||||
}
|
||||
|
||||
/* ImBuf read */
|
||||
|
||||
int imb_is_a_hdr(const unsigned char *buf)
|
||||
{
|
||||
/* For recognition, Blender only loads first 32 bytes, so use #?RADIANCE id instead */
|
||||
/* update: actually, the 'RADIANCE' part is just an optional program name, the magic word is really only the '#?' part */
|
||||
//if (strstr((char *)buf, "#?RADIANCE")) return 1;
|
||||
if (strstr((char *)buf, "#?")) return 1;
|
||||
// if (strstr((char *)buf, "32-bit_rle_rgbe")) return 1;
|
||||
return 0;
|
||||
/* For recognition, Blender only loads first 32 bytes, so use #?RADIANCE id instead */
|
||||
/* update: actually, the 'RADIANCE' part is just an optional program name, the magic word is really only the '#?' part */
|
||||
//if (strstr((char *)buf, "#?RADIANCE")) return 1;
|
||||
if (strstr((char *)buf, "#?"))
|
||||
return 1;
|
||||
// if (strstr((char *)buf, "32-bit_rle_rgbe")) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct ImBuf *imb_loadhdr(const unsigned char *mem, size_t size, int flags, char colorspace[IM_MAX_SPACE])
|
||||
struct ImBuf *imb_loadhdr(const unsigned char *mem,
|
||||
size_t size,
|
||||
int flags,
|
||||
char colorspace[IM_MAX_SPACE])
|
||||
{
|
||||
struct ImBuf *ibuf;
|
||||
RGBE *sline;
|
||||
fCOLOR fcol;
|
||||
float *rect_float;
|
||||
int found = 0;
|
||||
int width = 0, height = 0;
|
||||
const unsigned char *ptr, *mem_eof = mem + size;
|
||||
char oriY[80], oriX[80];
|
||||
struct ImBuf *ibuf;
|
||||
RGBE *sline;
|
||||
fCOLOR fcol;
|
||||
float *rect_float;
|
||||
int found = 0;
|
||||
int width = 0, height = 0;
|
||||
const unsigned char *ptr, *mem_eof = mem + size;
|
||||
char oriY[80], oriX[80];
|
||||
|
||||
if (imb_is_a_hdr((void *)mem)) {
|
||||
colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_FLOAT);
|
||||
if (imb_is_a_hdr((void *)mem)) {
|
||||
colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_FLOAT);
|
||||
|
||||
/* find empty line, next line is resolution info */
|
||||
size_t x;
|
||||
for (x = 1; x < size; x++) {
|
||||
if ((mem[x - 1] == '\n') && (mem[x] == '\n')) {
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (found && (x < (size + 2))) {
|
||||
if (sscanf((char *)&mem[x + 1], "%79s %d %79s %d", (char *)&oriY, &height,
|
||||
(char *)&oriX, &width) != 4)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
/* find empty line, next line is resolution info */
|
||||
size_t x;
|
||||
for (x = 1; x < size; x++) {
|
||||
if ((mem[x - 1] == '\n') && (mem[x] == '\n')) {
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (found && (x < (size + 2))) {
|
||||
if (sscanf((char *)&mem[x + 1],
|
||||
"%79s %d %79s %d",
|
||||
(char *)&oriY,
|
||||
&height,
|
||||
(char *)&oriX,
|
||||
&width) != 4) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* find end of this line, data right behind it */
|
||||
ptr = (unsigned char *)strchr((char *)&mem[x + 1], '\n');
|
||||
ptr++;
|
||||
/* find end of this line, data right behind it */
|
||||
ptr = (unsigned char *)strchr((char *)&mem[x + 1], '\n');
|
||||
ptr++;
|
||||
|
||||
if (flags & IB_test) ibuf = IMB_allocImBuf(width, height, 32, 0);
|
||||
else ibuf = IMB_allocImBuf(width, height, 32, (flags & IB_rect) | IB_rectfloat);
|
||||
if (flags & IB_test)
|
||||
ibuf = IMB_allocImBuf(width, height, 32, 0);
|
||||
else
|
||||
ibuf = IMB_allocImBuf(width, height, 32, (flags & IB_rect) | IB_rectfloat);
|
||||
|
||||
if (UNLIKELY(ibuf == NULL)) {
|
||||
return NULL;
|
||||
}
|
||||
ibuf->ftype = IMB_FTYPE_RADHDR;
|
||||
if (UNLIKELY(ibuf == NULL)) {
|
||||
return NULL;
|
||||
}
|
||||
ibuf->ftype = IMB_FTYPE_RADHDR;
|
||||
|
||||
if (flags & IB_alphamode_detect)
|
||||
ibuf->flags |= IB_alphamode_premul;
|
||||
if (flags & IB_alphamode_detect)
|
||||
ibuf->flags |= IB_alphamode_premul;
|
||||
|
||||
if (flags & IB_test) {
|
||||
return ibuf;
|
||||
}
|
||||
if (flags & IB_test) {
|
||||
return ibuf;
|
||||
}
|
||||
|
||||
/* read in and decode the actual data */
|
||||
sline = (RGBE *)MEM_mallocN(sizeof(*sline) * width, __func__);
|
||||
rect_float = ibuf->rect_float;
|
||||
/* read in and decode the actual data */
|
||||
sline = (RGBE *)MEM_mallocN(sizeof(*sline) * width, __func__);
|
||||
rect_float = ibuf->rect_float;
|
||||
|
||||
for (size_t y = 0; y < height; y++) {
|
||||
ptr = freadcolrs(sline, ptr, width, mem_eof);
|
||||
if (ptr == NULL) {
|
||||
printf("WARNING! HDR decode error, image may be just truncated, or completely wrong...\n");
|
||||
break;
|
||||
}
|
||||
for (x = 0; x < width; x++) {
|
||||
/* convert to ldr */
|
||||
RGBE2FLOAT(sline[x], fcol);
|
||||
*rect_float++ = fcol[RED];
|
||||
*rect_float++ = fcol[GRN];
|
||||
*rect_float++ = fcol[BLU];
|
||||
*rect_float++ = 1.0f;
|
||||
}
|
||||
}
|
||||
MEM_freeN(sline);
|
||||
if (oriY[0] == '-') IMB_flipy(ibuf);
|
||||
for (size_t y = 0; y < height; y++) {
|
||||
ptr = freadcolrs(sline, ptr, width, mem_eof);
|
||||
if (ptr == NULL) {
|
||||
printf(
|
||||
"WARNING! HDR decode error, image may be just truncated, or completely wrong...\n");
|
||||
break;
|
||||
}
|
||||
for (x = 0; x < width; x++) {
|
||||
/* convert to ldr */
|
||||
RGBE2FLOAT(sline[x], fcol);
|
||||
*rect_float++ = fcol[RED];
|
||||
*rect_float++ = fcol[GRN];
|
||||
*rect_float++ = fcol[BLU];
|
||||
*rect_float++ = 1.0f;
|
||||
}
|
||||
}
|
||||
MEM_freeN(sline);
|
||||
if (oriY[0] == '-')
|
||||
IMB_flipy(ibuf);
|
||||
|
||||
if (flags & IB_rect) {
|
||||
IMB_rect_from_float(ibuf);
|
||||
}
|
||||
if (flags & IB_rect) {
|
||||
IMB_rect_from_float(ibuf);
|
||||
}
|
||||
|
||||
return ibuf;
|
||||
}
|
||||
//else printf("Data not found!\n");
|
||||
}
|
||||
//else printf("Not a valid radiance HDR file!\n");
|
||||
return ibuf;
|
||||
}
|
||||
//else printf("Data not found!\n");
|
||||
}
|
||||
//else printf("Not a valid radiance HDR file!\n");
|
||||
|
||||
return NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* ImBuf write */
|
||||
static int fwritecolrs(FILE *file, int width, int channels, unsigned char *ibufscan, float *fpscan)
|
||||
{
|
||||
int beg, c2, cnt = 0;
|
||||
fCOLOR fcol;
|
||||
RGBE rgbe, *rgbe_scan;
|
||||
int beg, c2, cnt = 0;
|
||||
fCOLOR fcol;
|
||||
RGBE rgbe, *rgbe_scan;
|
||||
|
||||
if (UNLIKELY((ibufscan == NULL) && (fpscan == NULL))) {
|
||||
return 0;
|
||||
}
|
||||
if (UNLIKELY((ibufscan == NULL) && (fpscan == NULL))) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
rgbe_scan = (RGBE *)MEM_mallocN(sizeof(RGBE) * width, "radhdr_write_tmpscan");
|
||||
rgbe_scan = (RGBE *)MEM_mallocN(sizeof(RGBE) * width, "radhdr_write_tmpscan");
|
||||
|
||||
/* convert scanline */
|
||||
for (size_t i = 0, j = 0; i < width; i++) {
|
||||
if (fpscan) {
|
||||
fcol[RED] = fpscan[j];
|
||||
fcol[GRN] = (channels >= 2) ? fpscan[j + 1] : fpscan[j];
|
||||
fcol[BLU] = (channels >= 3) ? fpscan[j + 2] : fpscan[j];
|
||||
}
|
||||
else {
|
||||
fcol[RED] = (float)ibufscan[j] / 255.f;
|
||||
fcol[GRN] = (float)((channels >= 2) ? ibufscan[j + 1] : ibufscan[j]) / 255.f;
|
||||
fcol[BLU] = (float)((channels >= 3) ? ibufscan[j + 2] : ibufscan[j]) / 255.f;
|
||||
}
|
||||
FLOAT2RGBE(fcol, rgbe);
|
||||
COPY_RGBE(rgbe, rgbe_scan[i]);
|
||||
j += channels;
|
||||
}
|
||||
/* convert scanline */
|
||||
for (size_t i = 0, j = 0; i < width; i++) {
|
||||
if (fpscan) {
|
||||
fcol[RED] = fpscan[j];
|
||||
fcol[GRN] = (channels >= 2) ? fpscan[j + 1] : fpscan[j];
|
||||
fcol[BLU] = (channels >= 3) ? fpscan[j + 2] : fpscan[j];
|
||||
}
|
||||
else {
|
||||
fcol[RED] = (float)ibufscan[j] / 255.f;
|
||||
fcol[GRN] = (float)((channels >= 2) ? ibufscan[j + 1] : ibufscan[j]) / 255.f;
|
||||
fcol[BLU] = (float)((channels >= 3) ? ibufscan[j + 2] : ibufscan[j]) / 255.f;
|
||||
}
|
||||
FLOAT2RGBE(fcol, rgbe);
|
||||
COPY_RGBE(rgbe, rgbe_scan[i]);
|
||||
j += channels;
|
||||
}
|
||||
|
||||
if ((width < MINELEN) | (width > MAXELEN)) { /* OOBs, write out flat */
|
||||
int x = fwrite((char *)rgbe_scan, sizeof(RGBE), width, file) - width;
|
||||
MEM_freeN(rgbe_scan);
|
||||
return x;
|
||||
}
|
||||
/* put magic header */
|
||||
putc(2, file);
|
||||
putc(2, file);
|
||||
putc((unsigned char)(width >> 8), file);
|
||||
putc((unsigned char)(width & 255), file);
|
||||
/* put components separately */
|
||||
for (size_t i = 0; i < 4; i++) {
|
||||
for (size_t j = 0; j < width; j += cnt) { /* find next run */
|
||||
for (beg = j; beg < width; beg += cnt) {
|
||||
for (cnt = 1; (cnt < 127) && ((beg + cnt) < width) && (rgbe_scan[beg + cnt][i] == rgbe_scan[beg][i]); cnt++) ;
|
||||
if (cnt >= MINRUN) break; /* long enough */
|
||||
}
|
||||
if (((beg - j) > 1) && ((beg - j) < MINRUN)) {
|
||||
c2 = j + 1;
|
||||
while (rgbe_scan[c2++][i] == rgbe_scan[j][i]) {
|
||||
if (c2 == beg) { /* short run */
|
||||
putc((unsigned char)(128 + beg - j), file);
|
||||
putc((unsigned char)(rgbe_scan[j][i]), file);
|
||||
j = beg;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (j < beg) { /* write out non-run */
|
||||
if ((c2 = beg - j) > 128) c2 = 128;
|
||||
putc((unsigned char)(c2), file);
|
||||
while (c2--) putc(rgbe_scan[j++][i], file);
|
||||
}
|
||||
if (cnt >= MINRUN) { /* write out run */
|
||||
putc((unsigned char)(128 + cnt), file);
|
||||
putc(rgbe_scan[beg][i], file);
|
||||
}
|
||||
else {
|
||||
cnt = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
MEM_freeN(rgbe_scan);
|
||||
return(ferror(file) ? -1 : 0);
|
||||
if ((width < MINELEN) | (width > MAXELEN)) { /* OOBs, write out flat */
|
||||
int x = fwrite((char *)rgbe_scan, sizeof(RGBE), width, file) - width;
|
||||
MEM_freeN(rgbe_scan);
|
||||
return x;
|
||||
}
|
||||
/* put magic header */
|
||||
putc(2, file);
|
||||
putc(2, file);
|
||||
putc((unsigned char)(width >> 8), file);
|
||||
putc((unsigned char)(width & 255), file);
|
||||
/* put components separately */
|
||||
for (size_t i = 0; i < 4; i++) {
|
||||
for (size_t j = 0; j < width; j += cnt) { /* find next run */
|
||||
for (beg = j; beg < width; beg += cnt) {
|
||||
for (cnt = 1; (cnt < 127) && ((beg + cnt) < width) &&
|
||||
(rgbe_scan[beg + cnt][i] == rgbe_scan[beg][i]);
|
||||
cnt++)
|
||||
;
|
||||
if (cnt >= MINRUN)
|
||||
break; /* long enough */
|
||||
}
|
||||
if (((beg - j) > 1) && ((beg - j) < MINRUN)) {
|
||||
c2 = j + 1;
|
||||
while (rgbe_scan[c2++][i] == rgbe_scan[j][i]) {
|
||||
if (c2 == beg) { /* short run */
|
||||
putc((unsigned char)(128 + beg - j), file);
|
||||
putc((unsigned char)(rgbe_scan[j][i]), file);
|
||||
j = beg;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (j < beg) { /* write out non-run */
|
||||
if ((c2 = beg - j) > 128)
|
||||
c2 = 128;
|
||||
putc((unsigned char)(c2), file);
|
||||
while (c2--)
|
||||
putc(rgbe_scan[j++][i], file);
|
||||
}
|
||||
if (cnt >= MINRUN) { /* write out run */
|
||||
putc((unsigned char)(128 + cnt), file);
|
||||
putc(rgbe_scan[beg][i], file);
|
||||
}
|
||||
else {
|
||||
cnt = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
MEM_freeN(rgbe_scan);
|
||||
return (ferror(file) ? -1 : 0);
|
||||
}
|
||||
|
||||
static void writeHeader(FILE *file, int width, int height)
|
||||
{
|
||||
fprintf(file, "#?RADIANCE");
|
||||
fputc(10, file);
|
||||
fprintf(file, "# %s", "Created with Blender");
|
||||
fputc(10, file);
|
||||
fprintf(file, "EXPOSURE=%25.13f", 1.0);
|
||||
fputc(10, file);
|
||||
fprintf(file, "FORMAT=32-bit_rle_rgbe");
|
||||
fputc(10, file);
|
||||
fputc(10, file);
|
||||
fprintf(file, "-Y %d +X %d", height, width);
|
||||
fputc(10, file);
|
||||
fprintf(file, "#?RADIANCE");
|
||||
fputc(10, file);
|
||||
fprintf(file, "# %s", "Created with Blender");
|
||||
fputc(10, file);
|
||||
fprintf(file, "EXPOSURE=%25.13f", 1.0);
|
||||
fputc(10, file);
|
||||
fprintf(file, "FORMAT=32-bit_rle_rgbe");
|
||||
fputc(10, file);
|
||||
fputc(10, file);
|
||||
fprintf(file, "-Y %d +X %d", height, width);
|
||||
fputc(10, file);
|
||||
}
|
||||
|
||||
int imb_savehdr(struct ImBuf *ibuf, const char *name, int flags)
|
||||
{
|
||||
FILE *file = BLI_fopen(name, "wb");
|
||||
float *fp = NULL;
|
||||
size_t width = ibuf->x, height = ibuf->y;
|
||||
unsigned char *cp = NULL;
|
||||
FILE *file = BLI_fopen(name, "wb");
|
||||
float *fp = NULL;
|
||||
size_t width = ibuf->x, height = ibuf->y;
|
||||
unsigned char *cp = NULL;
|
||||
|
||||
(void)flags; /* unused */
|
||||
(void)flags; /* unused */
|
||||
|
||||
if (file == NULL) {
|
||||
return 0;
|
||||
}
|
||||
if (file == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
writeHeader(file, width, height);
|
||||
writeHeader(file, width, height);
|
||||
|
||||
if (ibuf->rect)
|
||||
cp = (unsigned char *)ibuf->rect + ibuf->channels * (height - 1) * width;
|
||||
if (ibuf->rect_float)
|
||||
fp = ibuf->rect_float + ibuf->channels * (height - 1) * width;
|
||||
if (ibuf->rect)
|
||||
cp = (unsigned char *)ibuf->rect + ibuf->channels * (height - 1) * width;
|
||||
if (ibuf->rect_float)
|
||||
fp = ibuf->rect_float + ibuf->channels * (height - 1) * width;
|
||||
|
||||
for (size_t y = 0; y < height; y++) {
|
||||
if (fwritecolrs(file, width, ibuf->channels, cp, fp) < 0) {
|
||||
fclose(file);
|
||||
printf("HDR write error\n");
|
||||
return 0;
|
||||
}
|
||||
if (cp) cp -= ibuf->channels * width;
|
||||
if (fp) fp -= ibuf->channels * width;
|
||||
}
|
||||
for (size_t y = 0; y < height; y++) {
|
||||
if (fwritecolrs(file, width, ibuf->channels, cp, fp) < 0) {
|
||||
fclose(file);
|
||||
printf("HDR write error\n");
|
||||
return 0;
|
||||
}
|
||||
if (cp)
|
||||
cp -= ibuf->channels * width;
|
||||
if (fp)
|
||||
fp -= ibuf->channels * width;
|
||||
}
|
||||
|
||||
fclose(file);
|
||||
return 1;
|
||||
fclose(file);
|
||||
return 1;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user