zdjpeg.c

linux环境下jpeg编解码算法的实现

//  zJpegInit( vMem, pMem );
  zJpegInit( APP_PHY_MEMORY + vMem, APP_PHY_MEMORY + pMem );

  /*
   * Override the default JPEG error handling. [Note, this functionality may
   * change in future releases!]
   */

  cinfo.err = zJpegStdError(&errorHandler.pub);
  errorHandler.pub.error_exit = zdjpegErrorExit;
  /* Establish the setjmp return context */
  if (setjmp(errorHandler.setjmp_buffer))
  {
    zJpegFinishDecompress(&cinfo);
    return 0;
  }

  /* Scan command line to find file names. */
  /* It is convenient to use just one switch-parsing routine, but the switch
   * values read here are ignored; we will rescan the switches after opening
   * the input file.
   * (Exception: tracing level set here controls verbosity for COM markers
   * found during jpeg_read_header...)
   */

  file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);

  /*
   * This semaphore syncs this command line utility to the asynchronous decode
   */

  sem_init(&done, 0, 0);

  /*
   * Initialize 3D graphics
   */

  display_init();

  /*
   * Now decide if we are in one-shot or slideshow mode and proceed accordingly
   */

  if (slideshow == FALSE && play == FALSE && tile == FALSE && outfilename == NULL)
  {
    /*
     * Initialize the JPEG decompression object
     */

    if (zJpegCreateDecompress( &cinfo ) != EXIT_SUCCESS)
    {
      fprintf(stderr, "%s: can't create decompression object\n", progname);
      exit(EXIT_FAILURE);
    }

    /*
     * At this point pZSP  which is the ZEVIO specific 'cinfo' extension can be
     * initialized. The intention is that 'cinfo' remains as standard and all
     * extensions use the existing 'client_data' pointer to user extensions
     */

//    pZSP = (struct zjpeg_command *)cinfo.client_data;

    if (file_index < argc)
    {
      if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL)
      {
        fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
        exit(EXIT_FAILURE);
      }
    }
    else
    {
      fprintf(stderr, "%s: must name one input and one output file\n", progname);
      usage();
    }

    if (zJpegOKToDecode(&cinfo, input_file) == JPEG_NOK_TO_DECODE)
    {
      printf("Unsupported Image Type\n");
      zJpegReleaseDecompress(&cinfo);
      fclose(input_file);
      return 1;
    }

    if (cinfo.err->trace_level)
    {
      timSet.it_interval.tv_sec = INTERVAL_TIME;
      timSet.it_interval.tv_usec = 0;
      timSet.it_value.tv_sec = INTERVAL_TIME;
      timSet.it_value.tv_usec = 0;
      assert(!setitimer(ITIMER_REAL, &timSet, NULL));
    }

    /*
     * Specify data source for decompression. File and memory sources are
     * supported although memory does not make any sense in the context of a
     * command line utility...
     */

    zJpegStdioSrc(&cinfo, input_file);

    /*
     * Read file header which sets the default decompression parameters. At this
     * point the ZEVIO decoder can check for an embedded thumbnail, see the logic
     * below for details...
     */

    if (zJpegReadHeader(&cinfo, thumbnail, &thumbnailFound) == JPEG_NOK_TO_DECODE)
    {
      printf("Unsupported Image Type\n");
      zJpegFinishDecompress(&cinfo);
      zJpegReleaseDecompress(&cinfo);
      fclose(input_file);
      return 1;
    }
    if(thumbnail == TRUE && thumbnailFound == FALSE)
    {
      fprintf(stderr, "%s: no thumbnail present\n", progname);
      zJpegFinishDecompress(&cinfo);
      rewind(input_file);
      zJpegStdioSrc(&cinfo, input_file);
      zJpegReadHeader(&cinfo, FALSE, &thumbnailFound);
      oWidth  = 160;
      oHeight = 120;
    }
    if (thumbnail == TRUE)
    {
	 oWidth  = 160; oHeight = 120;
    }

    /*
     * Adjust default decompression parameters by re-parsing the options. In a
     * real application the decode parameters must be set after reading the
     * header
     */

    file_index = parse_switches( &cinfo, argc, argv, 0, TRUE );

    /*
     * Scale the image to fit the desired output size. Here we always scale to
     * match aspect ratio and maximum 800x600
     */

    zJpegSetOutputSize( &cinfo, &oWidth, &oHeight, SCALE_MAX );
	printf("SetOutputSize: %d x %d\n", oWidth, oHeight);

    /*
     * (void*) gpuBuf.pBase = physical address to top left corner of buffer
     * (unsigned short*) gpuBuf.vBase = virtual address to top left corner of buffer
     */

    GPU_Factory_Request(ZV_GBUF_FULL_SCREEN,&gpuBuf);

    /*
     * Start decompressor, the callback and memory pointers for the output
     * buffer are passed as parameters
     */

    (void) zJpegStartDecompress(&cinfo, freeInputBuffer, 0, gpuBuf.vBase, (unsigned long)gpuBuf.pBase); // Buffer assigned internally for now

    /*
     * Pend on callback indicating decode complete
     */

    sem_wait(&done);

    /*
     * Decode time is captured before writing out the file which is subject to
     * NFS delays. Of course the input and swap file are also plagued by NFS
     * but at least one source of uncertainty is removed...
     */

    if  (cinfo.err->trace_level)
    {
      assert(!getitimer(ITIMER_REAL, &timGet1));
    }
    assert(oWidth  <= OUTPUT_W);
    assert(oHeight <= OUTPUT_H);

    /*
     * Draw LCD display
     */

    GPU_Factory_BindTexture(&gpuBuf);
    display_pixels( (void *)gpuBuf.vBase,
                    (unsigned short*)gpuVMem,
                    gpuBuf.offset );

    if  (cinfo.err->trace_level)
    {
      assert(!getitimer(ITIMER_REAL, &timGet2));
    }

    /*
     * Write the image out to the specified file in PPM format. Output width and
     * output height are constrained if incorrct scaling selection could cause a
     * memory access problem, any image is capped at 800*600 pixels
     *
     * NOTE : Writing a file here totally screws up the presentation time value
     * but currently drawing to 3D when the image is in GPU memory (not system)
     * corrupts the decode results so it is here or never!
     */

    /*
     * Tidy up after decode of a single image, this should be used by any
     * application
     */

    zJpegReleaseDecompress(&cinfo);

    /*
     * Decode & presentation run time output
     */

    if  (cinfo.err->trace_level)
    {
      zJpegInstrumentation result;
      zJpegGetInstrumentation( &cinfo, &result );

      printf("\n%d %u.%ums [%d] %u.%ums [%d] %d %dx%d %dx%d %dx%d\n",
             result.ppPackets,
             result.zspTimer0ms,
             result.zspTimer0hus,
             result.zspTimer0oflow,
             result.zspTimer1ms,
             result.zspTimer1hus,
             result.zspTimer1oflow,
             result.chromaType,
             result.imageWidth,
             result.imageHeight,
             result.outputWidth,
             result.outputHeight,
             result.displayWidth,
             result.displayHeight);

      time = INTERVAL_TIME*1000000 - (timGet1.it_value.tv_sec * 1000000 + timGet1.it_value.tv_usec);
      if (time <= 0)
        printf("Task Timer Elapsed...\n");
      else
        printf("[D] %ld.%02lds ", time/1000000, (time%1000000)/10000);

      time = INTERVAL_TIME*1000000 - (timGet2.it_value.tv_sec * 1000000 + timGet2.it_value.tv_usec);
      if (time <= 0)
        printf("Task Timer Elapsed...\n");
      else
        printf("[P] %ld.%02lds for %s\n", time/1000000, (time%1000000)/10000, argv[file_index]);
    }

    fclose(input_file);

    GPU_Factory_Release(&gpuBuf);

    /*
     * The default behavior is to leave the image visible but this obscures the
     * directFB plane, there is a command line option to delay for 'N' seconds then
     * clear the image.
     */

    if (presentationDelay)
    {
      sleep(presentationDelay);
      zevio2d_disable_3dscr();
    }
  }
  else if (outfilename)
  {
    /*
     * This path implements an encode option. It encodes a JPEG with an
     * embedded thumbnail. Right now the method used is VERY crude, the image
     * is decoded and encoded twice, once for thumbnail and the second time for
     * display. Going forward there are much better ways to do this, e.g.
     * copying the thumbnail from the original image if there are no changes
     * such as cropping or in the more general case scaling a resulting display
     * size image to thumbnail size before encoding, much faster than a double
     * decode but another PP step to implement.
     *
     * Also no EXIF is transferred over, that will almost certainly be required
     * in the future.
     */

    unsigned char *header;
    FILE *tempFile;
    unsigned int length,
                 orientation;

    /*
     * Step 1 - Decode Thumbnail to a discrete file. To differentiate the
     * thumbnails and bypass ZSP PP (necessary for this low rent solution) the
     * thumbnail is going to be generated at 200*150.
     */

    if (zJpegCreateDecompress( &cinfo ) != EXIT_SUCCESS)
    {
      fprintf(stderr, "%s: can't create decompression object\n", progname);
      exit(EXIT_FAILURE);
    }

    if (file_index < argc)
    {
      if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL)
      {
        fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
        exit(EXIT_FAILURE);
      }
    }
    else
    {
      fprintf(stderr, "%s: must name one input and one output file\n", progname);
      usage();
    }

    GPU_Factory_Request(ZV_GBUF_FULL_SCREEN,&gpuBuf);

    zJpegStdioSrc(&cinfo, input_file);

    zJpegReadHeader(&cinfo, FALSE, &thumbnailFound);

    oWidth  = 200;
    oHeight = 150;
    orientation = zJpegGetOrientation( &cinfo );

    zJpegSetOutputSize( &cinfo, &oWidth, &oHeight, SCALE_MAX );

     rgbBuffer = malloc(800 * 3 * 2);
     assert(rgbBuffer);

     zJpegSetRGBbuffer( &cinfo, rgbBuffer );

    encodeStart( &cinfo, "temp", oWidth, oHeight, 80 );

    (void) zJpegStartDecompress(&cinfo, freeInputBuffer, 0, gpuBuf.vBase, (unsigned long)gpuBuf.pBase); // Buffer assigned internally for now

    sem_wait(&done);

    encodeEnd();

    zJpegFinishDecompress(&cinfo);
