Using The Independent JPEG Group's JPEG software

Using The Independent JPEG Group's JPEG software

Post by Mehmet Cane » Fri, 25 May 2001 21:00:31



Hi,

I am trying to read a .jpg file using "The Independent JPEG Group's JPEG
software".
in C++ Builder 1.0.

In my project, I tried the code in example.c file of the Software.

I have used a loop to insert raw data to Image1->Canvas. But it is very
slow.
I have only added  the code below to the function (read_JPEG_file (char *
filename)).
I am looking for a faster method managing the same work.

Thanks in advance!

Mehmet

int d1, d2, d3;

d1 = 0;
 while (cinfo.output_scanline < cinfo.output_height) {
        (void) jpeg_read_scanlines(&cinfo, buffer, 1);
         // put_scanline_someplace(buffer[0], row_stride);
         // my code
        for (d2=0, d3=0; d2 < cinfo.output_width * 3; d2+=3, d3+=1) {
              Image1->Canvas->Pixels[d3][d1] = RGB (buffer[0][d2],
buffer[0][d2+1], buffer[0][d2+2]);
        }
    d1++;
  }

And the complete function:

void __fastcall TForm1::read_JPEG_file (char * filename)
{
  /* This struct contains the JPEG decompression parameters and pointers to
   * working space (which is allocated as needed by the JPEG library).
   */
  struct jpeg_decompress_struct cinfo;
  /* We use our private extension JPEG error handler.
   * Note that this struct must live as long as the main JPEG parameter
   * struct, to avoid dangling-pointer problems.
   */
  struct my_error_mgr jerr;
  /* More stuff */
  FILE * infile;  /* source file */
  JSAMPARRAY buffer;  /* Output row buffer */
  int row_stride;  /* physical row width in output buffer */

  /* In this example we want to open the input file before doing anything
else,
   * so that the setjmp() error recovery below can assume the file is open.
   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
   * requires it in order to read binary files.
   */

  if ((infile = fopen(filename, "rb")) == NULL) {
    fprintf(stderr, "can't open %s\n", filename);
    Application->Terminate();
  }

  /* Step 1: allocate and initialize JPEG decompression object */

  /* We set up the normal JPEG error routines, then override error_exit. */
  cinfo.err = jpeg_std_error(&jerr.pub);
  jerr.pub.error_exit = my_error_exit;
  /* Establish the setjmp return context for my_error_exit to use. */
  if (setjmp(jerr.setjmp_buffer)) {
    /* If we get here, the JPEG code has signaled an error.
     * We need to clean up the JPEG object, close the input file, and
return.
     */
    jpeg_destroy_decompress(&cinfo);
    fclose(infile);
    Application->Terminate();
  }
  /* Now we can initialize the JPEG decompression object. */
  jpeg_create_decompress(&cinfo);

  /* Step 2: specify data source (eg, a file) */

  jpeg_stdio_src(&cinfo, infile);

  /* Step 3: read file parameters with jpeg_read_header() */

  (void) jpeg_read_header(&cinfo, TRUE);
  /* We can ignore the return value from jpeg_read_header since
   *   (a) suspension is not possible with the stdio data source, and
   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
   * See libjpeg.doc for more info.
   */

  /* Step 4: set parameters for decompression */

  /* In this example, we don't need to change any of the defaults set by
   * jpeg_read_header(), so we do nothing here.
   */

  /* Step 5: Start decompressor */

  (void) jpeg_start_decompress(&cinfo);
  /* We can ignore the return value since suspension is not possible
   * with the stdio data source.
   */

  /* We may need to do some setup of our own at this point before reading
   * the data.  After jpeg_start_decompress() we have the correct scaled
   * output image dimensions available, as well as the output colormap
   * if we asked for color quantization.
   * In this example, we need to make an output work buffer of the right
size.
   */
  /* JSAMPLEs per row in output buffer */
  row_stride = cinfo.output_width * cinfo.output_components;
  /* Make a one-row-high sample array that will go away when done with image
*/
  buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, r
ow_stride, 1);

  /* Step 6: while (scan lines remain to be read) */
  /*           jpeg_read_scanlines(...); */

  /* Here we use the library's state variable cinfo.output_scanline as the
   * loop counter, so that we don't have to keep track ourselves.
   */

  Image1->Width = cinfo.output_width;
  Image1->Height = cinfo.output_height;

  int d1, d2, d3;

  d1 = 0;
  while (cinfo.output_scanline < cinfo.output_height) {
    (void) jpeg_read_scanlines(&cinfo, buffer, 1);
    // put_scanline_someplace(buffer[0], row_stride);      // instead of
this line I used the lines below.
    for (d2=0, d3=0; d2 < cinfo.output_width * 3; d2+=3, d3+=1) {
         Image1->Canvas->Pixels[d3][d1] = RGB (buffer[0][d2],
buffer[0][d2+1], buffer[0][d2+2]);
    }
    d1++;
  }
  /* ///////Burasy thumbnail i?in
     // Genitlik i?in cinfo.output_width deeerinin istenen thumbnail
genitlieine b?lnmesi
     // gerekir. Eeer bu deeer 2 ise d2+=3 olan deeer d2+=6 olur.
     // Ykseklik i?in cinfo.output_height deeerinin istenen thumbnail
ykseklieine b?lnmesi
     // gerekir. Eeer bu deeer 3 ise d1%3==0 olur.

  d1 = 0;
  d4 = 0;
  while (cinfo.output_scanline < cinfo.output_height) {
    (void) jpeg_read_scanlines(&cinfo, buffer, 1);
    if (d1%4==0) {
        for (d2=0, d3=0; d2 < cinfo.output_width * 3; d2+=12, d3+=1) {
             Image2->Canvas->Pixels[d3][d4] = RGB (buffer[0][d2],
buffer[0][d2+1], buffer[0][d2+2]);
        }
        d4++;
    }
    d1++;
  }
  */
  ReleaseDC(Panel1->Handle, hdc); file://benim uydurmam

  /* Step 7: Finish decompression */

  (void) jpeg_finish_decompress(&cinfo);
  /* We can ignore the return value since suspension is not possible
   * with the stdio data source.
   */

  /* Step 8: Release JPEG decompression object */

  /* This is an important step since it will release a good deal of memory.
*/
  jpeg_destroy_decompress(&cinfo);

  /* After finish_decompress, we can close the input file.
   * Here we postpone it until after no more JPEG errors are possible,
   * so as to simplify the setjmp error logic above.  (Actually, I don't
   * think that jpeg_destroy can do an error exit, but why assume
anything...)
   */
  fclose(infile);

  /* At this point you may want to check to see whether any corrupt-data
   * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
   */

  /* And we're done! */

