zdjpeg.c

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

     header[32] = 0x03;  // IFD1 Entry Count
     header[33] = 0x00;
     header[34] = 0x03;  // Thumbnail Type tag
     header[35] = 0x01;
     header[36] = 0x03;
     header[37] = 0x00;
     header[38] = 0x01;
     header[39] = 0x00;
     header[40] = 0x00;
     header[41] = 0x00;
     header[42] = 0x06;
     header[43] = 0x00;
     header[44] = 0x00;
     header[45] = 0x00;
     header[46] = 0x01;  // Offset to JPEG Thumbnail
     header[47] = 0x02;
     header[48] = 0x04;
     header[49] = 0x00;
     header[50] = 0x01;
     header[51] = 0x00;
     header[52] = 0x00;
     header[53] = 0x00;
     header[54] = 0x44;  // 68 bytes from start of TIFF to JPEG
     header[55] = 0x00;
     header[56] = 0x00;
     header[57] = 0x00;
     header[58] = 0x02;  // JPEG Thumbnail Length
     header[59] = 0x02;
     header[60] = 0x04;
     header[61] = 0x00;
     header[62] = 0x01;
     header[63] = 0x00;
     header[64] = 0x00;
     header[65] = 0x00;
     header[66] =  length       & 0xFF;
     header[67] = (length >> 8) & 0xFF;
     header[68] = 0x00;
     header[69] = 0x00;
     header[70] = 0x00;  // NULL offset, no more IFDs
     header[71] = 0x00;
     header[72] = 0x00;
     header[73] = 0x00;

     /*
      * Write the header
      */


     rewind(input_file);

    zJpegStdioSrc(&cinfo, input_file);

    zJpegReadHeader(&cinfo, FALSE, &thumbnailFound);
            cinfo.dct_method          = JDCT_IFAST;
            cinfo.quantize_colors     = FALSE;
            cinfo.two_pass_quantize   = FALSE;
            cinfo.do_fancy_upsampling = FALSE;
            cinfo.dither_mode         = JDITHER_ORDERED;

    oWidth  = OUTPUT_W;
    oHeight = OUTPUT_H;

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

    encodeStart( &cinfo, outfilename, oWidth, oHeight, quality );

     encodeWriteAPP1( header, length+74);

     zJpegSetRGBbuffer( &cinfo, rgbBuffer );

     /*
      * Decode the main image to the file
      */
printf("starting main image\n");
    (void) zJpegStartDecompress(&cinfo, freeInputBuffer, 0, gpuBuf.vBase, (unsigned long)gpuBuf.pBase); // Buffer assigned internally for now

    sem_wait(&done);

    zJpegSetRGBbuffer( &cinfo, NULL );
    encodeEnd();

    /*
     * Tidy Up
     */

    free(rgbBuffer);
    zJpegFinishDecompress(&cinfo);
    zJpegReleaseDecompress(&cinfo);
    GPU_Factory_Release(&gpuBuf);

    fclose(input_file);
  }
  else if (slideshow == TRUE)
  {
    DIR *dir;
    struct dirent *ptr;
    int imageCount = 0,
        k = loopCounter;
    char imgFile[128]; // Sometimes long paths!

    /*
     * Initialize the JPEG decompression object
     */

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

    printf("Slideshow Mode, %d loops requested...\n", k);
    while (k--)
    {
      dir = opendir(argv[file_index]);
      if (!dir)
      {
        printf("[ERROR] Failed to open dir '%s'\n", argv[file_index]);
        break;
      }
      else
      {
        while (NULL != (ptr = readdir(dir)))
        {
          oWidth  = OUTPUT_W;
          oHeight = OUTPUT_H;

          if ((!(memcmp(ptr->d_name+strlen(ptr->d_name)-4, ".jpg", 4))) ||
                (!(memcmp(ptr->d_name+strlen(ptr->d_name)-4, ".JPG", 4))))
          {
            /*
             * Decode and present an image
             */

            sprintf(imgFile, "%s", argv[file_index]);
            strcat(imgFile, ptr->d_name);
            imageCount++;
            if  (cinfo.err->trace_level)
            {
              printf("\nSlideshow - decoding %s [%d]\n", imgFile, imageCount);
            }

            if ((input_file = fopen(imgFile, READ_BINARY)) == NULL)
            {
              fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
              exit(EXIT_FAILURE);
            }

            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));
            }

            /*
             * 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;

            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...
             */

            zJpegReadHeader(&cinfo, thumbnail, &thumbnailFound);
            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;
            }

            /*
             * 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 );

            /*
             * (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
             */

            if (flush == TRUE)
            {
              if (imageCount & 1)
              {
                sleep(2);
                zJpegFlushDecoder();
              }
            }

            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));
            }

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

            zJpegFinishDecompress(&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);

            if (presentationDelay)
            {
              sleep(presentationDelay);
            }
          }
        }
      }
      closedir(dir);
    }
    printf("\nSlideshow done, %d images in total\n\n", imageCount);
    zJpegReleaseDecompress(&cinfo);
    zevio2d_disable_3dscr();
  }
  else if (play == TRUE)
  {
    int imageCount = 1;
    char imgFile[128]; // Sometimes long paths!

    /*
     * Initialize the JPEG decompression object
     */

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

    sprintf(imgFile, "%s00001.jpg", playRoot);

    if ((input_file = fopen(imgFile, READ_BINARY)) == NULL)
    {
      sprintf(imgFile, "%s00001.JPG", playRoot);
      if ((input_file = fopen(imgFile, READ_BINARY)) == NULL)
      {
        fprintf(stderr,
                "%s: can't open first frame - %s00001.[jpg|JPG]\n",
                progname,
                playRoot);
        exit(EXIT_FAILURE);
      }
      else
      {
        upperCase = TRUE;
      }
    }
    else
    {
      upperCase = FALSE;
    }
    fclose(input_file);

    printf("Play - %s\n\n", playRoot);
    while (1)
    {
      oWidth  = OUTPUT_W;
      oHeight = OUTPUT_H;

       /*
       * Decode and present an image
       */

      sprintf(imgFile, "%s%05u.%s", playRoot, imageCount++, (upperCase == TRUE) ? "JPG" : "jpg");

      if ((input_file = fopen(imgFile, READ_BINARY)) == NULL)
      {
        break;
      }

      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));
      }

      /*
       * 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;

      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...
       */