C++ rgbe_error函数代码示例

/* default minimal header. modify if you want more information in header */
int RGBE_WriteHeader(FILE *fp, int width, int height, rgbe_header_info *info,
                     char *errbuf)
{
    const char *programtype = "RADIANCE";
    /* N.B. from Larry Gritz:
     * Plenty of readers will refuse to read .rgbe/.hdr files if their
     * program type is not "RADIANCE".  So I changed the default
     * programtype from Bruce Walter's original "RGBE", which many readers
     * refuse to accept.  (Mac OS X's "preview" utility is one such reader!)
     */

    if (info && (info->valid & RGBE_VALID_PROGRAMTYPE))
        programtype = info->programtype;
    if (fprintf(fp,"#?%s\n",programtype) < 0)
        return rgbe_error(rgbe_write_error,NULL, errbuf);
    /* The #? is to identify file type, the programtype is optional. */
    if (info && (info->valid & RGBE_VALID_GAMMA)) {
        if (fprintf(fp,"GAMMA=%g\n",info->gamma) < 0)
            return rgbe_error(rgbe_write_error,NULL, errbuf);
    }
    if (info && (info->valid & RGBE_VALID_EXPOSURE)) {
        if (fprintf(fp,"EXPOSURE=%g\n",info->exposure) < 0)
            return rgbe_error(rgbe_write_error,NULL, errbuf);
    }
    if (fprintf(fp,"FORMAT=32-bit_rle_rgbe\n\n") < 0)
        return rgbe_error(rgbe_write_error,NULL, errbuf);
    if (fprintf(fp, "-Y %d +X %d\n", height, width) < 0)
        return rgbe_error(rgbe_write_error,NULL, errbuf);
    return RGBE_RETURN_SUCCESS;
}

/* default minimal header. modify if you want more information in header */
int RGBE_WriteHeader(FILE *fp, int width, int height, rgbe_header_info *info)
{
  //char *programtype = "RGBE";
  char *programtype = "RADIANCE";

  //if (info && (info->valid & RGBE_VALID_PROGRAMTYPE))
  //  programtype = info->programtype;
  if (fprintf(fp,"#?%s%c", programtype, 10) < 0)
    return rgbe_error(rgbe_write_error,NULL);
  /* The #? is to identify file type, the programtype is optional. */

  if (fprintf(fp,"# Created with CubeMapGen%c", 10) < 0)
    return rgbe_error(rgbe_write_error,NULL);


  if (info && (info->valid & RGBE_VALID_GAMMA)) {
    if (fprintf(fp,"GAMMA=%g%c",info->gamma, 10) < 0)
      return rgbe_error(rgbe_write_error,NULL);
  }
  /*
  if (info && (info->valid & RGBE_VALID_EXPOSURE)) {
    if (fprintf(fp,"EXPOSURE=%g%c",info->exposure, 10) < 0)
      return rgbe_error(rgbe_write_error,NULL);
  }*/
//  if (fprintf(fp,"FORMAT=32-bit_rle_rgbe\n\n") < 0)
//    return rgbe_error(rgbe_write_error,NULL);
  if (fprintf(fp,"FORMAT=32-bit_rle_rgbe%c%c", 10, 10) < 0)
    return rgbe_error(rgbe_write_error,NULL);
  if (fprintf(fp, "-Y %d +X %d%c", height, width, 10) < 0)
    return rgbe_error(rgbe_write_error,NULL);
  return RGBE_RETURN_SUCCESS;
}

