需要帮助在读取JPEG文件使用libjpeg

下面是读取jpeg图像的示例:

/***************************************************
    To read a jpg image file and download
    it as a texture map for openGL
    Derived from Tom Lane's example.c
    -- Obtain & install jpeg stuff from web 
    (jpeglib.h, jerror.h jmore.h, jconfig.h,jpeg.lib)
****************************************************/
#include <jpeglib.h>    
#include <jerror.h>
//================================
GLuint LoadJPEG(char* FileName)
//================================
{
  unsigned long x, y;
  unsigned int texture_id;
  unsigned long data_size;     // length of the file
  int channels;               //  3 =>RGB   4 =>RGBA 
  unsigned int type;  
  unsigned char * rowptr[1];    // pointer to an array
  unsigned char * jdata;        // data for the image
  struct jpeg_decompress_struct info; //for our jpeg info
  struct jpeg_error_mgr err;          //the error handler
  FILE* file = fopen(FileName, "rb");  //open the file
  info.err = jpeg_std_error(& err);     
  jpeg_create_decompress(& info);   //fills info structure
  //if the jpeg file doesn't load
  if(!file) {
     fprintf(stderr, "Error reading JPEG file %s!", FileName);
     return 0;
  }
  jpeg_stdio_src(&info, file);    
  jpeg_read_header(&info, TRUE);   // read jpeg file header
  jpeg_start_decompress(&info);    // decompress the file
  //set width and height
  x = info.output_width;
  y = info.output_height;
  channels = info.num_components;
  type = GL_RGB;
  if(channels == 4) type = GL_RGBA;
  data_size = x * y * 3;
  //--------------------------------------------
  // read scanlines one at a time & put bytes 
  //    in jdata[] array. Assumes an RGB image
  //--------------------------------------------
  jdata = (unsigned char *)malloc(data_size);
  while (info.output_scanline < info.output_height) // loop
  {
    // Enable jpeg_read_scanlines() to fill our jdata array
    rowptr[0] = (unsigned char *)jdata +  // secret to method
            3* info.output_width * info.output_scanline; 
    jpeg_read_scanlines(&info, rowptr, 1);
  }
  //---------------------------------------------------
  jpeg_finish_decompress(&info);   //finish decompressing
  //----- create OpenGL tex map (omit if not needed) --------
  glGenTextures(1,&texture_id);
  glBindTexture(GL_TEXTURE_2D, texture_id);
  gluBuild2DMipmaps(GL_TEXTURE_2D,3,x,y,GL_RGB,GL_UNSIGNED_BYTE,jdata);
  jpeg_destroy_decompress(&info);
  fclose(file);                    //close the file
  free(jdata);
  return texture_id;    // for OpenGL tex maps
}

jpeg_read_scanlines函数接收一个指针数组(不是像imageData->pixels那样的像素直接指针)。所以我们应该先创建一个JSAMPARRAY:

int buffer_height = 1;
JSAMPARRAY buffer = (JSAMPARRAY)malloc(sizeof(JSAMPROW) * buffer_height);
buffer[0] = (JSAMPROW)malloc(sizeof(JSAMPLE) * row_stride);

在你的代码中，你用"cinfo"创建了一个"缓冲区"。Mem -> alloc_array "，但你从不使用它。最后一步是传递"buffer"作为jpeg_read_scanlines的参数:

while (cinfo.output_scanline < cinfo.output_height) {
  jpeg_read_scanlines(&cinfo, buffer, 1);
  memcpy(imageData->pixels+counter, buffer[0], row_stride);
  counter += row_stride;
}

看到我们正在使用"imageData->pixels+counter"，而不仅仅是"imageData->pixels"在你的代码。通过这种方式，我们在整个"imageData->pixels"内存块中逐行写入。

就像dacap说的，它期待一个JSAMPARRAY。也就是说，如果愿意，可以直接写入imageData->pixels数组。你只需要做这样的事情:

// Allocate imageData->pixels to be the correct size, start decompress and all
// that jazz, like you did in your code. Skip allocating buffer though.
// ...
JSAMPROW output_data;
unsigned int scanline_len = cinfo.output_width * cinfo.output_components;
unsigned int scanline_count = 0;
while (cinfo.output_scanline < cinfo.output_height)
{
    output_data = (imageData->pixels + (scanline_count * scanline_len));
    jpeg_read_scanlines(&cinfo, &output_data, 1);
    scanline_count++;
}

您可以完全跳过分配缓冲区。使用内存可以很好地工作，但是如果没有必要，为什么要进行额外的复制呢?

下面是Jim整理的代码版本。它还使用cim作为输出格式，这使得如何提取RGB值更加明确。

CImg<unsigned char> *ReadJpegIntoCImg( const char *path )
{
    FILE *file = fopen( path, "rb" );
    if ( file == NULL )
    {
        return NULL;
    }
    
    struct jpeg_decompress_struct info; //for our jpeg info
    struct jpeg_error_mgr err; //the error handler
    
    info.err = jpeg_std_error( &err );     
    jpeg_create_decompress( &info ); //fills info structure
    
    jpeg_stdio_src( &info, file );    
    jpeg_read_header( &info, true );
    
    jpeg_start_decompress( &info );
    
    unsigned int w = info.output_width;
    unsigned int h = info.output_height;
    unsigned int numChannels = info.num_components; // 3 = RGB, 4 = RGBA
    unsigned long dataSize = w * h * numChannels;
    
    // read RGB(A) scanlines one at a time into jdata[]
    unsigned char *data = (unsigned char *)malloc( dataSize );
    unsigned char* rowptr;
    while ( info.output_scanline < h )
    {
        rowptr = data + info.output_scanline * w * numChannels;
        jpeg_read_scanlines( &info, &rowptr, 1 );
    }
    
    jpeg_finish_decompress( &info );
    jpeg_destroy_decompress( &info );   
    
    fclose( file );
    
    // this code block is only if you happen to want output in CImg format, but is illustrative
    CImg<unsigned char> *image = new CImg<unsigned char>( w, h, 1, numChannels );
    for ( int x = 0 ; x < w ; x++ )
    {
        for ( int y = 0 ; y < h ; y++ )
        {
            for ( int c = 0 ; c < numChannels ; c++ )
            {
                *image->data( x, y, 0, c ) = data[ y * w * numChannels + x * numChannels + c ];
            }
        }
    }
    
    free( data );
    
    return image;
}

另外，对于那些可能被我同样的问题困住的人来说，当从c++使用libjpeg时，重要的是要有一个包含

#ifdef __cplusplus
extern "C" {
#endif

我使用的文件版本没有这个，并且得到链接错误。