PCDCodec.java :  » Graphic-Library » LaTeXDraw-2.0.8 » net » sourceforge » jiu » codecs » Java Open Source

Java Open Source » Graphic Library » LaTeXDraw 2.0.8 
LaTeXDraw 2.0.8 » net » sourceforge » jiu » codecs » PCDCodec.java
/*
 * PCDCodec
 * 
 * Copyright (c) 2000, 2001, 2002, 2003, 2004, 2005, 2006 Marco Schmidt.
 * All rights reserved.
 */

package net.sourceforge.jiu.codecs;

import java.io.IOException;
import java.io.RandomAccessFile;
import net.sourceforge.jiu.codecs.ImageCodec;
import net.sourceforge.jiu.codecs.InvalidFileStructureException;
import net.sourceforge.jiu.codecs.UnsupportedTypeException;
import net.sourceforge.jiu.codecs.WrongFileFormatException;
import net.sourceforge.jiu.color.YCbCrIndex;
import net.sourceforge.jiu.color.conversion.PCDYCbCrConversion;
import net.sourceforge.jiu.data.Gray8Image;
import net.sourceforge.jiu.data.IntegerImage;
import net.sourceforge.jiu.data.MemoryGray8Image;
import net.sourceforge.jiu.data.MemoryRGB24Image;
import net.sourceforge.jiu.data.RGB24Image;
import net.sourceforge.jiu.ops.MissingParameterException;
import net.sourceforge.jiu.ops.OperationFailedException;
import net.sourceforge.jiu.util.ArrayRotation;
import net.sourceforge.jiu.util.ArrayScaling;

/**
 * A codec to read Kodak Photo-CD (image pac) image files. 
 * Typical file extension is <code>.pcd</code>.
 * PCD is designed to store the same image in several resolutions.
 * Not all resolutions are always present in a file.
 * Typically, the first five resolutions are available and the file size
 * is between four and six megabytes.
 * Lossless compression (Huffman encoding) is used to store the higher resolution images.
 * All images are in 24 bit YCbCr colorspace, with a component subsampling of 4:1:1 (Y:Cb:Cr) 
 * in both horizontal and vertical direction.
 * <h3>Limitations</h3>
 * Only the lowest three resolutions are supported by this codec.
 * <h3>Sample PCD files</h3>
 * You can download sample PCD image files from
 * <a href="http://www.kodak.com/digitalImaging/samples/imageIntro.shtml">Kodak's
 * website</a>.
 *
 * @author Marco Schmidt
 */
public class PCDCodec extends ImageCodec implements YCbCrIndex
{
  /**
   * Base/16, the minimum pixel resolution, 192 x 128 pixels.
   */
  public static final int PCD_RESOLUTION_1 = 0;

  /**
   * Base/4, the second pixel resolution, 384 x 256 pixels.
   */
  public static final int PCD_RESOLUTION_2 = 1;

  /**
   * Base, the third pixel resolution, 768 x 512 pixels.
   */
  public static final int PCD_RESOLUTION_3 = 2;

  /**
   * Base*4, the fourth pixel resolution, 1536 x 1024 pixels. <em>Unsupported</em>
   */
  public static final int PCD_RESOLUTION_4 = 3;

  /**
   * Base*16, the fifth pixel resolution, 3072 x 2048 pixels. <em>Unsupported</em>
   */
  public static final int PCD_RESOLUTION_5 = 4;

  /**
   * Base*64, the sixth pixel resolution, 6144 x 4096 pixels. <em>Unsupported</em>
   */
  public static final int PCD_RESOLUTION_6 = 5;

  /**
   * Index for the default resolution , Base ({@link #PCD_RESOLUTION_3}).
   */
  public static final int PCD_RESOLUTION_DEFAULT = PCD_RESOLUTION_3;

  /**
   * This two-dimensional int array holds all possible pixel resolutions for
   * a PCD file. Use one of the PCD resolution constants (e.g.
   * {@link #PCD_RESOLUTION_3} as first index.
   * The second index must be 0 or 1 and leads to either width or
   * height.
   * Example: <code>PCD_RESOLUTION[PCD_RESOLUTION_3][1]</code> will evalute
   * as 512, which can be width or height, depending on the image being
   * in landscape or portrait mode.
   * You may want to use these resolution values in your program
   * to prompt the user which resolution to load from the file.
   */
  public static final int[][] PCD_RESOLUTIONS =
    {{192, 128}, {384, 256}, {768, 512},
     {1536, 1024}, {3072, 2048}, {6144, 4096}};
  // offsets into the file for the three uncompressed resolutions
  private static final long[] PCD_FILE_OFFSETS =
    {0x2000, 0xb800, 0x30000};
  /*private static final long[] PCD_BASE_LENGTH =
    {0x2000, 0xb800, 0x30000};*/
  // some constants to understand the orientation of an image
  private static final int NO_ROTATION = 0;
  private static final int ROTATE_90_LEFT = 1;
  private static final int ROTATE_180 = 2;
  private static final int ROTATE_90_RIGHT = 3;
  // 2048 bytes
  private static final int SECTOR_SIZE = 0x800;
  // "PCD_IPI"
  private static final byte[] MAGIC =
    {0x50, 0x43, 0x44, 0x5f, 0x49, 0x50, 0x49};
  private boolean performColorConversion;
  private boolean monochrome;
  private int numChannels;
  private int resolutionIndex;
  private RandomAccessFile in;
  private byte[][] data;