static int RGBE_WriteBytes_RLE(FILE *fp, unsigned char *data, int numbytes,
                               char *errbuf)
{
#define MINRUNLENGTH 4
    int cur, beg_run, run_count, old_run_count, nonrun_count;
    unsigned char buf[2];

    cur = 0;
    while(cur < numbytes) {
        beg_run = cur;
        /* find next run of length at least 4 if one exists */
        run_count = old_run_count = 0;
        while((run_count < MINRUNLENGTH) && (beg_run < numbytes)) {
            beg_run += run_count;
            old_run_count = run_count;
            run_count = 1;
            while((data[beg_run] == data[beg_run + run_count])
                    && (beg_run + run_count < numbytes) && (run_count < 127))
                run_count++;
        }
        /* if data before next big run is a short run then write it as such */
        if ((old_run_count > 1)&&(old_run_count == beg_run - cur)) {
            buf[0] = 128 + old_run_count;   /*write short run*/
            buf[1] = data[cur];
            if (fwrite(buf,sizeof(buf[0])*2,1,fp) < 1)
                return rgbe_error(rgbe_write_error,NULL, errbuf);
            cur = beg_run;
        }
        /* write out bytes until we reach the start of the next run */
        while(cur < beg_run) {
            nonrun_count = beg_run - cur;
            if (nonrun_count > 128)
                nonrun_count = 128;
            buf[0] = nonrun_count;
            if (fwrite(buf,sizeof(buf[0]),1,fp) < 1)
                return rgbe_error(rgbe_write_error,NULL, errbuf);
            if (fwrite(&data[cur],sizeof(data[0])*nonrun_count,1,fp) < 1)
                return rgbe_error(rgbe_write_error,NULL, errbuf);
            cur += nonrun_count;
        }
        /* write out next run if one was found */
        if (run_count >= MINRUNLENGTH) {
            buf[0] = 128 + run_count;
            buf[1] = data[beg_run];
            if (fwrite(buf,sizeof(buf[0])*2,1,fp) < 1)
                return rgbe_error(rgbe_write_error,NULL, errbuf);
            cur += run_count;
        }
    }
    return RGBE_RETURN_SUCCESS;
#undef MINRUNLENGTH
}

int RGBE_ReadPixels_Raw(FILE *fp, unsigned char *data, int numpixels)
{
  if (fread(data, 4, numpixels, fp) < (size_t)numpixels)
    return rgbe_error(rgbe_read_error,NULL);

  return RGBE_RETURN_SUCCESS;
}

int VIGRA_RGBE_ReadPixels_Raw(FILE *fp, unsigned char *data, unsigned int numpixels)
{
  if (fread(data, 4, numpixels, fp) < numpixels)
    return rgbe_error(rgbe_read_error,NULL);

  return VIGRA_RGBE_RETURN_SUCCESS;
}

/* minimal header reading.  modify if you want to parse more information */
int RGBE_ReadHeader(FILE *fp, int *width, int *height, rgbe_header_info *info)
{
    char buf[128];
    int found_format;
    float tempf;
    unsigned int i;

    found_format = 0;
    if (info) {
        info->valid = 0;
        info->programtype[0] = 0;
        info->gamma = info->exposure = 1.0;
    }
    if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == NULL)
        return rgbe_error(rgbe_read_error,NULL);
    if ((buf[0] != '#')||(buf[1] != '?')) {
        /* if you want to require the magic token then uncomment the next line */
        /*return rgbe_error(rgbe_format_error,"bad initial token"); */
    }
    else if (info) {
        info->valid |= RGBE_VALID_PROGRAMTYPE;
        for(i=0; i<sizeof(info->programtype)-1; i++) {
            if ((buf[i+2] == 0) || isspace(buf[i+2]))
                break;
            info->programtype[i] = buf[i+2];
        }
        info->programtype[i] = 0;
        if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
            return rgbe_error(rgbe_read_error,NULL);
    }
    for(;;) {
        if ((buf[0] == 0)||(buf[0] == '\n'))
            return rgbe_error(rgbe_format_error,"no FORMAT specifier found");
        else if (strcmp(buf,"FORMAT=32-bit_rle_rgbe\n") == 0)
            break;       /* format found so break out of loop */
        else if (info && (sscanf(buf,"GAMMA=%g",&tempf) == 1)) {
            info->gamma = tempf;
            info->valid |= RGBE_VALID_GAMMA;
        }
        else if (info && (sscanf(buf,"EXPOSURE=%g",&tempf) == 1)) {
            info->exposure = tempf;
            info->valid |= RGBE_VALID_EXPOSURE;
        }
        if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
            return rgbe_error(rgbe_read_error,NULL);
    }
    if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
        return rgbe_error(rgbe_read_error,NULL);
    if (strcmp(buf,"\n") != 0)
        return rgbe_error(rgbe_format_error,
                          "missing blank line after FORMAT specifier");
    if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
        return rgbe_error(rgbe_read_error,NULL);
    if (sscanf(buf,"-Y %d +X %d",height,width) < 2)
        return rgbe_error(rgbe_format_error,"missing image size specifier");
    return RGBE_RETURN_SUCCESS;
}

