apps/ccam/dma2jpeg.c

Go to the documentation of this file.

/*
 * dma2jpeg.c
 *
 * This file illustrates how to use the IJG code as a subroutine library
 * to read or write JPEG image files.  You should look at this code in
 * conjunction with the documentation file libjpeg.doc.
 *
 * This code will not do anything useful as-is, but it may be helpful as a
 * skeleton for constructing routines that call the JPEG library.  
 *
 * We present these routines in the same coding style used in the JPEG code
 * (ANSI function definitions, etc); but you are of course free to code your
 * routines in a different style if you prefer.
 */
#include <fcntl.h>  /*open*/
#include <unistd.h> /* close */

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>           /* mmap */

/*
 * Include file for users of JPEG library.
 * You will need to have included system headers that define at least
 * the typedefs FILE and size_t before you can include jpeglib.h.
 * (stdio.h is sufficient on ANSI-conforming systems.)
 * You may also wish to include "jerror.h".
 */

#include "jpeg/jpeglib.h"
#include "imageaccess.h"
#include "dma2jpeg.h"


#define D(x)
#define D1(x)
//   MD(fprintf(stderr,"width- %d, height %d, quality - %d, contrast - %d, color - %d, orient - %d, depth - %d\r\n", ImageWidth,ImageHeight, Quality, Contrast, Color, bayerOrient, Depth));

/******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/

/* This half of the example shows how to feed data into the JPEG compressor.
 * We present a minimal version that does not worry about refinements such
 * as error recovery (the JPEG code will just exit() if it gets an error).
 */


/*
 * IMAGE DATA FORMATS:
 *
 * The standard input image format is a rectangular array of pixels, with
 * each pixel having the same number of "component" values (color channels).
 * Each pixel row is an array of JSAMPLEs (which typically are unsigned chars).
 * If you are working with color data, then the color values for each pixel
 * must be adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit
 * RGB color.
 *
 * For this example, we'll assume that this data structure matches the way
 * our application has stored the image in memory, so we can just pass a
 * pointer to our image buffer.  In particular, let's say that the image is
 * RGB color and is described by:
 */

