source/blender/imbuf/intern/radiance_hdr.c

   1 /*
   2  * radiance_hdr.c
   3  *
   4  * $Id:
   5  *
   6  * ***** BEGIN GPL LICENSE BLOCK *****
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  *
  22  * The Original Code is Copyright
  23  * All rights reserved.
  24  *
  25  * The Original Code is: all of this file.
  26  *
  27  * Contributor(s): none yet.
  28  *
  29  * ***** END GPL LICENSE BLOCK *****
  30 */
  31
  32 /* ----------------------------------------------------------------------
  33   Radiance High Dynamic Range image file IO
  34   For description and code for reading/writing of radiance hdr files
  35         by Greg Ward, refer to:
  36   http://radsite.lbl.gov/radiance/refer/Notes/picture_format.html
  37 ----------------------------------------------------------------------
  38 */
  39
  40 #ifdef WIN32
  41 #include <io.h>
  42 #endif
  43 #include "BLI_blenlib.h"
  44
  45 #include "imbuf.h"
  46 #include "imbuf_patch.h"
  47
  48 #include "IMB_imbuf_types.h"
  49 #include "IMB_imbuf.h"
  50
  51 #include "IMB_allocimbuf.h"
  52 #include "IMB_cmap.h"
  53 #include "IMB_radiance_hdr.h"
  54
  55 /* needed constants */
  56 #define MINELEN 8
  57 #define MAXELEN 0x7fff
  58 #define MINRUN  4       /* minimum run length */
  59 #define RED 0
  60 #define GRN 1
  61 #define BLU 2
  62 #define EXP 3
  63 #define COLXS 128
  64 #define STR_MAX 540
  65 typedef unsigned char RGBE[4];
  66 typedef float fCOLOR[3];
  67 /* copy source -> dest */
  68 #define copy_rgbe(c1, c2) (c2[RED]=c1[RED], c2[GRN]=c1[GRN], c2[BLU]=c1[BLU], c2[EXP]=c1[EXP])
  69 #define copy_fcol(f1, f2) (f2[RED]=f1[RED], f2[GRN]=f1[GRN], f2[BLU]=f1[BLU])
  70
  71 /* read routines */
  72 static unsigned char* oldreadcolrs(RGBE *scan, unsigned char *mem, int xmax)
  73 {
  74         int i, rshift = 0, len = xmax;
  75         while (len > 0) {
  76                 scan[0][RED] = *mem++;
  77                 scan[0][GRN] = *mem++;
  78                 scan[0][BLU] = *mem++;
  79                 scan[0][EXP] = *mem++;
  80                 if (scan[0][RED] == 1 && scan[0][GRN] == 1 && scan[0][BLU] == 1) {
  81                         for (i=scan[0][EXP]<<rshift;i>0;i--) {
  82                                 copy_rgbe(scan[-1], scan[0]);
  83                                 scan++;
  84                                 len--;
  85                         }
  86                         rshift += 8;
  87                 }
  88                 else {
  89                         scan++;
  90                         len--;
  91                         rshift = 0;
  92                 }
  93         }
  94         return mem;
  95 }
  96
  97 static unsigned char* freadcolrs(RGBE *scan, unsigned char* mem, int xmax)
  98 {
  99         int i, j, code, val;
 100
 101         if ((xmax < MINELEN) | (xmax > MAXELEN)) return oldreadcolrs(scan, mem, xmax);
 102
 103         i = *mem++;
 104         if (i != 2) return oldreadcolrs(scan, mem-1, xmax);
 105
 106         scan[0][GRN] = *mem++;
 107         scan[0][BLU] = *mem++;
 108
 109         i = *mem++;
 110         if (((scan[0][BLU] << 8) | i) != xmax) return NULL;
 111
 112         for (i=0;i<4;i++)
 113                 for (j=0;j<xmax;) {
 114                         code = *mem++;
 115                         if (code > 128) {
 116                                 code &= 127;
 117                                 val = *mem++;
 118                                 while (code--)
 119                                         scan[j++][i] = (unsigned char)val;
 120                         }
 121                         else
 122                                 while (code--)
 123                                         scan[j++][i] = *mem++;
 124                 }
 125         return mem;
 126 }
 127
 128 /* helper functions */
 129
 130 /* rgbe -> float color */
 131 static void RGBE2FLOAT(RGBE rgbe, fCOLOR fcol)
 132 {
 133         if (rgbe[EXP]==0) {
 134                 fcol[RED] = fcol[GRN] = fcol[BLU] = 0;
 135         }
 136         else {
 137                 float f = ldexp(1.0, rgbe[EXP]-(COLXS+8));
 138                 fcol[RED] = f*(rgbe[RED] + 0.5f);
 139                 fcol[GRN] = f*(rgbe[GRN] + 0.5f);
 140                 fcol[BLU] = f*(rgbe[BLU] + 0.5f);
 141         }
 142 }
 143
 144 /* float color -> rgbe */
 145 static void FLOAT2RGBE(fCOLOR fcol, RGBE rgbe)
 146 {
 147         int e;
 148         float d = (fcol[RED]>fcol[GRN]) ? fcol[RED] : fcol[GRN];
 149         if (fcol[BLU]>d) d = fcol[BLU];
 150         if (d <= 1e-32f)
 151                 rgbe[RED] = rgbe[GRN] = rgbe[BLU] = rgbe[EXP] = 0;
 152         else {
 153                 d = frexp(d, &e) * 256.f / d;
 154                 rgbe[RED] = (unsigned char)(fcol[RED] * d);
 155                 rgbe[GRN] = (unsigned char)(fcol[GRN] * d);
 156                 rgbe[BLU] = (unsigned char)(fcol[BLU] * d);
 157                 rgbe[EXP] = (unsigned char)(e + COLXS);
 158         }
 159 }
 160
 161 /* ImBuf read */
 162
 163 int imb_is_a_hdr(void *buf)
 164 {
 165         // For recognition, Blender only loads first 32 bytes, so use #?RADIANCE id instead
 166         // update: actually, the 'RADIANCE' part is just an optional program name, the magic word is really only the '#?' part
 167         //if (strstr((char*)buf, "#?RADIANCE")) return 1;
 168         if (strstr((char*)buf, "#?")) return 1;
 169         // if (strstr((char*)buf, "32-bit_rle_rgbe")) return 1;
 170         return 0;
 171 }
 172
 173 struct ImBuf *imb_loadhdr(unsigned char *mem, int size, int flags)
 174 {
 175         struct ImBuf* ibuf;
 176         RGBE* sline;
 177         fCOLOR fcol;
 178         float* rect_float;
 179         int found=0;
 180         int width=0, height=0;
 181         int x, y;
 182         unsigned char* ptr;
 183         unsigned char* rect;
 184         char oriY[80], oriX[80];
 185         char buff[STR_MAX];
 186
 187         if (imb_is_a_hdr((void*)mem))
 188         {
 189                 /* find empty line, next line is resolution info */
 190                 for (x=1;x<size;x++) {
 191                         if ((mem[x-1]=='\n') && (mem[x]=='\n')) {
 192                                 found = 1;
 193                                 break;
 194                         }
 195                 }
 196                 if (found) {
 197                         BLI_strncpy(buff, (char *)&mem[x+1], sizeof(buff));
 198                         if (sscanf(buff, "%s %d %s %d", (char*)&oriY, &height,
 199                                 (char*)&oriX, &width) != 4) return NULL;
 200
 201                         /* find end of this line, data right behind it */
 202                         ptr = (unsigned char *)strchr((char*)&mem[x+1], '\n');
 203                         ptr++;
 204
 205                         if (flags & IB_test) ibuf = IMB_allocImBuf(width, height, 32, 0, 0);
 206                         else ibuf = IMB_allocImBuf(width, height, 32, IB_rect|IB_rectfloat, 0);
 207
 208                         if (ibuf==NULL) return NULL;
 209                         ibuf->ftype = RADHDR;
 210                         ibuf->xorig = ibuf->yorig = 0;
 211
 212                         if (flags & IB_test) return ibuf;
 213
 214                         /* read in and decode the actual data */
 215                         sline = (RGBE*)MEM_mallocN(sizeof(RGBE)*width, "radhdr_read_tmpscan");
 216                         rect = (unsigned char*)ibuf->rect;
 217                         rect_float = (float *)ibuf->rect_float;
 218
 219                         for (y=0;y<height;y++) {
 220                                 ptr = freadcolrs(sline, ptr, width);
 221                                 if (ptr==NULL) {
 222                                         printf("HDR decode error\n");
 223                                         MEM_freeN(sline);
 224                                         return ibuf;
 225                                 }
 226                                 for (x=0;x<width;x++) {
 227                                         /* convert to ldr */
 228                                         RGBE2FLOAT(sline[x], fcol);
 229                                         *rect_float++ = fcol[RED];
 230                                         *rect_float++ = fcol[GRN];
 231                                         *rect_float++ = fcol[BLU];
 232                                         *rect_float++ = 1.0f;
 233                                         /* Also old oldstyle for the rest of blender which is not using floats yet */
 234                                         // e: changed to simpler tonemapping, previous code was rather slow (is this actually still relevant at all?)
 235                                         fcol[RED] = fcol[RED]/(1.f + fcol[RED]);
 236                                         fcol[GRN] = fcol[GRN]/(1.f + fcol[GRN]);
 237                                         fcol[BLU] = fcol[BLU]/(1.f + fcol[BLU]);
 238                                         *rect++ = (unsigned char)((fcol[RED] < 0.f) ? 0 : ((fcol[RED] > 1.f) ? 255 : (255.f*fcol[RED])));
 239                                         *rect++ = (unsigned char)((fcol[GRN] < 0.f) ? 0 : ((fcol[GRN] > 1.f) ? 255 : (255.f*fcol[GRN])));
 240                                         *rect++ = (unsigned char)((fcol[BLU] < 0.f) ? 0 : ((fcol[BLU] > 1.f) ? 255 : (255.f*fcol[BLU])));
 241                                         *rect++ = 255;
 242                                 }
 243                         }
 244                         MEM_freeN(sline);
 245                         if (oriY[0]=='-') IMB_flipy(ibuf);
 246                         return ibuf;
 247                 }
 248                 //else printf("Data not found!\n");
 249         }
 250         //else printf("Not a valid radiance HDR file!\n");
 251
 252         return NULL;
 253 }
 254
 255 /* ImBuf write */
 256 static int fwritecolrs(FILE* file, int width, unsigned char* ibufscan, float* fpscan)
 257 {
 258         int x, i, j, beg, c2, cnt=0;
 259         fCOLOR fcol;
 260         RGBE rgbe, *rgbe_scan;
 261
 262         if ((ibufscan==NULL) && (fpscan==NULL)) return 0;
 263
 264         rgbe_scan = (RGBE*)MEM_mallocN(sizeof(RGBE)*width, "radhdr_write_tmpscan");
 265
 266         /* convert scanline */
 267         j= 0;
 268         for (i=0;i<width;i++) {
 269                 if (fpscan) {
 270                         fcol[RED] = fpscan[j];
 271                         fcol[GRN] = fpscan[j+1];
 272                         fcol[BLU] = fpscan[j+2];
 273                 } else {
 274                         fcol[RED] = (float)ibufscan[j] / 255.f;
 275                         fcol[GRN] = (float)ibufscan[j+1] / 255.f;
 276                         fcol[BLU] = (float)ibufscan[j+2] /255.f;
 277                 }
 278                 FLOAT2RGBE(fcol, rgbe);
 279                 copy_rgbe(rgbe, rgbe_scan[i]);
 280                 j+=4;
 281         }
 282
 283         if ((width < MINELEN) | (width > MAXELEN)) {    /* OOBs, write out flat */
 284                 x=fwrite((char *)rgbe_scan, sizeof(RGBE), width, file) - width;
 285                 MEM_freeN(rgbe_scan);
 286                 return x;
 287         }
 288         /* put magic header */
 289         putc(2, file);
 290         putc(2, file);
 291         putc((unsigned char)(width >> 8), file);
 292         putc((unsigned char)(width & 255), file);
 293         /* put components seperately */
 294         for (i=0;i<4;i++) {
 295                 for (j=0;j<width;j+=cnt) {      /* find next run */
 296                         for (beg=j;beg<width;beg+=cnt) {
 297                                 for (cnt=1;(cnt<127) && ((beg+cnt)<width) && (rgbe_scan[beg+cnt][i] == rgbe_scan[beg][i]); cnt++);
 298                                 if (cnt>=MINRUN) break;   /* long enough */
 299                         }
 300                         if (((beg-j)>1) && ((beg-j) < MINRUN)) {
 301                                 c2 = j+1;
 302                                 while (rgbe_scan[c2++][i] == rgbe_scan[j][i])
 303                                         if (c2 == beg) {        /* short run */
 304                                                 putc((unsigned char)(128+beg-j), file);
 305                                                 putc((unsigned char)(rgbe_scan[j][i]), file);
 306                                                 j = beg;
 307                                                 break;
 308                                         }
 309                         }
 310                         while (j < beg) {     /* write out non-run */
 311                                 if ((c2 = beg-j) > 128) c2 = 128;
 312                                 putc((unsigned char)(c2), file);
 313                                 while (c2--) putc(rgbe_scan[j++][i], file);
 314                         }
 315                         if (cnt >= MINRUN) {      /* write out run */
 316                                 putc((unsigned char)(128+cnt), file);
 317                                 putc(rgbe_scan[beg][i], file);
 318                         }
 319                         else cnt = 0;
 320                 }
 321         }
 322         MEM_freeN(rgbe_scan);
 323         return(ferror(file) ? -1 : 0);
 324 }
 325
 326 static void writeHeader(FILE *file, int width, int height)
 327 {
 328         fprintf(file, "#?RADIANCE");
 329         fputc(10, file);
 330         fprintf(file, "# %s", "Created with Blender");
 331         fputc(10, file);
 332         fprintf(file, "EXPOSURE=%25.13f", 1.0);
 333         fputc(10, file);
 334         fprintf(file, "FORMAT=32-bit_rle_rgbe");
 335         fputc(10, file);
 336         fputc(10, file);
 337         fprintf(file, "-Y %d +X %d", height, width);
 338         fputc(10, file);
 339 }
 340
 341 short imb_savehdr(struct ImBuf *ibuf, char *name, int flags)
 342 {
 343         FILE* file = fopen(name, "wb");
 344         float *fp= NULL;
 345         int y, width=ibuf->x, height=ibuf->y;
 346         unsigned char *cp= NULL;
 347
 348         if (file==NULL) return 0;
 349
 350         writeHeader(file, width, height);
 351
 352         if(ibuf->rect)
 353                 cp= (unsigned char *)(ibuf->rect + (height-1)*width);
 354         if(ibuf->rect_float)
 355                 fp= ibuf->rect_float + 4*(height-1)*width;
 356
 357         for (y=height-1;y>=0;y--) {
 358                 if (fwritecolrs(file, width, cp, fp) < 0) {
 359                         fclose(file);
 360                         printf("HDR write error\n");
 361                         return 0;
 362                 }
 363                 if(cp) cp-= 4*width;
 364                 if(fp) fp-= 4*width;
 365         }
 366
 367         fclose(file);
 368         return 1;
 369 }
 370