package de.desy.acop.video.displayer;
   
   //big memory for testing:
   //-Xms512m -Xmx512m -XX:PermSize=128m -XX:MaxPermSize=128m
   
   import java.awt.AlphaComposite;
   import java.awt.BorderLayout;
   import java.awt.Color;
   import java.awt.Dimension;
  import java.awt.Font;
  import java.awt.FontMetrics;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.Point;
  import java.awt.Rectangle;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.awt.event.MouseMotionListener;
  import java.awt.image.BufferedImage;
  import java.beans.ExceptionListener;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.io.File;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.text.SimpleDateFormat;
  import java.util.Calendar;
  import java.util.Date;
  
  import javax.swing.JPanel;
  import javax.swing.SwingUtilities;
  import javax.swing.Timer;
  
  import de.desy.acop.video.timageio.TBufferedImage;
  import de.desy.acop.video.timageio.TImageIO;
  import de.desy.acop.video.timageio.TImageMetadata;
  import de.desy.tine.types.IMAGE;
  import de.desy.tine.types.IMAGE.FrameHeader;
  
  /**
   * <code>ImageDisplayer</code> implements basic, but versatile display of video
   * images. Five guidelines were set at development startup:
   * <ul>
   * <li>pure Java-code, no Java native interface (JNI, which might improve speed
   * at cost of compatibility)
   * <li>fast (above average performance) of Java live image display
   * <li>providing of additional "image enhancement" methods like false color
   * mode(s), normalization
   * <li>support of JPEG, RGB raw, Grayscale and HuffYUV-compressed grayscale as
   * input data
   * <li>robustness (malformed data should do no harm and should be recognizable)
   * <li>easiness, intuitiveness of use (keep aspect ratio, overlaying of image
   * meta-data, obtain pixel value under cursor, save still image to PNG file,
   * facility-overridable splash and error screens)
   * </ul>
   * The component was designed that it can either be used inside a so-called ACOP
   * Video Bean as well as inside a stand alone application.
   * 
   * @author sweisse, mdavid
   * @version $Id: Templates.xml,v 1.10 2008/06/23 14:30:13 sweisse Exp $
   * 
   */
  public class ImageDisplayer extends JPanel implements TineImageReceiver {
  
  	private static final long serialVersionUID = 310376L;
  
  	public static final String INVALID_CAMERA_PORT_NAME = "invalid";
  
  	public static final String PROPERTY_KEEP_ASPECT_RATIO = "keepAspectRatio";
  	public static final String PROPERTY_AOI_ZOOM = "AOIZoom";
  	public static final String PROPERTY_OVERLAY_STATE = "overlayState";
  	public static final String PROPERTY_IMAGE_ZOOM = "imageZoom";
  	public static final String PROPERTY_HISTOGRAM_EQUALISATION = "histogramEqualisation";
  	public static final String PROPERTY_HISTOGRAM_MIN = "histogramMin";
  	public static final String PROPERTY_HISTOGRAM_MAX = "histogramMax";
  	public static final String PROPERTY_COLOR_MAP = "colorMap";
  
  	private static final int TIMER_DELAY = 250;
  
  	/**
  	 * Currently used color lookup table.
  	 */
  	private ImageCLUT _clut;
  
  	/**
  	 * Resizing an image in the ImageDisplayer pane (see description of
  	 * ImageZoom enumeration)
  	 */
  	private ImageZoom _imageZoom = ImageZoom.AUTO;
  
  	/**
  	 * see description of OverlayState enumeration
  	 */
  	private OverlayState _overlayState = OverlayState.AUTO;
  
  	/**
  	 * zooming out of area of interest (zoom area of interest to full rectangle
 	 * of component, but still do take account of aspect ratio if it is on)
 	 */
 	private boolean _aoiZoom;
 
 	/**
 	 * set to true if aspect ratio should be kept. At the moment, a pixel is
 	 * known to be square so aspect ratio takes into account the ratio of width
 	 * vs. height. This might change in future because VSv3 allows to detect and
 	 * take into account non- squared pixels.
 	 */
 	private boolean _keepAspectRatio;
 
 	/**
 	 * set to true if histogram equalization (aka. normalization, aka. contrast
 	 * enhancement) should be applied to any image before displayed. Makes sense
 	 * for dark scenes, very bright scenes or more in general any scene with low
 	 * contrast. Color histogram equalization is numerically well but is
 	 * outperformed by professional algorithms. This might be improved in
 	 * future. Same but weaker effect is known for luminosity (grayscale)
 	 * normalization.
 	 */
 	private boolean _histogramEqualisation;
 
 	/**
 	 * Histogram data min value
 	 */
 	private int _histogramMin = UNDEFINED_CONDITION;
 
 	/**
 	 * Histogram data max value
 	 */
 	private int _histogramMax = UNDEFINED_CONDITION;
 
 	/**
 	 * Set to true if live transfer is taking place and is not timed out. Set to
 	 * false if either live transfer is running but timed out or not running
 	 * (stop mode) at all.
 	 */
 	private boolean _isLiveTransfer;
 
 	/** dedicated synchronization (thread lock) object */
 	private Object _lockHeaderUpdate = new Object();
 
 	/** is the mouse arrow inside the video canvas? */
 	private boolean _isMouseInCanvas;
 
 	/** is the cursor inside the video canvas and is the left/right button down */
 	private boolean _isMousePressed;
 
 	/**
 	 * instance that will buffer the special error screen about to be displayed
 	 * if video image data could not properly be decoded or displayed
 	 */
 	private IMAGE _errorScreen;
 
 	/**
 	 * extracted but volatile video header out of current "about-to-be"
 	 * displayed frame. Values are altered if header data is preprocessed and
 	 * changed during image prepare inside this class.
 	 */
 	private IMAGE _timage;
 
 	/**
 	 * Image counter
 	 */
 	private ImageCounter _imageCounter = new ImageCounter();
 
 	/**
 	 * Image instance buffer for rendered video image contents ready for drawing
 	 */
 	private BufferedImage _image;
 
 	/** Camera port ID for last received frame */
 	private long _lastCameraPortId = UNDEFINED_CONDITION;
 
 	/**
 	 * the timer manually repainting the images
 	 */
 	private Timer _timer;
 
 	/**
 	 * Exception Listener
 	 * 
 	 * @see ImageDisplayer#setExceptionListener(ExceptionListener)
 	 */
 	private ExceptionListener _exceptionListener;
 
 	/** Constructs class */
 	public ImageDisplayer() {
 		initialize();
 	}
 
 	@Override
 	protected void paintComponent(Graphics g) {
 		// long t = System.currentTimeMillis();
 
 		super.paintComponents(g);
 
 		if (_timer != null && _timer.isRunning())
 			_timer.stop();
 
 		// for (int i = 0; i < 10; i++) {
 		BufferedImage bi = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
 		Graphics2D g2 = bi.createGraphics();
 		try {
 			drawFrame(g2, _image);
 		} finally {
 			g2.dispose();
 		}
 		g.drawImage(bi, 0, 0, null);
 		// }
 		// System.out.println("Rendered:  " + (System.currentTimeMillis() - t));
 	}
 
 	/**
 	 * Returns current Tine image
 	 * 
 	 * @return TINE image
 	 */
 	public IMAGE getIMAGE() {
 		return _timage;
 	}
 
 	/**
 	 * returns the currently used color lookup table.
 	 * 
 	 * @return currently used color lookup table
 	 */
 	public ImageCLUT getCLUT() {
 		return _clut;
 	}
 
 	/**
 	 * Sets color lookup table.
 	 * 
 	 * @param newValue
 	 *            new color lookup table
 	 */
 	public void setCLUT(ImageCLUT newValue) {
 		ImageCLUT oldValue = _clut;
 		_clut = newValue;
 		firePropertyChange(PROPERTY_COLOR_MAP, oldValue, newValue);
 	}
 
 	/**
 	 * Updates the currently used false color map.
 	 * 
 	 * @param newValue
 	 *            - new color map to use
 	 */
 	public void setColorMap(ColorMap newValue) {
 		System.out.println("ImageDisplayer.setColorMap()");
 		setCLUT(new ImageCLUT(newValue, _clut.getComponentSize()));
 	}
 
 	/**
 	 * returns the currently used false color map to outside world.
 	 * 
 	 * @return currently used false color map
 	 */
 	public ColorMap getColorMap() {
 		if (_clut == null)
 			throw null;
 		return _clut.getColorMap();
 	}
 
 	/**
 	 * Sets image zoom
 	 * 
 	 * @param newValue
 	 *            - new image zoom value
 	 */
 	public void setImageZoom(ImageZoom newValue) {
 		ImageZoom oldValue = _imageZoom;
 		_imageZoom = newValue;
 		firePropertyChange(PROPERTY_IMAGE_ZOOM, oldValue, newValue);
 	}
 
 	/**
 	 * Returns image zoom.
 	 */
 	public ImageZoom getImageZoom() {
 		return _imageZoom;
 	}
 
 	/**
 	 * Sets overlay state mode
 	 * 
 	 * @param newValue
 	 *            - new overlay state value
 	 */
 	public void setOverlayState(OverlayState newValue) {
 		OverlayState oldValue = _overlayState;
 		_overlayState = newValue;
 		firePropertyChange(PROPERTY_OVERLAY_STATE, oldValue, newValue);
 	}
 
 	/**
 	 * Returns overlay information state.
 	 */
 	public OverlayState getOverlayState() {
 		return _overlayState;
 	}
 
 	/**
 	 * Sets whether or not the histogram equalization (normalization) is
 	 * enabled.<br>
 	 * After new assignment, drawing as well as repainting is enforced to update
 	 * all involved parts of code so that Histogram Equalization is immediately
 	 * applied to image.
 	 * 
 	 * @param newValue
 	 *            - switch histogram equalization on (true) or off (false)
 	 */
 	public void setHistogramEqualisation(boolean newValue) {
 		boolean oldValue = _histogramEqualisation;
 		_histogramEqualisation = newValue;
 		firePropertyChange(PROPERTY_HISTOGRAM_EQUALISATION, oldValue, newValue);
 	}
 
 	/**
 	 * returns whether histogram equalization (normalization) is currently
 	 * enabled.
 	 * 
 	 * @return <code>true</code> if histogram equalization is enabled, otherwise
 	 *         <code>false</code>
 	 */
 	public boolean isHistogramEqualisation() {
 		return _histogramEqualisation;
 	}
 
 	/**
 	 * Sets histogram min value
 	 * 
 	 * @param newValue
 	 *            - histogram min value
 	 */
 	public void setHistogramMin(int newValue) {
 		int max = getHistogramMax();
 		validateMinMax(newValue, _clut.getMinValue(), (max == UNDEFINED_CONDITION ? _clut.getMaxValue() : max) - 1);
 		int oldValue = _histogramMin;
 		_histogramMin = newValue;
 		firePropertyChange(PROPERTY_HISTOGRAM_MIN, oldValue, newValue);
 	}
 
 	/**
 	 * returns histogram min value
 	 * 
 	 * @return histogram min value
 	 */
 	public int getHistogramMin() {
 		return _histogramMin;
 	}
 
 	/**
 	 * Sets histogram max value
 	 * 
 	 * @param newValue
 	 *            - histogram max value
 	 */
 	public void setHistogramMax(int newValue) {
 		int min = getHistogramMin();
 		validateMinMax(newValue, (min == UNDEFINED_CONDITION ? _clut.getMinValue() : min) + 1, _clut.getMaxValue());
 		int oldValue = _histogramMax;
 		_histogramMax = newValue;
 		firePropertyChange(PROPERTY_HISTOGRAM_MAX, oldValue, newValue);
 	}
 
 	private void validateMinMax(int value, int min, int max) {
 		if (value < min || value > max)
 			throw new IllegalArgumentException(value + " is out of range [" // 
 					+ min + ", " + max + "]");
 	}
 
 	/**
 	 * returns histogram max value
 	 * 
 	 * @return histogram max value
 	 */
 	public int getHistogramMax() {
 		return _histogramMax;
 	}
 
 	/**
 	 * Switches 'AOI zoom' on or off. This method will do nothing if the AOI
 	 * zoom mode is already in the state about to be set. Repainting is enforced
 	 * to have an immediate update.
 	 * 
 	 * @param aoiZoom
 	 *            - enable (true) or disable (false) AOI zooming
 	 */
 	public void setAOIZoom(boolean aoiZoom) {
 		boolean oldValue = _aoiZoom;
 		_aoiZoom = aoiZoom;
 		firePropertyChange(PROPERTY_AOI_ZOOM, oldValue, aoiZoom);
 	}
 
 	/**
 	 * returns whether out zooming of AOI (no black border around AOI which
 	 * depicts full frame) is currently enabled.
 	 * 
 	 * @return true - AOI Zoom is switched on<br>
 	 *         false - AOI Zoom is switched off
 	 */
 	public boolean isAOIZoom() {
 		return _aoiZoom;
 	}
 
 	/**
 	 * Switches 'aspect ratio is kept' on or off. This method will do nothing if
 	 * the aspect ratio mode is already in the state about to be set. Repainting
 	 * is enforced to have an immediate update.
 	 * 
 	 * @param keepAspectRatio
 	 *            - enable (true) or disable (false) keeping of aspect ratio
 	 */
 	public void setKeepAspectRatio(boolean keepAspectRatio) {
 		boolean oldValue = _keepAspectRatio;
 		_keepAspectRatio = keepAspectRatio;
 		firePropertyChange(PROPERTY_KEEP_ASPECT_RATIO, oldValue, keepAspectRatio);
 	}
 
 	/**
 	 * returns whether 'aspect ratio is kept' is currently enabled.
 	 * 
 	 * @return true - 'aspect ratio is kept' is switched on<br>
 	 *         false - 'aspect ratio is kept' is switched off
 	 */
 	public boolean isKeepAspectRatio() {
 		return _keepAspectRatio;
 	}
 
 	/**
 	 * informs the displayer that a lot of frames are constantly to be
 	 * drawn(true) or it is not very likely that a lot of frames are drawn
 	 * (timeout on transfer or stop mode).
 	 * 
 	 * The method was invented for performance reasons. When a lot of frames are
 	 * coming in each second it can be a very time-consuming process for Java.
 	 * In order to off-load some performance, certain Java-scheduled redrawing
 	 * of the component is disabled because it is redrawn with each new video
 	 * image coming in anyhow.
 	 * 
 	 * @param aLive
 	 *            <ul>
 	 *            <li>true: live mode is set, a lot of frames are expected
 	 *            <li>false: either live mode was stopped or timeout happened
 	 *            </ul>
 	 */
 	public void setLiveTransfer(boolean aLive) {
 		_isLiveTransfer = aLive;
 	}
 
 	/**
 	 * resets important internal parameters. This method must be called from
 	 * outside (e.g. image provider like TineHandler) in order to prepare the
 	 * displayer for a new chunk of subsequent images.
 	 * 
 	 */
 	public void resetForReceiving() {
 		_imageCounter.reset();
 	}
 
 	/**
 	 * passes/injects a new image into image processing, drawing and redrawing
 	 * pipeline.
 	 * 
 	 * Uses thread locking for proper synchronization. Drawing and Displaying is
 	 * done inside invoked Swing thread.
 	 * 
 	 * @param ti
 	 *            new TINE image
 	 */
 	public void updateValue(IMAGE ti) {
 		_timage = ti;
 		long cameraPortId = ti.getSourceHeader().cameraPortId;
 		if (cameraPortId != _lastCameraPortId) {
 			if (cameraPortId != IMAGE.DEFAULT_CAMERA_PORT_ID) {
 				if (_lastCameraPortId != UNDEFINED_CONDITION)
 					_imageCounter.reset();
 			} else
 				System.out.println("WARN: value of camera port ID: " + cameraPortId);
 			_lastCameraPortId = cameraPortId;
 		}
 
 		FrameHeader frmHdr = ti.getFrameHeader();
 
 		// update image frame counter
 		_imageCounter.calculate(frmHdr.frameNumber);
 
 		// update CLUT and Histogram min/max values
 		boolean isGrayscale = (frmHdr.imageFormat == 0 || frmHdr.imageFormat == 10 || (frmHdr.imageFormat == 5 && frmHdr.bytesPerPixel == 1));
 		if (isGrayscale) {
 			if (_clut == null || frmHdr.effectiveBitsPerPixel != _clut.getPixelSize()) {
 				ImageCLUT clut = new ImageCLUT(_clut == null ? ColorMap.GRAYSCALE : _clut.getColorMap(),
 						new int[] { frmHdr.effectiveBitsPerPixel });
 				setCLUT(clut);
 				setHistogramMin(0);
 				setHistogramMax(clut.getMaxValue());
 
 			} else if (ColorMap.NONE.equals(_clut.getColorMap()))
 				setCLUT(new ImageCLUT(ColorMap.GRAYSCALE, new int[] { frmHdr.effectiveBitsPerPixel }));
 
 		} else if (_clut == null || !ColorMap.NONE.equals(_clut.getColorMap()) || !_clut.isRGB()) {
 			ImageCLUT clut = new ImageCLUT(ColorMap.NONE, new int[] { 8, 8, 8 });
 			setCLUT(clut);
 			setHistogramMin(0);
 			setHistogramMax(clut.getMaxValue());
 		}
 
 		// create BufferedImage for rendering
 		Runnable r = new Runnable() {
 			public void run() {
 				createBufferedImage();
 			}
 		};
 
 		if (SwingUtilities.isEventDispatchThread()) {
 			r.run();
 		} else {
 			SwingUtilities.invokeLater(r);
 		}
 	}
 
 	// private void updateHistogramMinMax(int maxValue) {
 	// int max = getHistogramMax();
 	// int min = getHistogramMin();
 	// max = Math.min(max == UNDEFINED_CONDITION ? maxValue : max, maxValue);
 	// min = Math.min(min == UNDEFINED_CONDITION ? 0 : min, max - 1);
 	//
 	// System.out.println("ImageDisplayer.updateHistogramMinMax(" + min + ", " +
 	// max + ")");
 	//
 	// setHistogramMin(min);
 	// setHistogramMax(max);
 	// }
 
 	/**
 	 * Takes a snapshot of the currently displayed image. TODO: mdavid
 	 * 
 	 * @return a snapshot of the current image
 	 */
 	public BufferedImage getSnapshotImage() {
 		return _image;
 	}
 
 	/**
 	 * Saves the currently displayed image as archival PNG file.
 	 * 
 	 * @param fileNamePath
 	 *            Filename of PNG file with extension, may include path
 	 * @return <code>false</code> if an error occurs during writing, otherwise
 	 *         <code>true</code>
 	 */
 	public boolean saveAsPNGImage(String fileNamePath) {
 		synchronized (_lockHeaderUpdate) {
 			try {
 				return TImageIO.write(new TBufferedImage(_timage), new File(fileNamePath));
 
 			} catch (Exception e) {
 				getExceptionListener().exceptionThrown(e);
 			}
 			return false;
 		}
 	}
 
 	/**
 	 * Exports the currently displayed image as exported PNG file.
 	 * 
 	 * @param fileNamePath
 	 *            Filename of PNG file with extension, may include path
 	 * @return <code>false</code> if an error occurs during writing, otherwise
 	 *         <code>true</code>
 	 */
 	public boolean exportToPNG(String fileNamePath) {
 		synchronized (_lockHeaderUpdate) {
 			try {
 
 				// long t = System.currentTimeMillis();
 				// BufferedImage rgbImage = TBufferedImage.toImageRGB(_image);
 				// System.out.println("toImageRGB: " +
 				// (System.currentTimeMillis() - t));
 
 				return TImageIO.write(new TBufferedImage(TBufferedImage.toImageRGB(_image), null), //
 						new File(fileNamePath));
 
 				// return TImageIO.write(new TBufferedImage(rgbImage, new
 				// TImageMetadata(_image)), new File(fileNamePath));
 
 				// return TImageIO.write(new TBufferedImage(_timage,
 				// _clut.getColorMap(), _histogramEqualisation, true),
 				// new File(fileNamePath));
 
 			} catch (Exception e) {
 				getExceptionListener().exceptionThrown(e);
 			}
 			return false;
 		}
 	}
 
 	// //////////////////////////////////////////////////////////////////////////
 	// /
 	//
 	// private methods
 	//
 	// //////////////////////////////////////////////////////////////////////////
 	// /
 
 	/**
 	 * This method initializes this current instance in order to display video
 	 * images. Splash screen will be shown if the component is drawn after
 	 * initialize() was finished.
 	 * 
 	 * @return void
 	 */
 	private void initialize() {
 
 		setLayout(new BorderLayout());
 		// setBackground(Color.darkGray);
 
 		// create mouse listeners
 		addMouseListener(new MouseListener() {
 			@Override
 			public void mouseClicked(MouseEvent e) {
 				// TODO Auto-generated method stub
 			}
 
 			@Override
 			public void mouseEntered(MouseEvent e) {
 				_isMouseInCanvas = true;
 				if (_overlayState == OverlayState.AUTO)
 					repaintImage();
 			}
 
 			@Override
 			public void mouseExited(MouseEvent e) {
 				_isMouseInCanvas = false;
 				if (_overlayState == OverlayState.AUTO)
 					repaintImage();
 			}
 
 			@Override
 			public void mousePressed(MouseEvent e) {
 				_isMousePressed = true;
 				if (_overlayState == OverlayState.ON || _overlayState == OverlayState.AUTO)
 					repaintImage();
 			}
 
 			@Override
 			public void mouseReleased(MouseEvent e) {
 				_isMousePressed = false;
 				if (_overlayState == OverlayState.ON || _overlayState == OverlayState.AUTO)
 					repaintImage();
 			}
 
 		});
 
 		addMouseMotionListener(new MouseMotionListener() {
 			@Override
 			public void mouseDragged(MouseEvent e) {
 				if (_overlayState == OverlayState.ON || _overlayState == OverlayState.AUTO)
 					repaintImage();
 			}
 
 			@Override
 			public void mouseMoved(MouseEvent e) {
 			}
 		});
 
 		addPropertyChangeListener(new PropertyChangeListener() {
 			public void propertyChange(PropertyChangeEvent e) {
 				String propertyChanged = e.getPropertyName();
 				if (propertyChanged.equals(PROPERTY_KEEP_ASPECT_RATIO) //
 						|| propertyChanged.equals(PROPERTY_OVERLAY_STATE)) {
 					repaintImage();
 
 				} else if (propertyChanged.equals(PROPERTY_IMAGE_ZOOM)) {
 					setPreferredSize(ImageZoom.AUTO.equals(_imageZoom) ? new Dimension(0, 0) : getZoomedSize(_image
 							.getWidth(), _image.getHeight(), getWidth(), getHeight()));
 					revalidate();
 					repaintImage();
 
 				} else if (propertyChanged.equals(PROPERTY_AOI_ZOOM) //
 						|| propertyChanged.equals(PROPERTY_HISTOGRAM_EQUALISATION) //
 						|| propertyChanged.equals(PROPERTY_HISTOGRAM_MIN) //
 						|| propertyChanged.equals(PROPERTY_HISTOGRAM_MAX) //
 						|| propertyChanged.equals(PROPERTY_COLOR_MAP)) {
 					createBufferedImage();
 				}
 			}
 		});
 
 		createSplashScreen(_timage = new IMAGE(0));
 		updateValue(_timage);
 	}
 
 	/**
 	 * loads or creates a splash screen. If a file "splash.png" can be found in
 	 * the current directory on disk and can be loaded, it is used as splash
 	 * screen. Otherwise, a basic splash screen is generated which is just a
 	 * pure black video image.<br>
 	 * <br>
 	 * The splash screen is shown when the ImageDisplayer is shown or drawn and
 	 * updateValue was not called a single time from outside before.
 	 * 
 	 * @param destImage
 	 *            reference to the IMAGE instance that will store the splash
 	 *            screen
 	 */
 	@SuppressWarnings("deprecation")
 	private void createSplashScreen(IMAGE destImage) {
 		if (destImage == null) {
 			getExceptionListener().exceptionThrown(new NullPointerException("destImage == null!"));
 			return;
 		}
 
 		String strURL = System.getProperty("splashImage.url");
 		URL splashURL = null;
 		try {
 			if (strURL == null || (strURL = strURL.trim()).isEmpty())
 				splashURL = (new File("splash.png")).toURI().toURL();
 			else
 				splashURL = new URL(strURL);
 
 		} catch (MalformedURLException e) {
 			getExceptionListener().exceptionThrown(e);
 			return;
 		}
 
 		// TODO: remove loading IMM splash (!?)
 		if (!ImageParser.loadImageFile(splashURL, destImage, false) && !ImageParser.loadIMM("splash.imm", destImage)) {
 			// obtain references:
 			IMAGE.FrameHeader frameHeader = destImage.getFrameHeader();
 			IMAGE.SourceHeader sourceHeader = destImage.getSourceHeader();
 
 			// set data of frameHeader
 			frameHeader.bytesPerPixel = 1;
 			frameHeader.appendedFrameSize = 768 * 576 * frameHeader.bytesPerPixel;
 			frameHeader.effectiveBitsPerPixel = 8;
 
 			// mdavid: changed
 			frameHeader.imageFlags |= ImageFlag.IMAGE_LOSSLESS.getId();
 
 			frameHeader.imageFormat = frameHeader.sourceFormat = ImageFormat.IMAGE_FORMAT_GRAY.getId();
 			frameHeader.sourceHeight = 576;
 			frameHeader.sourceWidth = 768;
 			frameHeader.xScale = frameHeader.yScale = 1F;
 
 			// set data of sourceHeader
 			sourceHeader.cameraPortName = "Internal Backup Splashscreen";
 			java.util.Calendar c = java.util.Calendar.getInstance();
 			sourceHeader.timestampMicroseconds = (int) (((c.getTimeInMillis() % ((long) 1000)) * ((long) 1000)));
 			sourceHeader.timestampSeconds = (int) (((c.getTimeInMillis()) / ((long) 1000)));
 			sourceHeader.totalLength = IMAGE.HEADER_SIZE + frameHeader.appendedFrameSize;
 
 			byte[] buf = new byte[frameHeader.appendedFrameSize];
 
 			// imperformant, but easy solution:
 			for (int i = 0; i < frameHeader.sourceWidth * frameHeader.sourceHeight;)
 				buf[i++] = (byte) 0;
 
 			destImage.setImageFrameBuffer(buf);
 		}
 
 	}
 
 	/**
 	 * loads or creates an error screen. If a file "error.png" can be found in
 	 * the current directory on disk and can be loaded, it is used as error
 	 * screen. Otherwise, a basic error screen is generated which is a random
 	 * noise screen (should look like _static_ (paused) white noise in analog
 	 * TV.<br>
 	 * <br>
 	 * The error screen is shown in case the current video image could not be
 	 * decoded, displayed or is generally malformed (header bad, ...). A special
 	 * textual region will be embedded in the noisy error screen stating that
 	 * the current frame could not be displayed.
 	 * 
 	 * @param destImage
 	 *            reference to the IMAGE instance that will store the error
 	 *            screen in memory
 	 */
 	@SuppressWarnings("deprecation")
 	private void createErrorScreen(IMAGE destImage) {
 		if (destImage == null) {
 			getExceptionListener().exceptionThrown(new NullPointerException("destImage == null!"));
 			return;
 		}
 
 		String strURL = System.getProperty("errorImage.url");
 		URL splashURL = null;
 		try {
 			if (strURL == null || (strURL = strURL.trim()).isEmpty())
 				splashURL = (new File("error.png")).toURI().toURL();
 			else
 				splashURL = new URL(strURL);
 
 		} catch (MalformedURLException e) {
 			getExceptionListener().exceptionThrown(e);
 			return;
 		}
 
 		if (!ImageParser.loadImageFile(splashURL, destImage, false)) {
 
 			// obtain references:
 			IMAGE.FrameHeader frameHeader = destImage.getFrameHeader();
 			IMAGE.SourceHeader sourceHeader = destImage.getSourceHeader();
 
 			// set data of frameHeader
 			frameHeader.appendedFrameSize = 768 * 576;
 			frameHeader.bytesPerPixel = 1;
 			frameHeader.effectiveBitsPerPixel = 8;
 
 			// mdavid: changed
 			frameHeader.imageFlags |= ImageFlag.IMAGE_LOSSLESS.getId();
 
 			frameHeader.imageFormat = ImageFormat.IMAGE_FORMAT_GRAY.getId();
 			frameHeader.sourceFormat = ImageFormat.IMAGE_FORMAT_GRAY.getId();
 			frameHeader.sourceHeight = 576;
 			frameHeader.sourceWidth = 768;
 			frameHeader.xScale = frameHeader.yScale = 1F;
 
 			// set data of sourceHeader
 			sourceHeader.cameraPortName = INVALID_CAMERA_PORT_NAME;
 			java.util.Calendar c = java.util.Calendar.getInstance();
 			sourceHeader.timestampMicroseconds = (int) (((c.getTimeInMillis() % ((long) 1000)) * ((long) 1000)));
 			sourceHeader.timestampSeconds = (int) (((c.getTimeInMillis()) / ((long) 1000)));
 			sourceHeader.totalLength = IMAGE.HEADER_SIZE + frameHeader.appendedFrameSize;
 
 			// create, generate and set video frame buffer
 
 			byte[] buf = new byte[frameHeader.appendedFrameSize];
 
 			// imperformant, but easy solution:
 			for (int i = 0; i < frameHeader.sourceWidth * frameHeader.sourceHeight;)
 				buf[i++] = (byte) (Math.random() * 256.0); // grayscale noise
 
 			destImage.setImageFrameBuffer(buf);
 		}
 	}
 
 	/**
 	 * Calculates zoomed image dimension.
 	 * 
 	 * @param srcW
 	 *            - source image width
 	 * @param srcH
 	 *            - source image height
 	 * @param destW
 	 *            - destination image width
 	 * @param destH
 	 *            - destination image height
 	 * @return zoomed image dimension
 	 */
 	private Dimension getZoomedSize(int srcW, int srcH, int destW, int destH) {
 		switch (_imageZoom) {
 		case AUTO:
 			return new Dimension(destW, destH);
 
 		case HALF:
 			return new Dimension(srcW / 2, srcH / 2);
 
 		case NORMAL:
 			return new Dimension(srcW, srcH);
 
 		case DOUBLE:
 			return new Dimension(srcW * 2, srcH * 2);
 
 		default:
 			throw new IllegalStateException("unsupported image zoom: " + _imageZoom);
 		}
 	}
 
 	/**
 	 * Calculates destination image dimension.
 	 * 
 	 * @param srcW
 	 *            - source image width
 	 * @param srcH
 	 *            - source image height
 	 * @param destW
 	 *            - destination image width
 	 * @param destH
 	 *            - destination image height
 	 * @return calculated destination image dimension
 	 */
 	private Dimension getKeepedRatioSize(int srcW, int srcH, int destW, int destH) {
 		float ratio = (float) srcW / (float) srcH;
 		if (destW > destH) {
 			int tmp = Math.round(ratio * destH);
 			if (tmp > destW)
 				return new Dimension(destW, Math.round(destW / ratio));
 			return new Dimension(tmp, destH);
 		}
 		return new Dimension(destW, Math.round(destW / ratio));
 	}
 
 	/**
 	 * Drawing of image as well as full overlay information inside the video
 	 * canvas. Takes into account AOI zooming and aspect ratio keeping. Reads
 	 * out video buffer for "value under cursor" function.
 	 * 
 	 * @author mdavid
 	 * @param g2d
 	 *            - Graphics context
 	 * @param image
 	 *            - Image to draw context
 	 * @param size
 	 *            - Frame size
 	 */
 	private void drawFrame(Graphics2D g2d, BufferedImage srcImage) {
 
 		int srcW = srcImage.getWidth();
 		int srcH = srcImage.getHeight();
 		int winW = getWidth();
 		int winH = getHeight();
 
 		Dimension destDim = (ImageZoom.AUTO.equals(_imageZoom) && _keepAspectRatio) ? getKeepedRatioSize(srcW, srcH,
 				winW, winH) : getZoomedSize(srcW, srcH, winW, winH);
 		Point destPoint = new Point((winW - destDim.width) / 2, (winH - destDim.height) / 2);
 
 		g2d.drawImage(srcImage, destPoint.x, destPoint.y, destDim.width, destDim.height, null);
 
 		g2d.setColor(Color.gray);
 		g2d.drawRect(destPoint.x - 1, destPoint.y - 1, destDim.width + 2, destDim.height + 2);
 
 		int xStart = (Integer) srcImage.getProperty(TImageMetadata.KEY_XSTART);
 		int yStart = (Integer) srcImage.getProperty(TImageMetadata.KEY_YSTART);
 		int aoiW = (Integer) srcImage.getProperty(TImageMetadata.KEY_AOI_WIDTH);
 		int aoiH = (Integer) srcImage.getProperty(TImageMetadata.KEY_AOI_HEIGHT);
 
 		String cameraPortName = (String) srcImage.getProperty(TImageMetadata.KEY_CAMERA_PORT_NAME);
 		long frameNumber = (Long) srcImage.getProperty(TImageMetadata.KEY_FRAME_NUMBER);
 		int bits = (Integer) srcImage.getProperty(TImageMetadata.KEY_EFFECTIVE_BITS_PER_PIXEL);
 		int bpp = (Integer) srcImage.getProperty(TImageMetadata.KEY_BYTES_PER_PIXEL);
 		int srcFormat = (Integer) srcImage.getProperty(TImageMetadata.KEY_SOURCE_FORMAT);
 		int imgFormat = (Integer) srcImage.getProperty(TImageMetadata.KEY_IMAGE_FORMAT);
 		int imgFlags = (Integer) srcImage.getProperty(TImageMetadata.KEY_IMAGE_FLAGS);
 		float imgRotation = (Float) srcImage.getProperty(TImageMetadata.KEY_IMAGE_ROTATION);
 		int timestampSeconds = (Integer) srcImage.getProperty(TImageMetadata.KEY_TIMESTAMP_SECONDS);
 		int timestampMicroseconds = (Integer) srcImage.getProperty(TImageMetadata.KEY_TIMESTAMP_MICROSECONDS);
 
 		if (cameraPortName == null || INVALID_CAMERA_PORT_NAME.equals(cameraPortName))
 			drawErrorString(g2d, frameNumber, winW, winH);
 
 		boolean isAoi = (aoiW != UNDEFINED_CONDITION);
 
 		// draw overlay information
 		if (OverlayState.ON.equals(_overlayState) || (_isMouseInCanvas && OverlayState.AUTO.equals(_overlayState))) {
 			StringBuilder sb = new StringBuilder();
 			if (_isMousePressed) {
 				// Rectangle destRect;
 				// if (isAoi) // AOI is present
 				// destRect = new Rectangle(destPoint.x + xStart, destPoint.y +
 				// yStart, aoiW, aoiH);
 				// else
 				// destRect = new Rectangle(destPoint.x, destPoint.y,
 				// destDim.width, destDim.height);
 
 				Rectangle destRect = new Rectangle(destPoint.x, destPoint.y, destDim.width, destDim.height);
 
 				Point p = getMousePosition();
 				if (p != null && destRect.contains(p)) {
 					double scaleX = 1D * srcW / destRect.width;
 					double scaleY = 1D * srcH / destRect.height;
 					int pX = (int) (scaleX * (p.x - destRect.x));
 					int pY = (int) (scaleY * (p.y - destRect.y));
 					int rgb = ((BufferedImage) _image).getRGB(pX, pY);
 					sb.append(" px(").append(pX).append(",").append(pY).append(") = ");
 					sb.append("(").append((rgb >> 16) & 0xff);
 					sb.append("/").append((rgb >> 8) & 0xff);
 					sb.append("/").append(rgb & 0xff).append(")");
 				} else
 					sb.append(" (out of dimension)");
 			}
 
 			final int ovH = 36;
 			final int insetX = 10;
 			final int insetY = 15;
 
 			Rectangle r = getVisibleRect();
 
 			// Composite orgComposite = g2d.getComposite();
 			g2d.setColor(Color.lightGray);
 			g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.85F));
 			g2d.fillRect(r.x, r.y, r.width, ovH);
 			g2d.fillRect(r.x, r.y + r.height - ovH, r.width, ovH);
 			// g2d.setComposite(orgComposite);
 			g2d.setColor(Color.black);
 
 			FontMetrics fm = g2d.getFontMetrics();
 
 			String leftStr = "Source: " + cameraPortName + " (" + ImageFormat.valueOf(srcFormat) + ")";
 			String rightStr = "# " + frameNumber + " - "
 					+ formatDate(new Date((timestampSeconds * 1000L) + (timestampMicroseconds / 1000L)));
 
 			int strW = fm.stringWidth(leftStr) + insetX;
 			drawOverlayStr(leftStr, g2d, fm, r.x, r.y + insetY, r.x + r.width, ovH, false);
 			drawOverlayStr(rightStr, g2d, fm, r.x + strW, r.y + insetY, r.x + r.width, ovH, true);
 
 			leftStr = "Size: " + srcW + " px * " + srcH + " px * " + bits + " of " + bpp * 8 + " bpp ";
 			if (isAoi)
 				leftStr += "(AOI: L " + xStart + ", T " + yStart + ", W " + aoiW + ", H " + aoiH + ")";
 			else
 				leftStr += "(AOI: none)";
 
 			rightStr = "Drop: " + _imageCounter.getDroppedFrames() // 
 					+ " (" + String.format("%4.3f", _imageCounter.getDroppedPercent() * 100D) + "%)";
 
 			strW = fm.stringWidth(leftStr) + insetX;
 			drawOverlayStr(leftStr, g2d, fm, r.x, r.y + 2 * insetY, r.x + r.width, ovH, false);
 			drawOverlayStr(rightStr, g2d, fm, r.x + strW, r.y + 2 * insetY, r.x + r.width, ovH, true);
 
 			leftStr = "Format: " + ImageFormat.valueOf(imgFormat) + sb.toString();
 			strW = fm.stringWidth(leftStr) + insetX;
 			drawOverlayStr(leftStr, g2d, fm, r.x, r.y + r.height - ovH + insetY, r.x + r.width, ovH, false);
 
 			rightStr = "Rotation: " + String.format("%4.2f", Math.abs(imgRotation)) + "°";
 			if (imgRotation > 0F)
 				rightStr += " cw";
 			else if (imgRotation < 0F)
 				rightStr += " ccw";
 
 			leftStr = "Flags: " + ImageFlag.toString(imgFlags);
 			strW = fm.stringWidth(leftStr) + insetX;
 
 			drawOverlayStr(leftStr, g2d, fm, r.x, r.y + r.height - ovH + 2 * insetY, r.x + r.width, ovH, false);
 			drawOverlayStr(rightStr, g2d, fm, r.x + strW, r.y + r.height - ovH + 2 * insetY, r.x + r.width, ovH, true);
 		}
 	}
 
 	private void drawErrorString(Graphics2D g2d, long frameNumber, int w, int h) {
 
 		String s1 = "Error: Video Frame #" + frameNumber + " could not be decoded or displayed properly.";
 
 		Font orgFont = g2d.getFont();
 		g2d.setFont(orgFont.deriveFont(Font.BOLD, (float) 12.0));
 
 		int fontH = g2d.getFontMetrics().getHeight();
 		int maxH = fontH + 20;
 
 		int s1w = g2d.getFontMetrics().stringWidth(s1);
 		int maxW = s1w + 40;
 
 		int y = (h - maxH) / 2;
 
 		g2d.setColor(Color.black);
 		g2d.fillRect((w - maxW) / 2, y, maxW, maxH);
 
 		g2d.setColor(Color.red);
 		g2d.drawString(s1, (w - s1w) / 2, y + 20);
 
 		g2d.setFont(orgFont);
 	}
 
 	/**
 	 * @author mdavid
 	 */
 	private void drawOverlayStr(String str, //
 			Graphics2D g2d, //
 			FontMetrics fm, //
 			int x, //
 			int y, //
 			int width, //
 			int height, //
 			boolean isRight) {
 
 		if (str == null || str.length() == 0)
 			return;
 
 		int insetX = 10;
 
 		int area = width - x;
 		int stringWidth = fm.stringWidth(str) + insetX;
 
 		if (stringWidth + insetX > area) {
 			String suffix = "...";
 			int suffixWidth = fm.stringWidth(suffix) + insetX;
 			stringWidth = suffixWidth + insetX;
 
 			StringBuilder sb = new StringBuilder();
 			for (int i = 0; i < str.length(); i++) {
 				if (stringWidth >= area)
 					break;
 				sb.append(str.charAt(i));
 				stringWidth = insetX + fm.stringWidth(sb.toString()) + suffixWidth;
 			}
 			g2d.drawString(sb.append(suffix).toString(), x + insetX, y);
 
 		} else
 			g2d.drawString(str, (isRight ? width - stringWidth : x + insetX), y);
 	}
 
 	/**
 	 * redraws the current image. A meaningful display buffer is created or
 	 * reused. In case of error, the error image is passed along. This display
 	 * buffer is rendered. <br>
 	 */
 	private void createBufferedImage() {
 		// long t = System.currentTimeMillis();
 		try {
 			// for (int i = 0; i < 10; i++) { // TODO
 			_image = TBufferedImage.toBufferedImage(_timage, _clut.getColorMap(), _histogramEqualisation,
 					_histogramMin, _histogramMax, !_aoiZoom);
 			// }
 
 			// int type = _image.getType();
 			// if (type == BufferedImage.TYPE_BYTE_GRAY //
 			// || type == BufferedImage.TYPE_USHORT_GRAY //
 			// || type == BufferedImage.TYPE_BYTE_INDEXED //
 			// || (type == BufferedImage.TYPE_CUSTOM &&
 			// _image.getData().getNumBands() == 1)) { //
 			//
 			// setCLUT(new TLookUpTable(_timage.getFrameHeader().bytesPerPixel,
 			// _timage.getFrameHeader().effectiveBitsPerPixel,
 			// ColorMap.GRAYSCALE));
 			//
 			// } else {
 			// // setCLUT(new TLookUpTable(0, 0, null));
 			// }
 
 		} catch (Exception e) {
 			_image = TBufferedImage.toBufferedImage(_timage = getErrorScreen());
 			getExceptionListener().exceptionThrown(e);
 		}
 		// System.out.println("CREATED: " + (System.currentTimeMillis() - t));
 
 		repaint();
 	}
 
 	/**
 	 * Reduces number of renders in run-mode
 	 */
 	private void repaintImage() {
 		if (_isLiveTransfer) {
 			if (_timer == null) { // Set up timer to drive animation events.
 				_timer = new Timer(TIMER_DELAY, new ActionListener() {
 					public void actionPerformed(ActionEvent evt) {
 						repaint();
 					}
 				});
 				_timer.start();
 			} else
 				_timer.restart();
 		} else
 			repaint();
 	}
 
 	/**
 	 * @author mdavid
 	 * @param date
 	 *            - Date to formatted
 	 * @return date in full format if date is not today
 	 */
 	private String formatDate(Date date) {
 		java.util.Calendar tmp = java.util.Calendar.getInstance();
 		int day = tmp.get(java.util.Calendar.DAY_OF_YEAR);
 		int year = tmp.get(java.util.Calendar.YEAR);
 		tmp.setTime(date);
 		boolean isSameDate = (day == tmp.get(Calendar.DAY_OF_YEAR) && year == tmp.get(Calendar.YEAR));
 		return new SimpleDateFormat(isSameDate ? "HH:mm:ss.SSS" : "dd.MM.yy HH:mm:ss.SSS").format(date);
 	}
 
 	/**
 	 * Create error screen (TINE IMAGE type) by calling appropriate helper
 	 * method
 	 * 
 	 * @return IMAGE - Error screen image
 	 */
 	private IMAGE getErrorScreen() {
 		if (_errorScreen == null) {
 			_errorScreen = new IMAGE(0);
 			createErrorScreen(_errorScreen);
 		}
 		return _errorScreen;
 	}
 
 	/**
 	 * Sets an exception listener for this ImageDisplayer.
 	 * 
 	 * @param exceptionListener
 	 *            - the exception listener
 	 */
 	public void setExceptionListener(ExceptionListener exceptionListener) {
 		this._exceptionListener = exceptionListener;
 	}
 
 	/**
 	 * Gets the ExceptionListener object for this ImageDisplayer.
 	 * 
 	 * @return the ExceptionListener for this ImageDisplayer
 	 */
 	public ExceptionListener getExceptionListener() {
 		return (_exceptionListener != null) ? _exceptionListener : defaultExceptionListener;
 	}
 
 	/**
 	 * The default ExceptionListener is the default implementation of the
 	 * ExceptionListener interface. An instance of this class is used whenever
 	 * the user provided no ExceptionListener instance on its own.
 	 */
 	private static final ExceptionListener defaultExceptionListener = new ExceptionListener() {
 		public void exceptionThrown(Exception e) {
 			System.err.println(e);
 		}
 	};
 }