  /**
   * This constructor chooses the default settings for PCD image loading:
   * <ul>
   * <li>load color image (all channels, not only luminance)</li>
   * <li>perform color conversion from PCD's native YCbCr color space to RGB</li>
   * <li>load the image in the default resolution 
   *  {@link #PCD_RESOLUTION_DEFAULT}, 768 x 512 pixels (or vice versa)</li>
   * </ul>
   */
  public PCDCodec()
  {
    super();
    setColorConversion(true);
    setMonochrome(false);
    setResolutionIndex(PCD_RESOLUTION_DEFAULT);
  }

  private byte[][] allocateMemory()
  {
    int numPixels = PCD_RESOLUTIONS[resolutionIndex][0] *
      PCD_RESOLUTIONS[resolutionIndex][1];
    byte[][] result = new byte[numChannels][];
    for (int i = 0; i < numChannels; i++)
    {
      result[i] = new byte[numPixels];
    }
    return result;
  }

  /*private void checkByteArray(
    byte[][] data, 
    int numPixels) throws IllegalArgumentException
  {
    // check if array is non-null
    if (data == null)
    {
      throw new IllegalArgumentException("Error: Image channel array is not initialized.");
    }
    // check if array has enough entries
    int channels;
    if (monochrome)
    {
      channels = 1;
      if (data.length < 1)
      {
        throw new IllegalArgumentException("Error: Image channel " +
          "array must have at least one channel for monochrome " +
          "images.");
      }
    }
    else
    {
      channels = 3;
      if (data.length < 3)
      {
        throw new IllegalArgumentException("Error: Image channel " +
          "array must have at least three channels for color images.");
      }
    }
    // check if each channel has enough entries for the samples
    for (int i = 0; i < channels; i++)
    {
      if (data[i].length < numPixels)
      {
        throw new IllegalArgumentException("Error: Image channel #" + i + 
          " is not large enough (" + numPixels + " entries required, " +
          data[i].length + " found).");
      }
    }
  }*/

  private void convertToRgb(int width, int height)
  {
    byte[] red = new byte[width];
    byte[] green = new byte[width];
    byte[] blue = new byte[width];
    int offset = 0;
    for (int y = 0; y < height; y++)
    {
      PCDYCbCrConversion.convertYccToRgb(
        data[INDEX_Y], 
        data[INDEX_CB], 
        data[INDEX_CR], 
        offset,
        red, 
        green, 
        blue, 
        0, 
        width);
      System.arraycopy(red, 0, data[0], offset, width);
      System.arraycopy(green, 0, data[1], offset, width);
      System.arraycopy(blue, 0, data[2], offset, width);
      offset += width;
    }
  }

  private IntegerImage createImage(int width, int height)
  {
    if (monochrome)
    {
      Gray8Image image = new MemoryGray8Image(width, height);
      int offset = 0;
      for (int y = 0; y < height; y++)
      {
        for (int x = 0; x < width; x++)
        {
          image.putByteSample(0, x, y, data[0][offset++]);
        }
      }
      return image;
    }
    else
    if (performColorConversion)
    {
      RGB24Image image = new MemoryRGB24Image(width, height);
      int offset = 0;
      for (int y = 0; y < height; y++)
      {
        for (int x = 0; x < width; x++)
        {
          image.putByteSample(RGB24Image.INDEX_RED, x, y, data[0][offset]);
          image.putByteSample(RGB24Image.INDEX_GREEN, x, y, data[1][offset]);
          image.putByteSample(RGB24Image.INDEX_BLUE, x, y, data[2][offset]);
          offset++;
        }
      }
      return image;
    }
    else
    {
      return null;
    }
  }

  public String[] getFileExtensions()
  {
    return new String[] {".pcd"};
  }

  public String getFormatName()
  {
    return "Kodak Photo-CD (PCD)";
  }

  public String[] getMimeTypes()
  {
    return new String[] {"image/x-pcd"};
  }

  public boolean isLoadingSupported()
  {
    return true;
  }