/* simple read routine.  will not correctly handle run length encoding */
static int rgbe_read_pixels(struct img_io *io, float *data, int numpixels)
{
	unsigned char rgbe[4];

	while(numpixels-- > 0) {
		if(io->read(rgbe, sizeof(rgbe), io->uptr) < 1)
			return rgbe_error(rgbe_read_error, NULL);
		rgbe2float(&data[RGBE_DATA_RED], &data[RGBE_DATA_GREEN], &data[RGBE_DATA_BLUE], rgbe);
		data += RGBE_DATA_SIZE;
	}
	return RGBE_RETURN_SUCCESS;
}

/* These routines can be made faster by allocating a larger buffer and
   fread-ing and fwrite-ing the data in larger chunks */
static int rgbe_write_pixels(struct img_io *io, float *data, int numpixels)
{
	unsigned char rgbe[4];

	while(numpixels-- > 0) {
		float2rgbe(rgbe, data[RGBE_DATA_RED], data[RGBE_DATA_GREEN], data[RGBE_DATA_BLUE]);
		data += RGBE_DATA_SIZE;
		if(io->write(rgbe, sizeof(rgbe), io->uptr) < 1)
			return rgbe_error(rgbe_write_error, NULL);
	}
	return RGBE_RETURN_SUCCESS;
}

/* simple read routine.  will not correctly handle run length encoding */
int RGBE_ReadPixels(FILE *fp, float *data, int numpixels)
{
    unsigned char rgbe[4];

    while(numpixels-- > 0) {
        if (fread(rgbe, sizeof(rgbe), 1, fp) < 1)
            return rgbe_error(rgbe_read_error,NULL);
        rgbe2float(&data[RGBE_DATA_RED],&data[RGBE_DATA_GREEN],
                   &data[RGBE_DATA_BLUE],rgbe);
        data += RGBE_DATA_SIZE;
    }
    return RGBE_RETURN_SUCCESS;
}

/* These routines can be made faster by allocating a larger buffer and
   fread-ing and fwrite-ing the data in larger chunks */
int RGBE_WritePixels(FILE *fp, float *data, int numpixels)
{
    unsigned char rgbe[4];

    while (numpixels-- > 0) {
        float2rgbe(rgbe,data[RGBE_DATA_RED],
                   data[RGBE_DATA_GREEN],data[RGBE_DATA_BLUE]);
        data += RGBE_DATA_SIZE;
        if (fwrite(rgbe, sizeof(rgbe), 1, fp) < 1)
            return rgbe_error(rgbe_write_error,NULL);
    }
    return RGBE_RETURN_SUCCESS;
}

/* default minimal header. modify if you want more information in header */
int RGBE_WriteHeader(FILE *fp, int width, int height, rgbe_header_info *info)
{
  const unsigned HDR_MAXLINE = 256;
  char buf[HDR_MAXLINE];
  int bufc;
  
  //const char *programtype = "RGBE";
  const char *programtype = "RADIANCE";
  
  if (info && (info->valid & RGBE_VALID_PROGRAMTYPE))
    programtype = info->programtype;
  
  bufc = snprintf(buf, HDR_MAXLINE, "#?%s\n", programtype);
  if(fwrite(buf, 1, bufc, fp) != bufc)
    return rgbe_error(rgbe_write_error,NULL);
  
  if (info && (info->valid & RGBE_VALID_GAMMA)) {
    bufc = snprintf(buf, HDR_MAXLINE, "GAMMA=%g\n", info->gamma);
    if (fwrite(buf, 1, bufc, fp) != bufc)
      return rgbe_error(rgbe_write_error,NULL);
  }
  
  if (info && (info->valid & RGBE_VALID_EXPOSURE)) {
    bufc = snprintf(buf, HDR_MAXLINE, "EXPOSURE=%g\n",info->exposure);
    if (fwrite(buf, 1, bufc, fp) != bufc)
      return rgbe_error(rgbe_write_error,NULL);
  }
  
  bufc = snprintf(buf, HDR_MAXLINE, "FORMAT=32-bit_rle_rgbe\n\n");
  if (fwrite(buf, 1, bufc, fp) != bufc)
    return rgbe_error(rgbe_write_error,NULL);
  
  bufc = snprintf(buf, HDR_MAXLINE, "-Y %d +X %d\n", height, width);
  if (fwrite(buf, 1, bufc, fp) != bufc)
    return rgbe_error(rgbe_write_error,NULL);
  
  return RGBE_RETURN_SUCCESS;
}