Quote:}

 
 
 

Using The Independent JPEG Group's JPEG software

Post by Scott Heima » Fri, 25 May 2001 22:29:56


Does Builder 1 have a TBitmap component?

You can download the BMGLib project from my web site (sorry, all the
projects are for BCB 5).  BMGLib uses the IJG software to read a JPEG file
and store the contents into a DIB section.  The HANDLE to the DIB section is
assigned to TBitamap->Handle.  The VCL compnent handles the rendering.

You can also read Harold Howe's article that discusses the IJG software and
using it with Builder ( www.bcbdev.com ).

--
Regards,
Scott
http://www.gnt.net/~heiman

 
 
 

Using The Independent JPEG Group's JPEG software

Post by Mehmet Cane » Sun, 27 May 2001 17:58:41


Thank you very much for your help!

Mehmet

 
 
 

1. to Mr. Tom Lane / Independent JPEG Group Software

    I need to know if IJG library can be run on MPS machines, on isolated
threads, I mean, several threads will decompress images (one each) at once.
Could it be done safely?

Thanks in  advance, keep up good work

Alvaro Sauca

2. C library for VT100/Retrographics?

3. Compiling IJG's JPEG software using Watcom for DOS

4. eps export problem with cdr8

5. Detecting a bad Jpeg using the JPEG unit

6. Volumetrics and solidity

7. New software to create AVI's from JPEG's

8. Good video card for text?