  public boolean isSavingSupported()
  {
    return false;
  }

  /**
   * Attempts to load an image.
   * The codec must have been given an input stream, all other
   * parameters (do not convert color to RGB, load monochrome channel 
   * only, load other resolution than default) can optionally be
   * chosen by calling the corresponding methods.
   *
   * @return loaded image
   * @throws IOException if there were reading errors
   * @throws OutOfMemoryException if there was not enough free memory 
   *  available
   * @throws InvalidFileStructureException if the file seems to be a PCD
   *  stream but has logical errors in it
   * @throws WrongFileFormatException if this is not a PCD file
   */
  private void load() throws
    InvalidFileStructureException,
    IOException, 
    UnsupportedTypeException,
    WrongFileFormatException
  {
    if (resolutionIndex != PCD_RESOLUTION_1 &&
        resolutionIndex != PCD_RESOLUTION_2 &&
        resolutionIndex != PCD_RESOLUTION_3)
    {
      throw new UnsupportedTypeException("Error reading PCD input " +
        "stream. Only the three lowest resolutions are supported.");
    }
    if (in == null)
    {
      throw new IllegalArgumentException("Input file is missing " +
        "(use PCDCodec.setInput(RandomAccessFile).");
    }
    if (in.length() < 16 * 1024)
    {
      throw new WrongFileFormatException("Not a PCD file.");
    }
    byte[] sector = new byte[SECTOR_SIZE];
    // read first sector; first 7 bytes must be 0xff
    in.readFully(sector);
    for (int i = 0; i < 7; i++)
    {
      if (sector[i] != -1)
      {
        throw new WrongFileFormatException("Input is not a valid PCD " +
          "file (wrong magic byte sequence).");
      }
    }
    // read second sector and check more magic bytes
    in.readFully(sector);
    for (int i = 0; i < MAGIC.length; i++)
    {
      if (sector[i] != MAGIC[i])
      {
        throw new WrongFileFormatException("Input is not a valid PCD " +
          "file (wrong magic byte sequence).");
      }
    }
    // get image orientation and resolution
    int rotationAngle = sector[0x602] & 0x03;
    int width = PCD_RESOLUTIONS[resolutionIndex][0];
    int height = PCD_RESOLUTIONS[resolutionIndex][1];
    int realWidth = width;
    int realHeight = height;
    if (rotationAngle == ROTATE_90_LEFT || rotationAngle == ROTATE_90_RIGHT)
    {
      realWidth = height;
      realHeight = width;
    }
    if (!hasBounds())
    {
      setBounds(0, 0, realWidth - 1, realHeight - 1);
    }
    // determine which uncompressed image will be loaded
    int uncompressedResolution = resolutionIndex;
    if (resolutionIndex > PCD_RESOLUTION_3)
    {
      uncompressedResolution = PCD_RESOLUTION_3;
    }
    // load uncompressed image
    data = allocateMemory();
    loadUncompressedImage(uncompressedResolution);
    // reverse color subsampling if necessary
    if (!monochrome)
    {
      ArrayScaling.scaleUp200Percent(data[INDEX_CB],
        PCD_RESOLUTIONS[uncompressedResolution][0] / 2,
        PCD_RESOLUTIONS[uncompressedResolution][1] / 2);
      ArrayScaling.scaleUp200Percent(data[INDEX_CR],
        PCD_RESOLUTIONS[uncompressedResolution][0] / 2,
        PCD_RESOLUTIONS[uncompressedResolution][1] / 2);
    }
    // TODO load higher resolution by decoding differences to uncompressed image
    // ...
    // convert to RGB color space if possible and desired
    if ((!monochrome) && performColorConversion)
    {
      convertToRgb(width, height);
    }
    // rotate the image if necessary
    rotateArrays(rotationAngle, width, height);
    // adjust width and height
    if (rotationAngle == ROTATE_90_LEFT || rotationAngle == ROTATE_90_RIGHT)
    {
      int temp = width;
      width = height;
      height = temp;
    }
    setImage(createImage(width, height));
  }