/* default minimal header. modify if you want more information in header */
int RGBE_WriteHeader(FILE *fp, int width, int height, rgbe_header_info *info)
{
    char *programtype = "RADIANCE";

    if (info && (info->valid & RGBE_VALID_PROGRAMTYPE))
        programtype = info->programtype;
    if (fprintf(fp,"#?%s\n",programtype) < 0)
        return rgbe_error(rgbe_write_error,NULL);
    /* The #? is to identify file type, the programtype is optional. */
    if (info && (info->valid & RGBE_VALID_GAMMA)) {
        if (fprintf(fp,"GAMMA=%g\n",info->gamma) < 0)
            return rgbe_error(rgbe_write_error,NULL);
    }
    if (info && (info->valid & RGBE_VALID_EXPOSURE)) {
        if (fprintf(fp,"EXPOSURE=%g\n",info->exposure) < 0)
            return rgbe_error(rgbe_write_error,NULL);
    }
    if (fprintf(fp,"FORMAT=32-bit_rle_rgbe\n\n") < 0)
        return rgbe_error(rgbe_write_error,NULL);
    if (fprintf(fp, "-Y %d +X %d\n", height, width) < 0)
        return rgbe_error(rgbe_write_error,NULL);
    return RGBE_RETURN_SUCCESS;
}

int RGBE_WritePixels_RLE(FILE *fp, float *data, int scanline_width,
                         int num_scanlines)
{
    unsigned char rgbe[4];
    unsigned char *buffer;
    int i, err;

    if ((scanline_width < 8)||(scanline_width > 0x7fff))
        /* run length encoding is not allowed so write flat*/
        return RGBE_WritePixels(fp,data,scanline_width*num_scanlines);
    buffer = (unsigned char *)malloc(sizeof(unsigned char)*4*scanline_width);
    if (buffer == NULL)
        /* no buffer space so write flat */
        return RGBE_WritePixels(fp,data,scanline_width*num_scanlines);
    while(num_scanlines-- > 0) {
        rgbe[0] = 2;
        rgbe[1] = 2;
        rgbe[2] = scanline_width >> 8;
        rgbe[3] = scanline_width & 0xFF;
        if (fwrite(rgbe, sizeof(rgbe), 1, fp) < 1) {
            free(buffer);
            return rgbe_error(rgbe_write_error,NULL);
        }
        for(i=0; i<scanline_width; i++) {
            float2rgbe(rgbe,data[RGBE_DATA_RED],
                       data[RGBE_DATA_GREEN],data[RGBE_DATA_BLUE]);
            buffer[i] = rgbe[0];
            buffer[i+scanline_width] = rgbe[1];
            buffer[i+2*scanline_width] = rgbe[2];
            buffer[i+3*scanline_width] = rgbe[3];
            data += RGBE_DATA_SIZE;
        }
        /* write out each of the four channels separately run length encoded */
        /* first red, then green, then blue, then exponent */
        for(i=0; i<4; i++) {
            if ((err = RGBE_WriteBytes_RLE(fp,&buffer[i*scanline_width],
                                           scanline_width)) != RGBE_RETURN_SUCCESS) {
                free(buffer);
                return err;
            }
        }
    }
    free(buffer);
    return RGBE_RETURN_SUCCESS;
}