//    zJpegReleaseDecompress(&cinfo);

printf("Thumb complete\n");
    /*
     * Step 2 - Read back the temporary file into a memory buffer and determine
     * its length. The image is read after sufficient space for the APP1/IFD
     * header so that the marker can be written in a single go
     */

    header = (unsigned char *)malloc(16384);
    assert(header);

    tempFile = fopen("temp.jpg", "rb");
    assert(tempFile);

    length = fread(header + 74, 1, 16384-74, tempFile);
    assert(length);

    fclose(tempFile);
printf("Thumb read\n");

    if (length == 16384-74)
    {
      printf("Warning JPEG Thumbnail too big!\n");
    }

    header[ 0] = 'E';   // Exif marker
    header[ 1] = 'x';
    header[ 2] = 'i';
    header[ 3] = 'f';
     header[ 4] = 0x00;
     header[ 5] = 0x00;
     header[ 6] = 0x49;  // Indicates little Endian TIFF, start of TIFF
     header[ 7] = 0x49;
     header[ 8] = 0x2A;  // TIFF Magic Number
     header[ 9] = 0x00;
     header[10] = 0x08;  // Offset from start of TIFF to IFD0
     header[11] = 0x00;
     header[12] = 0x00;
     header[13] = 0x00;
     header[14] = 0x01;  // IFD0 Entry Count
     header[15] = 0x00;
     header[16] = 0x12;  // Orientation Tag
     header[17] = 0x01;
     header[18] = 0x03;
     header[19] = 0x00;
     header[20] = 0x01;
     header[21] = 0x00;
     header[22] = 0x00;
     header[23] = 0x00;
     header[24] = orientation;  // Orientation Value
     header[25] = 0x00;
     header[26] = 0x00;
     header[27] = 0x00;
     header[28] = 0x1A;  // Offset from start of TIFF to IFD1
     header[29] = 0x00;
     header[30] = 0x00;
     header[31] = 0x00;