package de.desy.acop.video.displayer;
   
   import java.awt.Graphics2D;
   import java.awt.Image;
   import java.awt.MediaTracker;
   import java.awt.Toolkit;
   import java.awt.image.BufferedImage;
   import java.awt.image.MemoryImageSource;
   import java.util.Arrays;
  
  import de.desy.tine.types.IMAGE;
  import de.desy.tine.types.IMAGE.FrameHeader;
  
  /**
   * The <code>ImageBuffer</code> class describes an {@link java.awt.Image Image}
   * with an accessible buffer of image data.
   * 
   * @author mdavid, sweisse
   * @deprecated replaced by TBufferedImage.toBufferedImage
   */
  public class ImageBuffer {
  
  	/**
  	 * Array of RGB pixels
  	 */
  	private int[] _pixels;
  
  	/**
  	 * Memory image which varies over time to allow animation or custom
  	 * rendering
  	 */
  	private MemoryImageSource _memorySource;
  
  	/**
  	 * Image instance buffer for rendered video image contents ready for drawing
  	 */
  	private Image _image;
  
  	/**
  	 * Array for false color lookup table.
  	 */
  	private int[] _colorLookupTable;
  
  	/**
  	 * Set to true if histogram equalization (normalization) should be applied,
  	 * otherwise false.
  	 */
  	private boolean _enabledNormalization;
  
  	/**
  	 * Dimension of last created memory source data image
  	 */
  	private int _width, _height;
  
  	/**
  	 * Constructor (default)
  	 */
  	public ImageBuffer() {
  		super();
  	}
  
  	/**
  	 * Get array of pixels
  	 * 
  	 * @return array of RGB pixels
  	 */
  	public int[] getPixels() {
  		return _pixels;
  	}
  
  	/**
  	 * Sets array of RGB pixels
  	 * 
  	 * @param pixels
  	 */
  	public void setPixels(int[] pixels) {
  		_pixels = pixels;
  	}
  
  	/**
  	 * Returns whether histogram equalization (normalization) is currently
  	 * enabled.
  	 * 
  	 * @return <code>true</code> if histogram equalization is enabled, otherwise
  	 *         <code>false</code>
  	 */
  	public boolean isEnabledNormalization() {
  		return _enabledNormalization;
  	}
  
  	/**
  	 * Sets whether or not the histogram equalization (normalization) is
  	 * enabled.
  	 * 
  	 * @param enabledNormalization
  	 *            true if normalization should be enabled, false otherwise
  	 */
  	public void setEnabledNormalization(boolean enabledNormalization) {
  		_enabledNormalization = enabledNormalization;
 	}
 
 	/**
 	 * @return false color lookup table
 	 */
 	public int[] getColorLookupTable() {
 		return _colorLookupTable;
 	}
 
 	/**
 	 * @param rgbArray
 	 *            - false color lookup table
 	 */
 	public void setColorLookupTable(int[] rgbArray) {
 		_colorLookupTable = rgbArray;
 	}
 
 	/**
 	 * updates JAVA TYPE_INT_ARGB displayImageBuffer based on any input data and
 	 * header the image displayer is capable of processing. In addition,
 	 * normalization of given input data type is applied on demand.<br>
 	 * 
 	 * @param timage
 	 *            RGB, ARGB, JPEG or Luminosity (Grayscale) TINE IMAGE
 	 * @return Java graphical image
 	 * 
 	 */
 	public Image createImage(IMAGE timage) {
 		if (timage == null)
 			throw new IllegalArgumentException("timage == null!");
 
 		FrameHeader hdr = timage.getFrameHeader();
 
 		// uncompress image data if necessary
 		if (ImageFormat.IMAGE_FORMAT_HUFFYUV.equals(hdr.imageFormat)
 				&& ImageFormat.IMAGE_FORMAT_GRAY.equals(hdr.sourceFormat))
 			uncompressImage(timage);
 
 		ImageFormat imageFormat = ImageFormat.valueOf(hdr.imageFormat);
 		if (!imageFormat.isSupported())
 			throw new IllegalArgumentException("unsupported image format: " + imageFormat);
 
 		int width = (hdr.aoiWidth != -1) ? hdr.aoiWidth : hdr.sourceWidth;
 		int height = (hdr.aoiHeight != -1) ? hdr.aoiHeight : hdr.sourceHeight;
 
 		if (_pixels == null || width != _width || height != _height) {
 			_pixels = new int[width * height];
 			_memorySource = null;
 		}
 		_width = width;
 		_height = height;
 
 		byte[] buff = timage.getImageFrameBuffer();
 		buff = Arrays.copyOf(buff, hdr.appendedFrameSize);
 		if (buff == null)
 			throw new NullPointerException("buff == null!");
 
 		switch (imageFormat) {
 		case IMAGE_FORMAT_GRAY:
 			fillGray(buff, hdr.bytesPerPixel, hdr.effectiveBitsPerPixel);
 			break;
 
 		case IMAGE_FORMAT_RGB:
 			fillRGB(buff);
 			break;
 
 		case IMAGE_FORMAT_RGBA:
 			fillRGBA(buff);
 			break;
 
 		case IMAGE_FORMAT_JPEG:
 			fillJPEG(buff, hdr.bytesPerPixel, hdr.effectiveBitsPerPixel);
 			break;
 
 		default:
 			break;
 		}
 
 		// renew image memory source
 		if (_memorySource == null) {
 			_memorySource = new MemoryImageSource(_width, _height, _pixels, 0, _width);
 			_memorySource.setAnimated(true);
 			_memorySource.setFullBufferUpdates(true);
 			_image = Toolkit.getDefaultToolkit().createImage(_memorySource);
 
 		} else
 			_memorySource.newPixels(); // TODO: mdavid check this
 
 		return _image;
 	}
 
 	/**
 	 * Uncompresses the TINE image data.
 	 * 
 	 * @param timage
 	 *            - input/output TINE IMAGE
 	 */
 	private void uncompressImage(IMAGE timage) {
 
 		FrameHeader fHdr = timage.getFrameHeader();
 		int uncompressed_byte_length = fHdr.bytesPerPixel //
 				* ((fHdr.aoiWidth != -1) ? fHdr.aoiWidth : fHdr.sourceWidth) //
 				* ((fHdr.aoiHeight != -1) ? fHdr.aoiHeight : fHdr.sourceHeight);
 
 		byte[] compressedBuf = new byte[fHdr.appendedFrameSize];
 
 		System.arraycopy(timage.getImageFrameBuffer(), 0, compressedBuf, 0, fHdr.appendedFrameSize);
 
 		// VideoHeaderV3.HDRSIZE
 		HuffmanDecompression.decompressHuffYUV(compressedBuf, 0, timage.getImageFrameBuffer(), 0,
 				uncompressed_byte_length);
 
 		// adjust header after compression
 		fHdr.imageFormat = ImageFormat.IMAGE_FORMAT_GRAY.getId();
 		fHdr.appendedFrameSize = uncompressed_byte_length;
 		timage.getSourceHeader().totalLength = uncompressed_byte_length + IMAGE.HEADER_SIZE;
 	}
 
 	/**
 	 * Fills array of RGB pixels based TINE image buffer passed as parameter.<br>
 	 * 
 	 * @param buff
 	 *            marshaled RGB (24 bits per pixel RGB) TINE image buffer
 	 */
 	private void fillRGB(byte[] buff) {
 		// transform RGB24 color into ARGB32 color for java Image
 		int index = 0;
 		int offset = 0;
 		try {
 			for (;;) {
 				int red = buff[offset++] & 0xFF;
 				int green = buff[offset++] & 0xFF;
 				int blue = buff[offset++] & 0xFF;
 				_pixels[index++] = 0xFF000000 | (red << 16) | (green << 8) | blue;
 			}
 		} catch (ArrayIndexOutOfBoundsException ignored) {
 			// ignored for speeding up
 		}
 
 		// normalize
 		if (_enabledNormalization)
 			normalize();
 	}
 
 	/**
 	 * Fills array of RGB pixels based TINE image buffer passed as parameter.<br>
 	 * 
 	 * @param buff
 	 *            marshaled RGB (32bpp a-r-g-b) TINE image buffer, alpha is
 	 *            <b>not</b> taken into account
 	 */
 	private void fillRGBA(byte[] buff) {
 		System.arraycopy(java.nio.ByteBuffer.wrap(buff).asIntBuffer(), 0, _pixels, 0, _pixels.length);
 
 		// normalize
 		if (_enabledNormalization)
 			normalize();
 	}
 
 	/**
 	 * updates JAVA TYPE_INT_ARGB displayImageBuffer based on JPEG file bits
 	 * data and header passed as parameter. In addition, color normalization is
 	 * applied on demand.<br>
 	 * 
 	 * @param buff
 	 *            marshaled JPEG file bits (whole file attached)TINE image
 	 *            buffer
 	 * 
 	 * @return <ul>
 	 *         <li>false - no update was done, error on creation or conversion
 	 *         <li>true - success
 	 *         </ul>
 	 * @param bytesPerPixel
 	 *            - physical bytes per pixel
 	 * @param effBitsPerPixel
 	 *            - effective bits per pixel
 	 */
 	private boolean fillJPEG(byte[] buff, int bytesPerPixel, int effBitsPerPixel) {
 		BufferedImage bi = null;
 		Image image = Toolkit.getDefaultToolkit().createImage(buff);
 		MediaTracker tracker = new MediaTracker(null);
 		tracker.addImage(image, 0);
 		try {
 			tracker.waitForID(0);
 
 		} catch (InterruptedException e) {
 			throw new RuntimeException("Image creation has been interrupted, message: " + e.getMessage());
 		}
 
 		if (bytesPerPixel == 1) { // it is grayscale / it is color JPEG image
 			bi = new BufferedImage(_width, _height, BufferedImage.TYPE_BYTE_GRAY);
 
 			Graphics2D bufImageGraphics = bi.createGraphics();
 			bufImageGraphics.drawImage(image, 0, 0, null);
 
 			// get ARGB data from java image into display buffer
 			int imgWidth = bi.getWidth();
 			int imgHeight = bi.getHeight();
 
 			if (imgWidth != _width || imgHeight != _height)
 				return false; // TODO: mdavid check this
 
 			byte[] buffNew = new byte[imgWidth * imgHeight];
 			byte[] pix = new byte[1];
 
 			int i = 0;
 
 			// swaps the rows
 			for (int y = 0; y < imgHeight; y++) {
 				// swaps the columns
 				for (int x = 0; x < imgWidth; x++) {
 					bi.getRaster().getDataElements(x, y, pix);
 					buffNew[i++] = pix[0];
 				}
 
 			}
 			fillGray(buffNew, bytesPerPixel, effBitsPerPixel);
 
 		} else {
 			bi = new BufferedImage(_width, _height, BufferedImage.TYPE_INT_ARGB);
 
 			Graphics2D bufImageGraphics = bi.createGraphics();
 			bufImageGraphics.drawImage(image, 0, 0, null);
 
 			// get ARGB data from java image into display buffer
 			int imgWidth = bi.getWidth();
 			int imgHeight = bi.getHeight();
 
 			if (imgWidth != _width || imgHeight != _height
 					|| bi.getRGB(0, 0, imgWidth, imgHeight, _pixels, 0, imgWidth) == null)
 				throw new RuntimeException("create JPEG image failed.");
 
 			if (_enabledNormalization)
 				normalize();
 		}
 		return true;
 	}
 
 	/**
 	 * updates JAVA TYPE_INT_ARGB displayImageBuffer based on grayscale data
 	 * passed as parameter. In addition, false color normalization is applied.
 	 * The normalization is numerically precise and quite good, however
 	 * consideration of algorithm modification is considered for future.<br>
 	 * <p>
 	 * support also jpeg 1bypp == grayscale jpeg
 	 * 
 	 * @param buff
 	 *            - marshaled grayscale TINE image buffer
 	 * @param bytesPerPixel
 	 *            - physical bytes per pixel
 	 * @param effBitsPerPixel
 	 *            - effective bits per pixel
 	 */
 	private void fillGray(byte[] buff, int bytesPerPixel, int effBitsPerPixel) {
 		// normalize
 		if (_enabledNormalization)
 			normalizeGray(buff, bytesPerPixel, effBitsPerPixel);
 
 		int[] colorLookupTable = _colorLookupTable;
 		if (colorLookupTable == null)
 			colorLookupTable = (new ColorLookupTable(ColorMap.GRAYSCALE, bytesPerPixel, effBitsPerPixel)).getRGB();
 
 		// convert to image using false-color table
 		// in other words: transform grayscale to ARGB32 values for java display
 		// distinct for each supported bytes per pixel setting (1, 2, 3)
 
 		int index = 0;
 		int i = 0;
 		if (bytesPerPixel == 1) {
 			try {
 				for (;;) {
 					_pixels[index] = colorLookupTable[buff[index] & 0xff];
 					index++;
 				}
 			} catch (ArrayIndexOutOfBoundsException ignored) {
 				// ignored for speeding up
 			}
 
 		} else if (bytesPerPixel == 2) {
 			try {
 				for (;;) {
 					i = 2 * index;
 					_pixels[index++] = colorLookupTable[(buff[i] & 0xff) + ((buff[i + 1] & 0xff) << 8)];
 				}
 			} catch (ArrayIndexOutOfBoundsException ignored) {
 				// ignored for speeding up
 			}
 
 		} else { // 3 bytes per pixel
 			try {
 				for (;;) {
 					i = 3 * index;
 					_pixels[index++] = colorLookupTable[(buff[i] & 0xff) + ((buff[i + 1] & 0xff) << 8)
 							+ ((buff[i + 2] & 0xff) << 16)];
 				}
 			} catch (ArrayIndexOutOfBoundsException ignored) {
 				// ignored for speeding up
 			}
 		}
 	}
 
 	/**
 	 * Apply RGB color histogram equalization to the display image buffer. This
 	 * method is used for JPEG, RGB and ARGB input data types. This function is
 	 * used/necessary for RGB color image normalization.
 	 * <p>
 	 * Note: </b>Quality of current color histogram equalization algorithm is
 	 * not very good and subject to further improvement.
 	 * <p>
 	 * TODO: the current normalization algorithm makes the image a little bit
 	 * too bright (clipping occurs) IDEA: maybe use Adobe Photoshop algorithm:
 	 * http://www.lonestardigital.com/autocontrast.htm display image buffer
 	 * contains ARGB
 	 * 
 	 * @return <code>TRUE</code> in case normalization was applied<br>
 	 *         <code>FALSE</code> in case normalization was not applied (no
 	 *         error, already good image, normalization not necessary/possible)
 	 */
 	private boolean normalize() {
 
 		// 1) calculate min/max of Y (luminosity) from RGB values of this buffer
 
 		double minY = 256.0;
 		double maxY = 0;
 		int x = 0;
 
 		try {
 			for (;;) {
 				int pixel = _pixels[x++];
 
 				int r = (pixel >> 16) & 0xff;
 				int g = (pixel >> 8) & 0xff;
 				int b = pixel & 0xff;
 
 				double Y = 0.299 * r + 0.587 * g + 0.114 * b;
 				if (Y < minY)
 					minY = Y;
 				if (Y > maxY)
 					maxY = Y;
 			}
 
 		} catch (ArrayIndexOutOfBoundsException ignored) {
 			// ignored for speeding up
 		}
 
 		// 2) create scaling factor and offset for stretching
 
 		int lowest = (int) minY;
 		int highest = (int) maxY;
 
 		if (lowest == highest)
 			return false;
 
 		double step = (255.0) / ((double) (maxY - minY));
 		double offset = -1.0 * step * minY;
 
 		// 3) render stretched display image buffer
 
 		x = 0;
 		try {
 			for (;;) {
 				int pixel = _pixels[x];
 
 				int r = (pixel >> 16) & 0xff;
 				int g = (pixel >> 8) & 0xff;
 				int b = pixel & 0xff;
 
 				double Y = 0.299 * r + 0.587 * g + 0.114 * b;
 				double Ynew = Y * step + offset;
 				double YnewdY = Ynew / Y;
 
 				int r2 = (int) (YnewdY * r);
 				int g2 = (int) (YnewdY * g);
 				int b2 = (int) (YnewdY * b);
 
 				if (r2 < 0)
 					r2 = 0;
 				if (g2 < 0)
 					g2 = 0;
 				if (b2 < 0)
 					b2 = 0;
 				if (r2 > 255)
 					r2 = 255;
 				if (g2 > 255)
 					g2 = 255;
 				if (b2 > 255)
 					b2 = 255;
 
 				_pixels[x++] = 0xFF000000 | (r2 << 16) | (g2 << 8) | (b2);
 			}
 
 		} catch (ArrayIndexOutOfBoundsException ignored) {
 			// ignored for speeding up
 		}
 
 		return true;
 	}
 
 	/**
 	 * Performs histogram equalization on single-z-dimension (e.g. luminosity
 	 * only) data
 	 * 
 	 * @param buff
 	 *            - marshaled grayscale TINE image buffer
 	 */
 	private void normalizeGray(byte[] buff, int bytesPerPixel, int effBitsPerPixel) {
 
 		int maxcol = (1 << effBitsPerPixel) - 1;
 
 		// with histogram equalization (normalize upper and lower)
 		int lowest = maxcol;
 		int highest = 0;
 
 		// (1) perform getting of lowest and highest intensity value
 		// distinct for each supported bytes per pixel setting (1, 2, 3)
 
 		int index = 0; // performance-tip
 		int bytelength = _pixels.length;
 
 		if (bytesPerPixel == 1) {
 			while (index < bytelength) {
 				int pixel = (buff[index] & maxcol);
 				if (pixel < lowest)
 					lowest = pixel;
 				if (pixel > highest && pixel <= maxcol)
 					highest = pixel;
 				index++;
 			}
 
 		} else if (bytesPerPixel == 2) {
 			bytelength *= 2;
 			while (index < bytelength) {
 				int pixel = ((buff[index]) & 0xff) + (((buff[index + 1]) & 0xff) << 8);
 				if (pixel < lowest)
 					lowest = pixel;
 				if (pixel > highest && pixel <= maxcol)
 					highest = pixel;
 				index += 2;
 			}
 
 		} else { // 3 bytes per pixel
 			bytelength *= 3;
 			while (index < bytelength) {
 				int pixel = ((buff[index]) & 0xff) + (((buff[index + 1]) & 0xff) << 8)
 						+ (((buff[index + 2]) & 0xff) << 16);
 				if (pixel < lowest)
 					lowest = pixel;
 				if (pixel > highest && pixel <= maxcol)
 					highest = pixel;
 				index += 3;
 			}
 		}
 
 		if (lowest == highest)
 			return;
 
 		// rescale the buffer if it is necessary (!)
 
 		// calculate factor and offset for scaling
 		double step = (double) maxcol / ((double) (highest - lowest));
 		int offset = (int) (-1.0 * step * lowest);
 
 		// (1) perform conversion of data (span over whole z-dimension)
 		// distinct for each supported bytes per pixel setting (1, 2, 3)
 		index = 0; // performance-tip
 		if (bytesPerPixel == 1) {
 			while (index < bytelength) {
 				int pixel = (buff[index] & 0xff);
 				if (pixel <= maxcol)
 					pixel = ((int) (step * (double) pixel)) + offset;
 				buff[index] = (byte) pixel;
 				index++;
 			}
 
 		} else if (bytesPerPixel == 2) {
 			while (index < bytelength) {
 				int pixel = (buff[index] & 0xff) + ((buff[index + 1] & 0xff) << 8);
 				if (pixel <= maxcol)
 					pixel = ((int) (step * (double) pixel)) + offset;
 				buff[index] = (byte) (pixel & 0xff);
 				buff[index + 1] = (byte) ((pixel >> 8) & 0xff);
 				index += 2;
 			}
 		} else { // 3 bytes per pixel
 			while (index < bytelength) {
 				int pixel = (buff[index] & 0xff) + ((buff[index + 1] & 0xff) << 8) + ((buff[index + 2] & 0xff) << 16);
 				if (pixel <= maxcol)
 					pixel = ((int) (step * (double) pixel)) + offset;
 				buff[index] = (byte) (pixel & 0xff);
 				buff[index + 1] = (byte) ((pixel >> 8) & 0xff);
 				buff[index + 2] = (byte) ((pixel >> 16) & 0xff);
 				index += 3;
 			}
 		}
 	}
 
 	/**
 	 * Resets all buffers
 	 */
 	public void reset() {
 		this._memorySource = null;
 		this._pixels = null;
 		this._image = null;
 	}
 
 	/**
 	 * @return last rendered Image
 	 */
 	public Image getImage() {
 		return _image;
 	}
 
 }