int dma2jpeg        (int ImageWidth, int ImageHeight, int Quality, int Contrast, int Color, int bayerOrient, int Depth, const char * pseudo, const char * ifn, const char * ofn) {
  /* This struct contains the JPEG compression parameters and pointers to
   * working space (which is allocated as needed by the JPEG library).
   * It is possible to have several such structures, representing multiple
   * compression/decompression processes, in existence at once.  We refer
   * to any one struct (and its associated working data) as a "JPEG object".
   */
  struct jpeg_compress_struct cinfo;
  /* This struct represents a JPEG error handler.  It is declared separately
   * because applications often want to supply a specialized error handler
   * (see the second half of this file for an example).  But here we just
   * take the easy way out and use the standard error handler, which will
   * print a message on stderr and call exit() if compression fails.
   * Note that this struct must live as long as the main JPEG parameter
   * struct, to avoid dangling-pointer problems.
   */

// int i,j; // i,j - debug
  struct jpeg_error_mgr jerr;
  /* More stuff */
  FILE * outfile;               /* target file */
  JSAMPROW row_pointer[1];      /* pointer to JSAMPLE row[s] */
  struct pixel_buffers pb;

 // Contrast (0-5) - shift data left by Contrast bits (before shifting right by 2)
    if ((Contrast <0) || (Contrast >5 )) Contrast=0;
    

  /* Step -1: open dma data memory through 1-st filename */

 MD(fprintf(stderr,"\r\n"));

    if (initPixelBuffers(&pb, ifn,ImageWidth,ImageHeight,Contrast, Color, bayerOrient, Depth, pseudo) <0) return -1;
 MD(fprintf(stderr,"\r\n"));


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

  /* We have to set up the error handler first, in case the initialization
   * step fails.  (Unlikely, but it could happen if you are out of memory.)
   * This routine fills in the contents of struct jerr, and returns jerr's
   * address which we place into the link field in cinfo.
   */
  cinfo.err = jpeg_std_error(&jerr);
  /* Now we can initialize the JPEG compression object. */
  jpeg_create_compress(&cinfo);

  /* Step 2: specify data destination (eg, a file) */
  /* Note: steps 2 and 3 can be done in either order. */

  /* Here we use the library-supplied code to send compressed data to a
   * stdio stream.  You can also write your own code to do something else.
   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
   * requires it in order to write binary files.
   */


        if (ofn) {
          if ((outfile = fopen(ofn, "wb")) == NULL) {
            fprintf(stderr, "can't open %s\n", ofn);
            closePixelBuffers(&pb);
            exit(1);
          }
        } else {
          outfile=stdout;
 MD(fprintf(stderr, "Using stdout\r\n"));

        }

 MD(fprintf(stderr,"\r\n"));


        jpeg_stdio_dest(&cinfo, outfile);
 MD(fprintf(stderr,"\r\n"));


  /* Step 3: set parameters for compression */

  /* First we supply a description of the input image.
   * Four fields of the cinfo struct must be filled in:
   */
    if (getPalette (&pb)) Color=2;// pseudo color mode

    if (Color==2) { // pseudo color mode
          cinfo.image_width = ImageWidth;       /* image width and height, in pixels */
          cinfo.image_height = ImageHeight;
          cinfo.input_components = 3;           /* # of color components per pixel */
          cinfo.in_color_space = JCS_RGB;       /* colorspace of input image */
 MD(fprintf(stderr,"\r\n"));

        } else if (Color) {
          cinfo.image_width =  (ImageWidth>1)? ImageWidth-2 :0;         /* image width and height, in pixels */
          cinfo.image_height = (ImageHeight>1)?ImageHeight-2:0;
          cinfo.input_components = 3;           /* # of color components per pixel */
          cinfo.in_color_space = JCS_RGB;       /* colorspace of input image */
 MD(fprintf(stderr,"\r\n"));

        } else { // if (Color) 
          cinfo.image_width = ImageWidth;       /* image width and height, in pixels */
          cinfo.image_height = ImageHeight;
          cinfo.input_components = 1;           /* # of color components per pixel */
          cinfo.in_color_space = JCS_GRAYSCALE; /* colorspace of input image */
 MD(fprintf(stderr,"\r\n"));

        }
  /* Now use the library's routine to set default compression parameters.
   * (You must set at least cinfo.in_color_space before calling this,
   * since the defaults depend on the source color space.)
   */

  jpeg_set_defaults(&cinfo);
 MD(fprintf(stderr,"\r\n"));

  /* Now you can set any non-default parameters you wish to.
   * Here we just illustrate the use of quality (quantization table) scaling:
   */

  jpeg_set_quality(&cinfo, Quality, TRUE /* limit to baseline-JPEG values */);

 MD(fprintf(stderr,"\r\n"));

  /* Step 4: Start compressor */

  /* TRUE ensures that we will write a complete interchange-JPEG file.
   * Pass TRUE unless you are very sure of what you're doing.
   */

  jpeg_start_compress(&cinfo, TRUE);

  /* Step 5: while (scan lines remain to be written) */
  /*           jpeg_write_scanlines(...); */

  /* Here we use the library's state variable cinfo.next_scanline as the
   * loop counter, so that we don't have to keep track ourselves.
   * To keep things simple, we pass one scanline per call; you can pass
   * more if you wish, though.
   */
//  row_stride = image_width * 3;       /* JSAMPLEs per row in image_buffer */


  while (cinfo.next_scanline < cinfo.image_height) {
    /* jpeg_write_scanlines expects an array of pointers to scanlines.
     * Here the array is only one element long, but you could pass
     * more than one scanline at a time if that's more convenient.
     */

    row_pointer[0] = (char *) getPixelRow(&pb, cinfo.next_scanline + ((Color==1)? 1:0) );

    D(printf ("%4d:",cinfo.next_scanline));
    D(for (i=0;i<20;i++) { j=row_pointer[0][i];printf (" %2x",j);});
    D(printf ("\r\n"));
// MD(fprintf(stderr,"%d %x    ",cinfo.next_scanline, (int) row_pointer[0]));
    (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
  }
  /* Step 6: Finish compression */
 MD(fprintf(stderr,"\r\n"));

  jpeg_finish_compress(&cinfo);
  /* After finish_compress, we can close the output file. */
 MD(fprintf(stderr,"\r\n"));
  closePixelBuffers(&pb);
 MD(fprintf(stderr,"done\r\n"));

  /* Step 7: release JPEG compression object */

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

  /* And we're done! */
  return 0;
}


/*
 * SOME FINE POINTS:
 *
 * In the above loop, we ignored the return value of jpeg_write_scanlines,
 * which is the number of scanlines actually written.  We could get away
 * with this because we were only relying on the value of cinfo.next_scanline,
 * which will be incremented correctly.  If you maintain additional loop
 * variables then you should be careful to increment them properly.
 * Actually, for output to a stdio stream you needn't worry, because
 * then jpeg_write_scanlines will write all the lines passed (or else exit
 * with a fatal error).  Partial writes can only occur if you use a data
 * destination module that can demand suspension of the compressor.
 * (If you don't know what that's for, you don't need it.)
 *
 * If the compressor requires full-image buffers (for entropy-coding
 * optimization or a multi-scan JPEG file), it will create temporary
 * files for anything that doesn't fit within the maximum-memory setting.
 * (Note that temp files are NOT needed if you use the default parameters.)
 * On some systems you may need to set up a signal handler to ensure that
 * temporary files are deleted if the program is interrupted.  See libjpeg.doc.
 *
 * Scanlines MUST be supplied in top-to-bottom order if you want your JPEG
 * files to be compatible with everyone else's.  If you cannot readily read
 * your data in that order, you'll need an intermediate array to hold the
 * image.  See rdtarga.c or rdbmp.c for examples of handling bottom-to-top
 * source data using the JPEG code's internal virtual-array mechanisms.
 */

---