tools::jpeg Namespace Reference

Classes
struct	error_mgr
class	reader

Typedefs
typedef struct error_mgr *	error_ptr

Functions
bool	write_file (FILE *a_file, int a_quality, unsigned char *a_buffer, unsigned int a_width, unsigned int a_height, unsigned int a_bpp)
bool	write_file_100 (FILE *a_file, unsigned char *a_buffer, unsigned int a_width, unsigned int a_height, unsigned int a_bpp)
void	tools_jpeg_error_exit (j_common_ptr cinfo)
bool	infos_file (FILE *a_file, unsigned int &a_width, unsigned int &a_height, unsigned int &a_bpp)
unsigned char *	read_file (FILE *a_file, unsigned int &a_width, unsigned int &a_height, unsigned int &a_bpp)
bool	is (const std::string &a_file)
bool	infos (std::ostream &a_out, const std::string &a_file, unsigned int &a_width, unsigned int &a_height, unsigned int &a_bpp)
unsigned char *	read (std::ostream &a_out, const std::string &a_file, unsigned int &a_width, unsigned int &a_height, unsigned int &a_bpp)
unsigned char *	read_part (std::ostream &a_out, const std::string &a_file, unsigned int a_sx, unsigned int a_sy, unsigned int a_sw, unsigned int a_sh, unsigned int &a_rw, unsigned int &a_rh, unsigned int &a_rbpp)
bool	write (std::ostream &a_out, const std::string &a_file, unsigned char *a_buffer, unsigned int a_width, unsigned int a_height, unsigned int a_bpp, int a_quality)
bool	to_xpm (std::ostream &a_out, const std::string &a_file, const std::string &a_name, bool a_verbose=false)
bool	concatenate (std::ostream &a_out, const std::vector< std::string > &a_files, unsigned int a_cols, unsigned int a_rows, unsigned int a_bw, unsigned int a_bh, unsigned char a_bc, const std::string &a_file, int a_quality)

Typedef Documentation

error_ptr

typedef struct error_mgr* tools::jpeg::error_ptr

Definition at line 70 of file jpeg.

Function Documentation

concatenate()

bool tools::jpeg::concatenate ( std::ostream &  a_out, const std::vector< std::string > &  a_files, unsigned int  a_cols, unsigned int  a_rows, unsigned int  a_bw, unsigned int  a_bh, unsigned char  a_bc, const std::string &  a_file, int  a_quality  )

inline

Definition at line 501 of file jpeg.

                                                               {
  unsigned int wa,ha,bppa;
  unsigned char* ba =
    tools::image::concatenate
      (a_out,a_files,a_cols,a_rows,a_bw,a_bh,a_bc,read,wa,ha,bppa);
  if(!ba) {
    a_out << "tools::jpeg::concatenate :"
          << " failed to concatenate all buffers."
          << std::endl;
    delete [] ba;
    return false;
  }
 
  FILE* file = ::fopen(a_file.c_str(),"wb");
  if(!file) {
    a_out << "tools::jpeg::concatenate :"
          << " can't open " << file << " for writing."
          << std::endl;
    delete [] ba;
    return false;
  }
 
  if(!write_file(file,a_quality,ba,wa,ha,bppa)) {
    a_out << "tools::jpeg::concatenate :"
          << " can't write " << a_file << "."
          << std::endl;
    delete [] ba;
    ::fclose(file);
    return false;
  }
 
  delete [] ba;
  ::fclose(file);
  return true;
}

infos()

bool tools::jpeg::infos ( std::ostream &  a_out, const std::string &  a_file, unsigned int &  a_width, unsigned int &  a_height, unsigned int &  a_bpp  )

inline