  /**
   * Loads one of the three lowest resolution images from the file.
   * First skips as many bytes as there are between the current
   * stream offset and the offset of the image in the PCD file
   * (first three images are at fixed positions).
   * Then reads the pixels from in to data.
     * <p>
   * Note that there are <code>width</code> times <code>height</code>
   * samples for Y, but only one fourth that many samples for each Cb and Cr
   * (because of the 4:1:1 subsampling of the two chroma components).
   * <p>
   * @param resolution one of PCD_RESOLUTION_1, PCD_RESOLUTION_2 or PCD_RESOLUTION_3
   * @throws an IOException if there were any reading errors
   */
  private void loadUncompressedImage(int resolution)
    throws IllegalArgumentException, IOException
  {
    if (resolution != PCD_RESOLUTION_1 &&
        resolution != PCD_RESOLUTION_2 &&
        resolution != PCD_RESOLUTION_3)
    {
      throw new IllegalArgumentException("Error loading " +
        "PCD image, only the lowest three resolutions are " +
        "uncompressed.");
    }
    in.seek(PCD_FILE_OFFSETS[resolution]);
    int fullWidth = PCD_RESOLUTIONS[resolution][0];
    int fullHeight = PCD_RESOLUTIONS[resolution][1];
    int halfWidth = fullWidth / 2;
    int halfHeight = fullHeight / 2;
    int offset1 = 0;
    int offset2 = 0;
    for (int y = 0; y < halfHeight; y++)
    {
      // read two luminance rows
      in.readFully(data[INDEX_Y], offset1, fullWidth * 2);
      offset1 += (fullWidth * 2);
      if (monochrome)
      {
        if (in.skipBytes(fullWidth) != fullWidth)
        {
          throw new IOException("Could not skip " + fullWidth +
            " bytes.");
        }
      }
      else
      {
        // read one row for each cb and cr
        in.readFully(data[INDEX_CB], offset2, halfWidth);
        in.readFully(data[INDEX_CR], offset2, halfWidth);
        offset2 += halfWidth;
      }
    }
  }

  /**
   * Checks the parameter and loads an image.
   */
  public void process() throws
    InvalidFileStructureException,
    MissingParameterException,
    OperationFailedException,
    UnsupportedTypeException,
    WrongFileFormatException
  {
    in = getRandomAccessFile();
    if (in == null)
    {
      throw new MissingParameterException("RandomAccessFile object needed in PCDCodec.");
    }
    if (getMode() != CodecMode.LOAD)
    {
      throw new UnsupportedTypeException("PCDCodec can only load images.");
    }
    try
    {
      load();
    }
    catch (IOException ioe)
    {
      throw new OperationFailedException("I/O error: " + ioe.toString());
    }
  }

  private void rotateArrays(int rotationAngle, int width, int height)
  {
    if (rotationAngle == NO_ROTATION)
    {
      return;  
    }
    int numPixels = width * height;
    for (int i = 0; i < numChannels; i++)
    {
      byte[] dest = new byte[numPixels];
      switch(rotationAngle)
      {
        case(ROTATE_90_LEFT):
        {
          ArrayRotation.rotate90Left(width, height, data[i], 0, dest, 0);
          break;
        }
        case(ROTATE_90_RIGHT):
        {
          ArrayRotation.rotate90Right(width, height, data[i], 0, dest, 0);
          break;
        }
        case(ROTATE_180):
        {
          ArrayRotation.rotate180(width, height, data[i], 0, dest, 0);
          break;
        }
      }
      System.arraycopy(dest, 0, data[i], 0, numPixels);
    }
  }

  /*private void scaleUp(int currentResolution)
  {
    int width = PCD_RESOLUTIONS[currentResolution][0];
    int height = PCD_RESOLUTIONS[currentResolution][1];
    ArrayScaling.scaleUp200Percent(data[INDEX_Y], width, height);
    if (!monochrome)
    {
      ArrayScaling.scaleUp200Percent(data[INDEX_CB], width, height);
      ArrayScaling.scaleUp200Percent(data[INDEX_CR], width, height);
    }
  }*/

  /**
   * Specify whether color is converted from PCD's YCbCr color space to
   * RGB color space.
   * The default is <code>true</code>, and you should only change this
   * if you really know what you are doing.
   * If you simply want the luminance (gray) channel, use 
   * {@link #setMonochrome(boolean)} with <code>true</code> as parameter.
   * @param performColorConversion boolean that determines whether color conversion is applied
   */
  public void setColorConversion(boolean performColorConversion)
  {
    this.performColorConversion = performColorConversion;
  }

  public void setFile(String fileName, CodecMode codecMode) throws 
    IOException, 
    UnsupportedCodecModeException
  {
    if (codecMode == CodecMode.LOAD)
    {
      setRandomAccessFile(new RandomAccessFile(fileName, "r"), CodecMode.LOAD); 
    }
    else
    {
      throw new UnsupportedCodecModeException("This PCD codec can only load images.");
    }
  }

  /**
   * Specifies whether the image is to be loaded as gray or color image.
   * If argument is true, only the gray channel is loaded.
   */
  public void setMonochrome(boolean monochrome)
  {
    this.monochrome = monochrome;
    if (monochrome)
    {
      numChannels = 1;
    }
    else
    {
      numChannels = 3;
    }
  }

  public void setResolutionIndex(int resolutionIndex)
  {
    this.resolutionIndex = resolutionIndex;
  }
}
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.