/* default minimal header. modify if you want more information in header */
static int rgbe_write_header(struct img_io *io, int width, int height, rgbe_header_info * info)
{
	char *buf;
	int ptypelen = 4;
	const char *programtype = "RGBE";

	if(info && (info->valid & RGBE_VALID_PROGRAMTYPE)) {
		programtype = info->programtype;
		ptypelen = strlen(programtype);
	}
	buf = malloc(ptypelen > 120 ? ptypelen + 8 : 128);
	sprintf(buf, "#?%s\n", programtype);
	if(io->write(buf, strlen(buf), io->uptr) < 0)
		goto err;
	/* The #? is to identify file type, the programtype is optional. */
	if(info && (info->valid & RGBE_VALID_GAMMA)) {
		sprintf(buf, "GAMMA=%g\n", info->gamma);
		if(io->write(buf, strlen(buf), io->uptr) < 0)
			goto err;
	}
	if(info && (info->valid & RGBE_VALID_EXPOSURE)) {
		sprintf(buf, "EXPOSURE=%g\n", info->exposure);
		if(io->write(buf, strlen(buf), io->uptr) < 0)
			goto err;
	}
	strcpy(buf, "FORMAT=32-bit_rle_rgbe\n\n");
	if(io->write(buf, strlen(buf), io->uptr) < 0)
		goto err;
	sprintf(buf, "-Y %d +X %d\n", height, width);
	if(io->write(buf, strlen(buf), io->uptr) < 0)
		goto err;

	free(buf);
	return RGBE_RETURN_SUCCESS;
err:
	free(buf);
	return rgbe_error(rgbe_write_error, NULL);
}

//---------------------------------------------------------------------------
int RGBE_ReadPixels_RLE_Components(FILE *fp, unsigned char *data, int scanline_width,
      int num_scanlines)
{
  unsigned char rgbe[4];
  unsigned char *scanline_buffer = NULL;
  unsigned char *ptr;
  unsigned char *ptr_end;

  int i, count;
  unsigned char buf[2];

  if ((scanline_width < 8)||(scanline_width > 0x7fff))
    // run length encoding is not allowed so read flat, but we can't since we want components
    return RGBE_RETURN_FAILURE;
  
  // read in each successive scanline
  while(num_scanlines > 0)
  {
    if (fread(rgbe,sizeof(rgbe),1,fp) < 1)
    {
      free(scanline_buffer);
      return rgbe_error(rgbe_read_error,NULL);
    }
    
    if ((rgbe[0] != 2)||(rgbe[1] != 2)||(rgbe[2] & 0x80))
    {
      
      // this file is not run length encoded
      //rgbe2float(&data[0],&data[1],&data[2],rgbe);
      //data += RGBE_DATA_SIZE;
      free(scanline_buffer);
      //return RGBE_ReadPixels(fp,data,scanline_width*num_scanlines-1);
      return RGBE_RETURN_FAILURE;
    }
    if ((((int)rgbe[2])<<8 | rgbe[3]) != scanline_width)
    {
      free(scanline_buffer);
      return rgbe_error(rgbe_format_error,"wrong scanline width");
    }
    if (scanline_buffer == NULL)
    {
      int memsize = sizeof(unsigned char)*4*scanline_width;
      scanline_buffer = (unsigned char *)malloc(memsize);
      memset( scanline_buffer, 0, memsize );
    }
    if (scanline_buffer == NULL)
    {
      return rgbe_error(rgbe_memory_error,"unable to allocate buffer space");
    }

    ptr = &scanline_buffer[0];
    
    // read each of the four channels for the scanline into the buffer
    for( i = 0; i < 4; i++ )
    {
      ptr_end = &scanline_buffer[(i+1)*scanline_width];
      while(ptr < ptr_end)
      {
        if (fread(buf,sizeof(buf[0])*2,1,fp) < 1)
        {
          free(scanline_buffer);
          return rgbe_error(rgbe_read_error,NULL);
        }
        if (buf[0] > 128)
        {
          // a run of the same value
          count = buf[0]-128;
          if ((count == 0)||(count > ptr_end - ptr))
          {
            free(scanline_buffer);
            return rgbe_error(rgbe_format_error,"bad scanline data");
          }
          while(count-- > 0)
          {
            *ptr++ = buf[1];
          }
        }
        else
        {
          // a non-run
          count = buf[0];
          if ((count == 0)||(count > ptr_end - ptr))
          {
            free(scanline_buffer);
            return rgbe_error(rgbe_format_error,"bad scanline data");
          }
          
          *ptr++ = buf[1];
          
          if (--count > 0)
          {
            if (fread(ptr,sizeof(*ptr)*count,1,fp) < 1)
            {
              free(scanline_buffer);
              return rgbe_error(rgbe_read_error,NULL);
            }
            ptr += count;
          }
        }
//.........这里部分代码省略.........