Definition at line 230 of file jpeg.

                                                                                                                              {
  if(!is(a_file)) {
    a_out << "tools::jpeg::infos :"
          << " file " << a_file << " is not jpeg."
          << std::endl;
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  FILE* file = ::fopen(a_file.c_str(),"rb");
  if(!file) {
    a_out << "tools::jpeg::infos :"
          << " can't open " << a_file
          << std::endl;
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  unsigned int w,h,bpp;
  bool status = infos_file(file,w,h,bpp);
 
  ::fclose(file);
 
  if(!status) {
    a_out << "tools::jpeg::infos :"
              << " problem reading " << a_file
              << std::endl;
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  a_width = w;
  a_height = h;
  a_bpp = bpp;
  return true;
}

infos_file()

bool tools::jpeg::infos_file ( FILE *  a_file, unsigned int &  a_width, unsigned int &  a_height, unsigned int &  a_bpp  )

inline

Definition at line 82 of file jpeg.

                                                                                                      {
  //NOTE : G.Barrand : not sure that in case of error, we cleanup properly !
 
  struct jpeg_decompress_struct cinfo;
  struct error_mgr jerr;
 
  cinfo.err = ::jpeg_std_error(&jerr.pub);
  jerr.pub.error_exit = tools_jpeg_error_exit;
  if(::setjmp(jerr.setjmp_buffer)) {
    //printf("debug : out of setjmp\n");
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return false;
  }
 
  ::jpeg_create_decompress(&cinfo);
  ::jpeg_stdio_src(&cinfo,a_file);
  ::jpeg_read_header(&cinfo, TRUE);
 
  ::jpeg_start_decompress(&cinfo);
 
  a_width = cinfo.output_width;
  a_height = cinfo.output_height;
  a_bpp = cinfo.output_components;
 
  ::jpeg_abort_decompress(&cinfo);
  ::jpeg_destroy_decompress(&cinfo);
 
  return true;
}

is()

bool tools::jpeg::is ( const std::string &  a_file )

inline

Definition at line 216 of file jpeg.

                                       {
  FILE* file = ::fopen(a_file.c_str(),"rb");
  if(!file) return false; //if file does not exist, then it is not a jpeg !
  unsigned char head[4];
  size_t nitem = ::fread(head,1,4,file);
  ::fclose(file);
  if(nitem!=4) return false;
  if(head[0]!=255) return false;
  if(head[1]!=216) return false;
  if(head[2]!=255) return false;
  //if(head[3]!=224) return false; //LRI.jpg is 225 !
  return true;
}

read()

unsigned char* tools::jpeg::read ( std::ostream &  a_out, const std::string &  a_file, unsigned int &  a_width, unsigned int &  a_height, unsigned int &  a_bpp  )

inline

Definition at line 273 of file jpeg.

                                                                                                                                       {
  if(!is(a_file)) {
    a_out << "tools::jpeg::read :"
          << " file " << a_file << " is not jpeg."
          << std::endl;
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  FILE* file = ::fopen(a_file.c_str(),"rb");
  if(!file) {
    a_out << "tools::jpeg::read :"
          << " can't open " << a_file
          << std::endl;
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  unsigned int w,h,bpp;
  unsigned char* buffer = read_file(file,w,h,bpp);
 
  ::fclose(file);
 
  if(!buffer) {
    a_out << "tools::jpeg::read :"
              << " problem reading " << a_file
              << std::endl;
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  a_width = w;
  a_height = h;
  a_bpp = bpp;
  return buffer;
}

read_file()

unsigned char* tools::jpeg::read_file ( FILE *  a_file, unsigned int &  a_width, unsigned int &  a_height, unsigned int &  a_bpp  )

inline

Definition at line 114 of file jpeg.

                                                                                                               {
  // the returned buffer must be delete with "delete []".
 
  //NOTE : G.Barrand : not sure that in case of error, we cleanup properly !
 
  struct jpeg_decompress_struct cinfo;
  struct error_mgr jerr;
 
  cinfo.err = ::jpeg_std_error(&jerr.pub);
  jerr.pub.error_exit = tools_jpeg_error_exit;
  if(::setjmp(jerr.setjmp_buffer)) {
#ifdef TOOLS_JPEG_OUT_ERR
    ::printf("tools::jpeg::read_file : out of setjmp\n");
#endif
    //NOTE : how to be sure to delete the below new if having been done ?
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  ::jpeg_create_decompress(&cinfo);
  ::jpeg_stdio_src(&cinfo,a_file);
  ::jpeg_read_header(&cinfo, TRUE);
 
  ::jpeg_start_decompress(&cinfo);
 
  int row_stride = cinfo.output_width * cinfo.output_components;
 
  if((!cinfo.output_width)||
     (!cinfo.output_height)||
     (cinfo.output_components<=0)) {
#ifdef TOOLS_JPEG_OUT_ERR
    ::printf("tools::jpeg::read_file : bad size, w %u h %u cpnts %d\n",
             cinfo.output_width,cinfo.output_height,cinfo.output_components);
#endif
    ::jpeg_abort_decompress(&cinfo);
    ::jpeg_destroy_decompress(&cinfo);
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  a_width = cinfo.output_width;
  a_height = cinfo.output_height;
  a_bpp = cinfo.output_components;
 
  unsigned char* image_buffer = new unsigned char[row_stride * cinfo.output_height];
  if(!image_buffer) {
#ifdef TOOLS_JPEG_OUT_ERR
    ::printf("tools::jpeg::read_file : alloc of %d bytes failed\n",
        row_stride * cinfo.output_height);
#endif
    ::jpeg_abort_decompress(&cinfo);
    ::jpeg_destroy_decompress(&cinfo);
    a_width = 0;
    a_height = 0;
    a_bpp = 0;
    return 0;
  }
 
  //FIXME : iPad : the below crashes on LHCb_artist_16384_4096_80.jpg.
 
 {JSAMPROW buffer[1];
  unsigned char* pos = image_buffer + row_stride * cinfo.output_height;
  while (cinfo.output_scanline<cinfo.output_height) {
    pos -= row_stride;
    buffer[0] = pos;
    if(::jpeg_read_scanlines(&cinfo, buffer, 1)!=1) {
#ifdef TOOLS_JPEG_OUT_ERR
      ::printf("tools::jpeg::read_file : jpeg_read_scanlines failed\n");
#endif
      ::jpeg_abort_decompress(&cinfo);
      ::jpeg_destroy_decompress(&cinfo);
      a_width = 0;
      a_height = 0;
      a_bpp = 0;
      delete [] image_buffer;
      return 0;
    }
  }}
 
  if(cinfo.output_scanline<cinfo.output_height)
    ::jpeg_abort_decompress(&cinfo);
  else
    ::jpeg_finish_decompress(&cinfo);
 
  ::jpeg_destroy_decompress(&cinfo);
 
  return image_buffer;
}

read_part()

unsigned char* tools::jpeg::read_part ( std::ostream &  a_out, const std::string &  a_file, unsigned int  a_sx, unsigned int  a_sy, unsigned int  a_sw, unsigned int  a_sh, unsigned int &  a_rw, unsigned int &  a_rh, unsigned int &  a_rbpp  )

inline

Definition at line 316 of file jpeg.

                                                      {
  if(!is(a_file)) {
    a_out << "tools::jpeg::read_part :"
          << " file " << a_file << " is not jpeg."
          << std::endl;
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  FILE* file = ::fopen(a_file.c_str(),"rb");
  if(!file) {
    a_out << "tools::jpeg::read_part :"
          << " can't open " << a_file
          << std::endl;
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  struct jpeg_decompress_struct cinfo;
  struct error_mgr jerr;
 
  cinfo.err = ::jpeg_std_error(&jerr.pub);
  jerr.pub.error_exit = tools_jpeg_error_exit;
  if(::setjmp(jerr.setjmp_buffer)) {
    //printf("debug : out of setjmp\n");
    ::fclose(file);
    //NOTE : how to be sure to delete the below news if having been done ?
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  ::jpeg_create_decompress(&cinfo);
  ::jpeg_stdio_src(&cinfo,file);
  ::jpeg_read_header(&cinfo,TRUE);
 
  ::jpeg_start_decompress(&cinfo);
 
  int row_stride = cinfo.output_width * cinfo.output_components;
 
  unsigned int w = cinfo.output_width;
  unsigned int h = cinfo.output_height;
 
  if((a_sx>=w)||(a_sy>=h)){
    ::jpeg_abort_decompress(&cinfo);
    ::jpeg_destroy_decompress(&cinfo);
    ::fclose(file);
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  // 012345
  a_rw = tools::mn<unsigned int>(w-a_sx,a_sw);
  a_rh = tools::mn<unsigned int>(h-a_sy,a_sh);
  a_rbpp = cinfo.output_components;
 
  if(!a_rw||!a_rh||!a_rbpp){
    ::jpeg_abort_decompress(&cinfo);
    ::jpeg_destroy_decompress(&cinfo);
    ::fclose(file);
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  unsigned char* image_buffer = new unsigned char[a_rw*a_rh*a_rbpp];
  if(!image_buffer) {
    ::jpeg_abort_decompress(&cinfo);
    ::jpeg_destroy_decompress(&cinfo);
    ::fclose(file);
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  unsigned char* line = new unsigned char[row_stride];
  if(!line) {
    ::jpeg_abort_decompress(&cinfo);
    ::jpeg_destroy_decompress(&cinfo);
    ::fclose(file);
    delete [] image_buffer;
    a_rw = 0;
    a_rh = 0;
    a_rbpp = 0;
    return 0;
  }
 
  //FIXME : iPad : the below crashes on LHCb_artist_16384_4096_80.jpg.
 
  unsigned int hbeg = a_sy;
  unsigned int hend = a_sy+a_rh;
 
 {JSAMPROW buffer[1];
  buffer[0] = line;
  unsigned char* pos = image_buffer+a_rh*a_rw*a_rbpp;
  while(cinfo.output_scanline<cinfo.output_height) {
    if(jpeg_read_scanlines(&cinfo, buffer, 1)!=1) {
      ::jpeg_abort_decompress(&cinfo);
      ::jpeg_destroy_decompress(&cinfo);
      ::fclose(file);
      delete [] line;
      delete [] image_buffer;
      a_rw = 0;
      a_rh = 0;
      a_rbpp = 0;
      return 0;
    }
    if((hbeg<=cinfo.output_scanline)&&(cinfo.output_scanline<hend)){
      pos -= a_rw*a_rbpp;
      ::memcpy(pos,line+a_sx*a_rbpp,a_rw*a_rbpp);
    }
  }}
 
  if(cinfo.output_scanline<cinfo.output_height)
    ::jpeg_abort_decompress(&cinfo);
  else
    ::jpeg_finish_decompress(&cinfo);
 
  ::jpeg_destroy_decompress(&cinfo);
 
  ::fclose(file);
 
  delete [] line;
 
  return image_buffer;
}

to_xpm()

bool tools::jpeg::to_xpm ( std::ostream &  a_out, const std::string &  a_file, const std::string &  a_name, bool  a_verbose = false  )

inline

Definition at line 489 of file jpeg.

                                                                                                             {
  return tools::xpm::to_xpm(a_out,a_file,a_name,read,a_verbose);
}

tools_jpeg_error_exit()

void tools::jpeg::tools_jpeg_error_exit ( j_common_ptr  cinfo )

inline

Definition at line 73 of file jpeg.

                                                     {
  error_ptr myerr = (error_ptr) cinfo->err;
  //(*cinfo->err->output_message) (cinfo);
  //printf("debug : error_exit\n");
  //NSLog(@"debug : jpeg::error_exit");
  ::longjmp(myerr->setjmp_buffer, 1);
}

write()

bool tools::jpeg::write ( std::ostream &  a_out, const std::string &  a_file, unsigned char *  a_buffer, unsigned int  a_width, unsigned int  a_height, unsigned int  a_bpp, int  a_quality  )

inline

Definition at line 457 of file jpeg.

                                 {
  FILE* file = ::fopen(a_file.c_str(),"wb");
  if(!file) {
    a_out << "tools::jpeg::write :"
          << " can't open file " << tools::sout(a_file) << "."
          << std::endl;
    return false;
  }
  if(!write_file(file,a_quality,a_buffer,a_width,a_height,a_bpp)) {
    ::fclose(file);
    a_out << "tools::jpeg::write :"
          << " can't write file " << tools::sout(a_file) << "."
          << std::endl;
    return false;
  }
  ::fclose(file);
  return true;
}

write_file()

bool tools::jpeg::write_file ( FILE *  a_file, int  a_quality, unsigned char *  a_buffer, unsigned int  a_width, unsigned int  a_height, unsigned int  a_bpp  )

inline

Definition at line 26 of file jpeg.

                                                                                                                                         {
 
  struct jpeg_compress_struct cinfo;
 
  struct jpeg_error_mgr jerr;
  cinfo.err = ::jpeg_std_error(&jerr);
 
  ::jpeg_create_compress(&cinfo);
 
  ::jpeg_stdio_dest(&cinfo,a_file);
 
  cinfo.image_width = a_width;
  cinfo.image_height = a_height;
  cinfo.input_components = a_bpp; // # of color components per pixel.
  cinfo.in_color_space = JCS_RGB;   // colorspace of input image.
 
  ::jpeg_set_defaults(&cinfo);
  ::jpeg_set_quality(&cinfo,a_quality,TRUE);
 
  ::jpeg_start_compress(&cinfo,TRUE);
 
  int row_stride = a_width * cinfo.input_components;
 
  while (cinfo.next_scanline < cinfo.image_height) {
    JSAMPROW row_pointer =
      a_buffer+(cinfo.image_height-1-cinfo.next_scanline) * row_stride;
    ::jpeg_write_scanlines(&cinfo, &row_pointer, 1);
  }
 
  ::jpeg_finish_compress(&cinfo);
  ::jpeg_destroy_compress(&cinfo);
 
  return true;
}

write_file_100()

bool tools::jpeg::write_file_100 ( FILE *  a_file, unsigned char *  a_buffer, unsigned int  a_width, unsigned int  a_height, unsigned int  a_bpp  )

inline

Definition at line 61 of file jpeg.

                                                                                                                               {
  return tools::jpeg::write_file(a_file,100,a_buffer,a_width,a_height,a_bpp);
}