package de.desy.acop.video.displayer.timage;
   
   import java.awt.Color;
   import java.awt.Insets;
   import java.awt.image.BufferedImage;
   
   import de.desy.acop.video.displayer.ColorLookupTable;
   import de.desy.acop.video.displayer.ColorMap;
   import de.desy.acop.video.displayer.ImageBuffer;
  import de.desy.acop.video.displayer.ImageFlag;
  import de.desy.acop.video.displayer.ImageFormat;
  import de.desy.tine.types.IMAGE;
  import de.desy.tine.types.IMAGE.FrameHeader;
  import de.desy.tine.types.IMAGE.SourceHeader;
  
  /**
   * TINE Image <-> Java BufferedImage Converter.<br>
   * Note: Draft implementation
   * 
   * @author mdavid
   * @deprecated - use {@link TImageConverter} instead
   */
  public class TImageConverter {
  
  	/**
  	 * TINE Buffered Image used for creation/normalization images in memory
  	 * buffer.
  	 */
  	private ImageBuffer _imageBuffer = new ImageBuffer();
  
  	/**
  	 * Currently used color map
  	 */
  	private ColorMap _colorMap = ColorMap.GRAYSCALE;
  
  	/**
  	 * Currently used false color lookup.
  	 */
  	private ColorLookupTable _colorLookup;
  
  	/**
  	 * Default constructor
  	 */
  	public TImageConverter() {
  		super();
  	}
  
  	/**
  	 * Creates Java Image from TINE IMAGE
  	 * 
  	 * @param timage
  	 *            - a TINE IMAGE
  	 * @param aoiExpansion
  	 *            - if <code>true</code>the AOI Image should be surrounded by
  	 *            black pixels, otherwise not
  	 * @return java Image
  	 */
  	public BufferedImage parseTineImage(final IMAGE timage, boolean aoiExpansion) {
  		return parseTineImage(timage, aoiExpansion, ColorMap.GRAYSCALE);
  	}
  
  	/**
  	 * Creates Java Image from TINE IMAGE
  	 * 
  	 * @param timage
  	 *            - a TINE IMAGE
  	 * @param aoiExpansion
  	 *            - if <code>true</code>the AOI Image should be surrounded by
  	 *            black pixels, otherwise not
  	 * @param colorMap
  	 *            - colorMap to be used for conversion
  	 * @return java BufferedImage
  	 */
  	public BufferedImage parseTineImage(final IMAGE timage, boolean aoiExpansion, ColorMap colorMap) {
  		if (timage == null)
  			throw new IllegalStateException("timage == null!");
  
  		if (colorMap == null)
  			throw new IllegalStateException("colorMap == null!");
  
  		final IMAGE ti = timage.clone();
  
  		FrameHeader hdr = ti.getFrameHeader();
  		ImageFormat imageFormat = ImageFormat.valueOf(hdr.imageFormat);
  
  		// adjust false color lookup table
  		if (imageFormat == ImageFormat.IMAGE_FORMAT_GRAY // 
  				|| (imageFormat == ImageFormat.IMAGE_FORMAT_JPEG && hdr.bytesPerPixel == 1) //
  				|| (imageFormat == ImageFormat.IMAGE_FORMAT_HUFFYUV && ImageFormat.IMAGE_FORMAT_GRAY
  						.equals(hdr.sourceFormat))) {
  			if (_colorLookup == null // 
  					|| _colorLookup.getBytesPerPixel() != hdr.bytesPerPixel //
  					|| _colorLookup.getEffBitsPerPixel() != hdr.effectiveBitsPerPixel || _colorMap != colorMap) {
  				_colorLookup = new ColorLookupTable(colorMap, hdr.bytesPerPixel, hdr.effectiveBitsPerPixel);
  				_imageBuffer.setColorLookupTable(_colorLookup.getRGB());
  			}
  		}
  		_colorMap = colorMap;
  		BufferedImage bi = TImageUtils.toBufferedImage(_imageBuffer.createImage(ti));
 		if (aoiExpansion && (hdr.aoiWidth != -1 || hdr.aoiHeight != -1))
 			bi = TImageUtils.addInsets(bi, new Insets(hdr.yStart, hdr.xStart, //
 					hdr.sourceHeight - hdr.aoiHeight - hdr.yStart, //
 					hdr.sourceWidth - hdr.aoiWidth - hdr.xStart), Color.black);
 		return bi;
 	}
 
 	/**
 	 * Creates Java Image from TINE IMAGE.
 	 * 
 	 * @see #parseTineImageNoClone(IMAGE, boolean, ColorMap)
 	 * @param timage
 	 *            - a TINE IMAGE
 	 * @param aoiExpansion
 	 *            - if <code>true</code>the AOI Image should be surrounded by
 	 *            black pixels, otherwise not
 	 * @return java Image
 	 */
 	public BufferedImage parseTineImageNoClone(final IMAGE timage, boolean aoiExpansion) {
 		return parseTineImageNoClone(timage, aoiExpansion, ColorMap.GRAYSCALE);
 	}
 
 	/**
 	 * Creates Java Image from TINE IMAGE without cloning the original image.
 	 * This methods is much faster in comparison to
 	 * {@link #parseTineImage(IMAGE, boolean, ColorMap)}, but be careful about
 	 * thread safe opeartion: if the given image changes during the execution of
 	 * this method, that could cause troubles.
 	 * 
 	 * @param timage
 	 *            - a TINE IMAGE
 	 * @param aoiExpansion
 	 *            - if <code>true</code>the AOI Image should be surrounded by
 	 *            black pixels, otherwise not
 	 * @param colorMap
 	 *            - colorMap to be used for conversion
 	 * @return java BufferedImage
 	 */
 	public BufferedImage parseTineImageNoClone(final IMAGE timage, boolean aoiExpansion, ColorMap colorMap) {
 		if (timage == null)
 			throw new IllegalStateException("timage == null!");
 
 		if (colorMap == null)
 			throw new IllegalStateException("colorMap == null!");
 
 		FrameHeader hdr = timage.getFrameHeader();
 		ImageFormat imageFormat = ImageFormat.valueOf(hdr.imageFormat);
 
 		// adjust false color lookup table
 		if (imageFormat == ImageFormat.IMAGE_FORMAT_GRAY // 
 				|| (imageFormat == ImageFormat.IMAGE_FORMAT_JPEG && hdr.bytesPerPixel == 1) //
 				|| (imageFormat == ImageFormat.IMAGE_FORMAT_HUFFYUV && ImageFormat.IMAGE_FORMAT_GRAY
 						.equals(hdr.sourceFormat))) {
 			if (_colorLookup == null // 
 					|| _colorLookup.getBytesPerPixel() != hdr.bytesPerPixel //
 					|| _colorLookup.getEffBitsPerPixel() != hdr.effectiveBitsPerPixel || _colorMap != colorMap) {
 				_colorLookup = new ColorLookupTable(colorMap, hdr.bytesPerPixel, hdr.effectiveBitsPerPixel);
 				_imageBuffer.setColorLookupTable(_colorLookup.getRGB());
 			}
 		}
 		_colorMap = colorMap;
 		BufferedImage bi = TImageUtils.toBufferedImage(_imageBuffer.createImage(timage));
 		if (aoiExpansion && (hdr.aoiWidth != -1 || hdr.aoiHeight != -1))
 			bi = TImageUtils.addInsets(bi, new Insets(hdr.yStart, hdr.xStart, //
 					hdr.sourceHeight - hdr.aoiHeight - hdr.yStart, //
 					hdr.sourceWidth - hdr.aoiWidth - hdr.xStart), Color.black);
 		return bi;
 	}
 
 	/**
 	 * TODO:
 	 * 
 	 * @param src
 	 * @return TINE Image
 	 */
 	@SuppressWarnings("deprecation")
 	public static IMAGE parseBufferedImage(BufferedImage src) {
 		if (src == null)
 			throw new IllegalStateException("src == null!");
 
 		// System.out.println("Image Type: " + src.getType());
 
 		int width = src.getWidth();
 		int height = src.getHeight();
 		int numPixels = width * height;
 		int bytesPerPixel = 3; // RGB
 		int[] pixels = src.getRGB(0, 0, width, height, null, 0, width);
 		if (pixels == null)
 			throw new IllegalArgumentException("Can't get array of RGB pixels from buffered image!");
 
 		final IMAGE timage = new IMAGE(0);
 
 		IMAGE.FrameHeader frameHeader = timage.getFrameHeader();
 		frameHeader.bytesPerPixel = bytesPerPixel;
 		frameHeader.effectiveBitsPerPixel = 24;
 		frameHeader.imageFormat = frameHeader.sourceFormat = ImageFormat.IMAGE_FORMAT_RGB.getId();
 		frameHeader.appendedFrameSize = numPixels * bytesPerPixel;
 		frameHeader.imageFlags |= ImageFlag.IMAGE_LOSSLESS.getId();
 		frameHeader.sourceHeight = height;
 		frameHeader.sourceWidth = width;
 		frameHeader.xScale = frameHeader.yScale = 1;
 
 		IMAGE.SourceHeader sourceHeader = timage.getSourceHeader();
 		sourceHeader.totalLength = IMAGE.HEADER_SIZE + frameHeader.appendedFrameSize;
 
 		int pos = 0;
 		byte[] buf = new byte[frameHeader.appendedFrameSize];
 		for (int i = 0; i < numPixels; i++) {
 			buf[pos++] = (byte) ((pixels[i] >> 16) & 0xff); // R
 			buf[pos++] = (byte) ((pixels[i] >> 8) & 0xff); // G
 			buf[pos++] = (byte) (pixels[i] & 0xff); // B
 		}
 
 		timage.setImageFrameBuffer(buf);
 		return timage;
 	}
 
 	/**
 	 * TODO:
 	 * 
 	 * - resets aoi parameters - only for TYPE_INT_RGB/TYPE_INT_GRAY java images
 	 * - fraHeader and srcHeader are in/out parameters; application developer
 	 * will preset them and some fields may be changed inside method according
 	 * to bufferedImage characteristics - bufferedImage should be "easily"
 	 * converted to IMAGE, e.g. datatype ARGB of BufferedImage will become
 	 * datatype ARGB in TINE IMAGE (same for Gray8, 16, 24, RGB24...) - fields
 	 * in fraHeader and srcHeader which cannot be affected by bufferedImage
 	 * should NOT be touched - fields in fraHeader and srcHeader which are bound
 	 * to properties (like width, height, ...) of bufferedImage should be
 	 * changed to bufferedImage "fields" (ie. bufferedImage takes precedence
 	 * over settings encoded in fraHeader and srcHeader) * - shall flag LOSSLESS
 	 * in fraHeader be reset (because what's put in here is typically not some
 	 * thing lossless from the image source on)?
 	 * 
 	 * @param bi
 	 *            - input buffered image
 	 * @param frameHeader
 	 *            - in/out TINE frame header
 	 * @param sourceHeader
 	 *            - in/out TINE source header
 	 * @return
 	 */
 	@SuppressWarnings("deprecation")
 	public static IMAGE parseBufferedImage(BufferedImage bi, FrameHeader frameHeader, SourceHeader sourceHeader) {
 		if (bi == null)
 			throw new IllegalStateException("bi == null!");
 
 		if (frameHeader == null)
 			throw new IllegalStateException("frameHeader == null!");
 
 		if (sourceHeader == null)
 			throw new IllegalStateException("sourceHeader == null!");
 
 		int width = bi.getWidth();
 		int height = bi.getHeight();
 		int[] pixels = bi.getRGB(0, 0, width, height, null, 0, width);
 		if (pixels == null)
 			throw new IllegalArgumentException("Can't get array of RGB pixels from buffered image!");
 
 		int numPixels = width * height;
 
 		int itype = bi.getType();
 
 		int pos = 0;
 		byte[] buf;
 
 		switch (itype) {
 		case BufferedImage.TYPE_INT_RGB:
 			// case BufferedImage.TYPE_INT_ARGB:
 			frameHeader.bytesPerPixel = 3;
 			frameHeader.effectiveBitsPerPixel = 24;
 			frameHeader.imageFormat = frameHeader.sourceFormat = ImageFormat.IMAGE_FORMAT_RGB.getId();
 			frameHeader.appendedFrameSize = numPixels * frameHeader.bytesPerPixel;
 
 			buf = new byte[frameHeader.appendedFrameSize];
 
 			for (int i = 0; i < numPixels; i++) {
 				buf[pos++] = (byte) ((pixels[i] >> 16) & 0xff); // R
 				buf[pos++] = (byte) ((pixels[i] >> 8) & 0xff); // G
 				buf[pos++] = (byte) (pixels[i] & 0xff); // B
 			}
 			break;
 
 		case BufferedImage.TYPE_BYTE_GRAY:
 			frameHeader.bytesPerPixel = 1;
 			frameHeader.effectiveBitsPerPixel = 8;
 			frameHeader.imageFormat = frameHeader.sourceFormat = ImageFormat.IMAGE_FORMAT_GRAY.getId();
 			frameHeader.appendedFrameSize = numPixels * frameHeader.bytesPerPixel;
 
 			buf = new byte[frameHeader.appendedFrameSize];
 
 			for (int i = 0; i < numPixels; i++)
 				buf[i] = (byte) (pixels[i] & 0xff);
 
 			break;
 
 		default:
 			throw new IllegalArgumentException("Unsupported type of buffered image: " + itype);
 		}
 
 		frameHeader.sourceWidth = width;
 		frameHeader.sourceHeight = height;
 
 		frameHeader.aoiHeight = frameHeader.aoiWidth = -1;
 		frameHeader.xStart = frameHeader.yStart = -1;
 
 		final IMAGE timage = new IMAGE(0);
 		TImageUtils.setFrameHeader(timage, frameHeader);
 		TImageUtils.setSourceHeader(timage, sourceHeader);
 		timage.setImageFrameBuffer(buf);
 
 		return timage;
 	}
 }