/* zdjpeg.c * * Copyright (c)2008 Magnum Semiconductor Inc., All rights reserved. * * This command line JPEG decode utility is based on the IJG library djpeg. * Several of the options supported by that program have been removed as they * are not required to illustrate the operation of the ZEVIO JPEG decoder. * * This program performs a command line decode usingthe ZSP optimised decoder * * The original djpeg code is: * * Copyright (C) 1991-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. */#include <assert.h>#include <err.h>#include <errno.h>#include <fcntl.h>#include <stdio.h>#include <stdint.h>#include <stdlib.h>#include <stdbool.h>#include <string.h>#include <sysexits.h>#include <unistd.h>#include <stdint.h>#include <signal.h>#include <alloca.h>#include <limits.h>#include <ctype.h>#include <poll.h>#include <sys/mman.h>#include <sys/ioctl.h>#include <sys/time.h>#include <dirent.h>#include <pthread.h>#include <semaphore.h>#include <zevio/zevio2d.h>#include <zevio/zevio3d.h>#include <zevio/gpu_factory.h>#include "zeviojpegapi.h"#include "display.h"/* * These constants are for the use of this program, the JPEG library itself * is precompiled to support up to 800*600 displays which is all that can * be reasonably expected on a current ZEVIO platform. The memory saving in * the JPEG decoder for a smaller size such as 640*480 is minimal */#define OUTPUT_W 800#define OUTPUT_H 600/* * The value APP_PHY_MEMORY defines the memory reserved for final image output * which must be to physically mapped memory. Currently this is large enough * for an 800*600 linear image. However it is no longer required... */#define APP_PHY_MEMORY 0//#define TRACE fprintf(stdout, "( %s : %s : %d )\n", __FILE__, __func__, __LINE__);#define TRACE#define PPM_MAXVAL 255#define READ_BINARY "rb"#define WRITE_BINARY "wb"#define INTERVAL_TIME 60 // Seconds!static const char  *progname;static       char  *outfilename,                   *playRoot;static boolean      thumbnail,                    slideshow,                    play,                    tile,                    flush;static sem_t        done;static unsigned int oWidth,                    oHeight,                    loopCounter,                    displayCounter,                    presentationDelay,                    quality;static void                 *gpuVMem;static ZV_GPU_BUFFER_OBJECT  gpuBuf;extern void encodeStart( zJpegDecompressPtr decompressCinfo, char *filename, unsigned int oWidth, unsigned int oHeight, unsigned int quality);extern void encodeEnd( void );extern void encodeWriteAPP1( unsigned char *pHeader, unsigned int length);static void usage ( void );static boolean keymatch (char * arg, const char * keyword, int minchars);static int parse_switches (j_decompress_ptr cinfo, int argc, char **argv,                           int last_file_arg_seen, boolean for_real);static void freeInputBuffer( zJpegDecompressPtr cinfo,                             int                temp,                             zJpegDecodeStatus  status);static void zdjpegErrorExit ( zJpegCommonPtr cinfo );static int zdjpeg(int argc, char **argv);/* * Command line help message */static void usage (void)/* complain about bad command line */{  fprintf(stderr, "\nUsage: %s [switches] <input file>\n\n", progname);  fprintf(stderr, "Switches (names may be abbreviated):\n\n");  fprintf(stderr, "  -verbose            Emit debug output\n");  fprintf(stderr, "  -size WxH           Force the output size to be WxH (scaling down only)\n");  fprintf(stderr, "  -thumb              Process embedded thumbnail if present\n");  fprintf(stderr, "  -slideshow <N>      Display 'N' iterations of images in directory\n");  fprintf(stderr, "  -play <file root>   Play a sequence of JPEGs <file root>00001.jpg etc\n");  fprintf(stderr, "  -tile <N> <I>       Like slideshow, but Thumbnails, display refresh every <I>\n");  fprintf(stderr, "  -delay <1 - 99>     Delay then clear 3D screen, default is to leave image\n");  fprintf(stderr, "  -flush              Forces a flush after 2s of every other Slideshow image\n");  fprintf(stderr, "  \n  and\n\n  -outfile <quality> <filename> Writes a ppm file and a jpeg file at the \n                                specified quality level in addition to display\n");  exit(EXIT_FAILURE);}/* * Assist function for command line parsing, converts case and recognises * abbreviated keywords */static boolean keymatch (char * arg, const char * keyword, int minchars){  register int ca, ck;  register int nmatched = 0;  while ((ca = *arg++) != '\0') {    if ((ck = *keyword++) == '\0')      return FALSE;        /* arg longer than keyword, no good */    if (isupper(ca))        /* force arg to lcase (assume ck is already) */      ca = tolower(ca);    if (ca != ck)      return FALSE;        /* no good */    nmatched++;            /* count matched characters */  }  /* reached end of argument; fail if it's too short for unique abbrev */  if (nmatched < minchars)    return FALSE;  return TRUE;            /* A-OK */}/* * Command line parser */static int parse_switches (j_decompress_ptr cinfo, int argc, char **argv,                           int last_file_arg_seen, boolean for_real)/* Parse optional switches. * Returns argv[] index of first file-name argument (== argc if none). * Any file names with indexes <= last_file_arg_seen are ignored; * they have presumably been processed in a previous iteration. * (Pass 0 for last_file_arg_seen on the first or only iteration.) * for_real is FALSE on the first (dummy) pass; we may skip any expensive * processing. */{  int argn;  char * arg;  for_real = for_real;  /* Set up default JPEG parameters. */  outfilename                = NULL;  cinfo->err->trace_level    = 0;  cinfo->dct_method          = JDCT_IFAST;  cinfo->quantize_colors     = FALSE;  cinfo->two_pass_quantize   = FALSE;  cinfo->do_fancy_upsampling = FALSE;  cinfo->dither_mode         = JDITHER_ORDERED;//  cinfo->dither_mode         = JDITHER_NONE;  presentationDelay = 0;  /* Scan command line options, adjust parameters */  for (argn = 1; argn < argc; argn++) {    arg = argv[argn];    if (*arg != '-') {      /* Not a switch, must be a file name argument */      if (argn <= last_file_arg_seen) {        outfilename = NULL;    /* -outfile applies to just one input file */        continue;        /* ignore this name if previously processed */      }      break;            /* else done parsing switches */    }    arg++;            /* advance past switch marker character */    if (keymatch(arg, "verbose", 1)) {      cinfo->err->trace_level++;    } else if (keymatch(arg, "thumb", 2)) {      thumbnail = TRUE;    } else if (keymatch(arg, "flush", 2)) {      flush = TRUE;    } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {      /* Force monochrome output. */      cinfo->out_color_space = JCS_GRAYSCALE;    } else if (keymatch(arg, "outfile", 2)) {      /* Set output file name. */      if (slideshow == TRUE || tile == TRUE || play == TRUE)        usage();       if (++argn >= argc)    /* advance to next argument */        usage();      if (sscanf(argv[argn], "%d",                 &quality) != 1)        usage();      if (++argn >= argc)    /* advance to next argument */        usage();      outfilename = argv[argn];    /* save it away for later use */    } else if (keymatch(arg, "play", 2)) {      /* Set output file name. */      if (++argn >= argc)    /* advance to next argument */        usage();      if (slideshow == TRUE || tile == TRUE || outfilename != NULL)        usage();      playRoot = argv[argn];    /* save it away for later use */      play        = TRUE;    } else if (keymatch(arg, "delay", 2)) {      /* Set the presentation delay */      if (++argn >= argc)    /* advance to next argument */        usage();      if (sscanf(argv[argn], "%d",                 &presentationDelay) != 1)        usage();      if (presentationDelay == 0 || presentationDelay > 99)        usage();    } else if (keymatch(arg, "slideshow", 2)) {      /* Set the presentation delay */      slideshow = TRUE;      if (++argn >= argc)    /* advance to next argument */        usage();      if (play == TRUE || tile == TRUE || outfilename != NULL)        usage();      if (sscanf(argv[argn], "%d",                 &loopCounter) != 1)        usage();    } else if (keymatch(arg, "tile", 2)) {      /* Set the presentation delay */      tile = TRUE;      if (++argn >= argc)    /* advance to next argument */        usage();      if (slideshow == TRUE || play == TRUE || outfilename != NULL)        usage();      if (sscanf(argv[argn], "%d",                 &loopCounter) != 1)        usage();      if (++argn >= argc)    /* advance to next argument */        usage();      if (sscanf(argv[argn], "%d",                 &displayCounter) != 1)        usage();      if (displayCounter <  1) displayCounter = 1;      if (displayCounter > 25) displayCounter = 25;    } else if (keymatch(arg, "size", 2)) {      /* Set the output size. */      if (++argn >= argc)    /* advance to next argument */        usage();      if (sscanf(argv[argn], "%dx%d",                 &oWidth, &oHeight) != 2)        usage();    } else {      usage();            /* bogus switch */    }  }  return argn;            /* return index of next arg (file name) */}/* Override standard error handling */struct zdjpegErrorMgr {  zJpegErrorMgr pub;  jmp_buf setjmp_buffer;};typedef struct zdjpegErrorMgr *zdjpegErrorPtr;static void zdjpegErrorExit ( zJpegCommonPtr cinfo ){  zdjpegErrorPtr errorMgr = (zdjpegErrorPtr)cinfo->err;  /* Always display the message. */  (*cinfo->err->output_message) (cinfo);  /* Return control to the setjmp point */  longjmp(errorMgr->setjmp_buffer, 1);}/* * Simple callback routine used to synchronise the command line application to * the asynchronous JPEG decode. This feedback mechanism is likely to be more * complex in a real world application */static void freeInputBuffer( zJpegDecompressPtr cinfo,                             int                temp,                             zJpegDecodeStatus  status){	cinfo = cinfo;	temp  = temp;  if (status == DECODE_ERROR)  {    printf("\n!!!Decode Error!!!\n\n");  }  else if (status == DECODE_ABORTED)  {    printf("\n!!!Decode Aborted!!!\n\n");  }  printf("decoded size: %d x %d\n", cinfo->output_width, cinfo->output_height);  sem_post(&done);}/* * zdjpeg entry point */static int zdjpeg(int argc, char **argv){  zJpegDecompressStruct cinfo;  struct zdjpegErrorMgr       errorHandler;  void                       *vMem,                             *rgbBuffer = NULL;  unsigned long               pMem;  long                        time;  struct itimerval            timSet,                              timGet1,                              timGet2;  int                         file_index;  FILE                       *input_file  = NULL;  boolean                     thumbnailFound,                              upperCase;  thumbnail = FALSE;  slideshow = FALSE;  play      = FALSE;  tile      = FALSE;  flush     = FALSE;  progname = argv[0];  if (progname == NULL || progname[0] == 0)    progname = "zdjpeg";  oWidth  = OUTPUT_W;  oHeight = OUTPUT_H;  /*   * Initialize the 3D library used to provide contiguous physical memory   */  GPU_Factory_Init(&gpuVMem);  /*   * Reserve physically mapped memory for the image store and as required by   * the JPEG decoder. The JPEG decoder manages its own memory buffers after   * initialisation.   *///  vMem = zevio3d_pmalloc_far( zJpegGetRequiredMemory( NULL ), 16, &pMem );  vMem = zevio3d_palloc_far( APP_PHY_MEMORY + zJpegGetRequiredMemory( NULL ), &pMem );//  vMem = zevio3d_pmalloc_far( APP_PHY_MEMORY + zJpegGetRequiredMemory( NULL ), 16, &pMem );  assert(vMem);  assert(pMem);  /*   * Initialize the ZSP, passing virtual and physical pointers to the requested   * memory buffers   */