package de.desy.video.sw;
   
   //big memory for testing:
   //-Xms512m -Xmx512m -XX:PermSize=128m -XX:MaxPermSize=128m
   
   import java.awt.AlphaComposite;
   import java.awt.BorderLayout;
   import java.awt.Canvas;
   import java.awt.Color;
  import java.awt.Composite;
  import java.awt.Container;
  import java.awt.Dimension;
  import java.awt.Font;
  import java.awt.FontMetrics;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.HeadlessException;
  import java.awt.Image;
  import java.awt.MediaTracker;
  import java.awt.Point;
  import java.awt.Toolkit;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.awt.event.MouseMotionAdapter;
  import java.awt.event.MouseMotionListener;
  import java.awt.event.MouseWheelListener;
  import java.awt.image.BufferedImage;
  import java.awt.image.MemoryImageSource;
  import java.text.DateFormat;
  import java.text.SimpleDateFormat;
  
  import javax.swing.SwingUtilities;
  
  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 colour
   * mode(s), normalisation
   * <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>easeness, intuitiveness of use (keep aspect ratio, overlaying of image
   * metadata, 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 standalone application.
   * 
   * @author <a href="mailto:stefan.weisse@desy.de">Stefan Weisse</a>
   * @version $Id: Templates.xml,v 1.10 2008/06/23 14:30:13 sweisse Exp $
   * 
   */
  
  public final class ImageDisplayer extends Container {
  
  	/** enum for color mapping assignment */
  	public enum ColorMap {
  		GRAYSCALE, PITZ, JET;
  
  		@Override
  		public String toString() {
  			switch (this) {
  			case GRAYSCALE:
  				return "Grayscale";
  			case PITZ:
  				return "PITZ False Color";
  			case JET:
  				return "JET False Color";
  			}
  			return super.toString();
  		}
  	}
  
  	/**
  	 * Enum for overlay information
  	 * 
  	 * @author mdavid
  	 */
  	public enum OverlayState {
  		/**
  		 * overlay information always enabled.
  		 */
  		ON("On"),
  
  		/**
  		 * overlay information always disabled.
  		 */
  		OFF("Off"),
  
 		/**
 		 * overlay information appears when moving over video frame.
 		 */
 		AUTO("Auto");
 
 		private final String description;
 
 		OverlayState(String description) {
 			this.description = description;
 		}
 
 		public String getDescription() {
 			return description;
 		}
 	}
 
 	private static final long serialVersionUID = 310376L;
 
 	/**
 	 * minimal width of video canvas. This is not taken into account inside the
 	 * ACOP bean.
 	 */
 	private static final int MIN_X = 592;
 
 	/**
 	 * minimal height of video canvas. This is not taken into account inside the
 	 * ACOP bean.
 	 */
 	private static final int MIN_Y = 211; // 127 + 2x42 OSD;
 
 	/** Timeout period. See 'reenableAlwaysUpdateVideoCanvas' */
 	private static final long TIMEOUT = 1000;
 
 	/** Flipping Buffer strategy for (fast) Java drawing */
 	private java.awt.image.BufferStrategy flipStrategy;
 
 	/** is Flipping Buffer strategy for (fast) Java drawing already created? */
 	private boolean isBufferStrategyCreated;
 
 	/** underlying drawing canvas */
 	private Canvas videoCanvas;
 
 	/** dedicated synchronization (thread lock) object */
 	private Object lockHeaderUpdate = new Object();
 
 	/** is the mouse arrow inside the overlay section of the video canvas? */
 	private boolean isVideoCanvasMouseInOverlay;
 
 	/** is the mouse arrow inside the video canvas? */
 	private boolean isVideoCanvasMouseInCanvas;
 
 	/** is the mouse arrow inside the video canvas and is the left button down? */
 	private boolean isVideoCanvasMouseLeftButtonDown;
 
 	/**
 	 * 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;
 
 	/**
 	 * see description of OverlayState enumarion
 	 * 
 	 * @author mdavid
 	 */
 	private OverlayState overlayState;
 
 	/**
 	 * 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 isAOIZoom;
 
 	/**
 	 * 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 isKeepAspectRatioEnabled;
 
 	/**
 	 * set to true if histogram equalisation (aka. normalisation, 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. Colour histogram equalisation is numerically well but is
 	 * outperformed by professional algorithms. This might be improved in
 	 * future. Same but weaker effect is known for luminosity (greyscale)
 	 * normalisation.
 	 */
 	private boolean isHistogramEqualisation; // was: Normalisation
 
 	/**
 	 * false-colour switching can be disabled because if colour video is
 	 * displayed there is no meaningful false color translation so switching is
 	 * meaningless.
 	 */
 	private boolean falseColorSwitchingAllowed = true;
 
 	/** currently used color map, default is grayscale */
 	private ColorMap colorMap = ColorMap.GRAYSCALE;
 
 	/** matching colour mode for colour map */
 	private int colorMode = CColorLookupTable.GRAYSCALE;
 
 	/** has the false colour table to be updated before next image is shown? */
 	private boolean isDoUpdateColorLookupTable = true;
 
 	/**
 	 * memory buffer for TYPE_INT_ARGB data before rendered to java.awt.Image
 	 * and displayed
 	 */
 	private int[] displayImageBuffer; // = new int[hdr.width*hdr.height];
 
 	/**
 	 * memory buffer for current false-colour index to TYPE_INT_ARGB conversion
 	 * table
 	 */
 	private int[] colorLookupTableArray; // mapping from
 
 	/** class instance for 'colorLookupTableArray' creation and updating */
 	private CColorLookupTable colorLookupTable;
 
 	/**
 	 * 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;
 
 	/**
 	 * last received frame number. This value is updated if a video image is
 	 * scheduled for displaying. It is reset to -1 on startup of live transfer.
 	 */
 	private long lastFrameNumber = -1;
 
 	/**
 	 * total dropped frames counter. This value is updated if a video image is
 	 * scheduled for displaying. It is reset to zero on startup of live
 	 * transfer.
 	 */
 	private long droppedFrames = 0;
 
 	/**
 	 * total subsequent received frames counter. This value is updated if a
 	 * video image is scheduled for displaying. It is reset to zero on startup
 	 * of live transfer.
 	 */
 	private long receivedFrames = 0;
 
 	/**
 	 * ratio (percentage) of dropped vs. total number of received frames. This
 	 * value is updated if a video images is scheduled for displaying. It is
 	 * reset to "-0.001" (about zero, identified as unset) on startup of live
 	 * transfer.
 	 */
 	private double ratio = -0.001;
 
 	/**
 	 * java.awt.Image instance buffer for rendered video image contents ready
 	 * for drawing
 	 */
 	private Image image; // @jve:decl-index=0:
 
 	/**
 	 * java.awt.MemoryImageSource marshals 'displayImageBuffer' for faster
 	 * updating of 'image'
 	 */
 	private MemoryImageSource memoryImageSource; // @jve:decl-index=0:
 
 	/**
 	 * extracted but frozen video header out of current "about-to-be" displayed
 	 * frame. Values will not changed if header data is preprocessed (and thus,
 	 * changed) during image prepare inside this class.
 	 */
 	private CVideoHeader3 constHeader;
 
 	/**
 	 * 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 CVideoHeader3 changeHeader;
 
 	/**
 	 * Timeout counter for setting up the GUI for any redrawing (imperformant)
 	 * if for 'TIMEOUT' milliseconds no new video image was received.
 	 */
 	private long reenableAlwaysUpdateVideoCanvas = java.lang.System
 			.currentTimeMillis();
 
 	/**
 	 * default constructor. Initialises parent class and calls initialize()
 	 * method for local initialisation.
 	 */
 	public ImageDisplayer() {
 		super();
 		initialize();
 	}
 
 	@Override
 	/** overridden general mouse listener. */
 	public synchronized void addMouseListener(MouseListener l) {
 		super.addMouseListener(l);
 		videoCanvas.addMouseListener(l);
 	}
 
 	@Override
 	/** overridden mouse motion listener. */
 	public synchronized void addMouseMotionListener(MouseMotionListener l) {
 		super.addMouseMotionListener(l);
 		videoCanvas.addMouseMotionListener(l);
 	}
 
 	@Override
 	/** overridden mouse wheel listener. */
 	public synchronized void addMouseWheelListener(MouseWheelListener l) {
 		super.addMouseWheelListener(l);
 		videoCanvas.addMouseWheelListener(l);
 	}
 
 	/**
 	 * updates the currently used false colour map. Get/Set. This method will do
 	 * nothing if the new map equals the current map for performance reasons.
 	 * After new assignment, drawing is enforced to update all involved parts of
 	 * code that work with or reference false colours.
 	 * 
 	 * @param map
 	 *            new false colour map to use
 	 */
 	public void setColorMap(ColorMap map) {
 		if (this.colorMap == map)
 			return;
 
 		ColorMap oldMap = this.colorMap;
 		this.colorMap = map;
 
 		// mdavid: optimized
 		switch (colorMap) {
 		case GRAYSCALE:
 			colorMode = CColorLookupTable.GRAYSCALE;
 			break;
 
 		case PITZ:
 			colorMode = CColorLookupTable.FALSEPITZ;
 			break;
 
 		case JET:
 			colorMode = CColorLookupTable.FALSEJET;
 			break;
 
 		default:
 			throw new IllegalArgumentException("Unsupported color map: " + map);
 		}
 
 		isDoUpdateColorLookupTable = true;
 		firePropertyChange("colorMap", oldMap, this.colorMap);
 
 		drawAndUpdate(false);
 		repaintAnything();
 	}
 
 	/**
 	 * returns the currently used false colour map to outside world. Get/Set.
 	 * 
 	 * @return currently used false colour map
 	 */
 	public ColorMap getColorMap() {
 		return colorMap;
 	}
 
 	/**
 	 * @author mdavid
 	 * @param overlay
 	 *            set overlay mode always on (true) or off(false)
 	 */
 	public void setOverlayState(OverlayState state) {
 		OverlayState oldState = overlayState;
 		overlayState = state;
 		firePropertyChange("overlayState", oldState, overlayState);
 		repaintAnything(); // TODO: mdavid - why here ??
 	}
 
 	/**
 	 * Returns overlay information state.
 	 * 
 	 * @author mdavid
 	 */
 	public OverlayState getOverlayState() {
 		return overlayState;
 	}
 
 	/**
 	 * Switches 'histogram equalisation' on or off. Get/Set. This method will do
 	 * nothing if the histogram equalisation mode is already in the state about
 	 * to be set. After new assignment, drawing as well as repainting is
 	 * enforced to update all involved parts of code so that histogram
 	 * equalisation is immediately applied to image.
 	 * 
 	 * @param switch
 	 *            histogram equalisation on (true) or off (false)
 	 */
 	public void setHistogramEqualisationEnabled(boolean normalisation) {
 		if (this.isHistogramEqualisation == normalisation)
 			return;
 		this.isHistogramEqualisation = normalisation;
 		firePropertyChange("histogramEqualisation", !isHistogramEqualisation,
 				isHistogramEqualisation);
 
 		drawAndUpdate(false);
 		repaintAnything();
 	}
 
 	/**
 	 * returns whether histogram equalisation (normalisation) is currently
 	 * enabled. Get/Set.
 	 * 
 	 * @return true - histogram equalisation is switched on<br>
 	 *         false - histogram equalisation is switched off
 	 */
 	public boolean isHistogramEqualisationEnabled() {
 		return isHistogramEqualisation;
 	}
 
 	/**
 	 * Switches 'AOI zoom' on or off. Get/Set. 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 zoom
 	 *            enable (true) or disable (false) AOI zooming
 	 */
 	public void setAOIZoom(boolean zoom) {
 		if (isAOIZoom == zoom)
 			return;
 		this.isAOIZoom = zoom;
 
 		firePropertyChange("AOIZoom", !isAOIZoom, isAOIZoom);
 		repaintAnything();
 	}
 
 	/**
 	 * returns whether outzooming of AOI (no black border around AOI which
 	 * depicts full frame) is currently enabled. Get/Set.
 	 * 
 	 * @return true - AOI Zoom is switched on<br>
 	 *         false - AOI Zoom is switched off
 	 */
 	public boolean isAOIZoom() {
 		return isAOIZoom;
 	}
 
 	/**
 	 * Switches 'aspect ratio is kept' on or off. Get/Set. 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 keep
 	 *            enable (true) or disable (false) keeping of aspect ratio
 	 */
 	public void setKeepAspectRatioEnabled(boolean keep) {
 		if (this.isKeepAspectRatioEnabled == keep)
 			return;
 		this.isKeepAspectRatioEnabled = keep;
 
 		firePropertyChange("keepAspectRatioEnabled", !isKeepAspectRatioEnabled,
 				isKeepAspectRatioEnabled);
 		repaintAnything();
 	}
 
 	/**
 	 * returns whether 'aspect ratio is kept' is currently enabled. Get/Set.
 	 * 
 	 * @return true - 'aspect ratio is kept' is switched on<br>
 	 *         false - 'aspect ratio is kept' is switched off
 	 */
 	public boolean isKeepAspectRatioEnabled() {
 		return isKeepAspectRatioEnabled;
 	}
 
 	/**
 	 * saves the currently displayed image as colour (RGB) png file. An
 	 * additional text file is saved beside the png file that describes full
 	 * image metainformation (VSv3 header contents).
 	 * 
 	 * @param fileNamePath
 	 *            Filename of PNG file with extension, may include path
 	 * @return boolean indicating success (true) or failure (false)
 	 */
 	public boolean saveAsPNGImage(String fileNamePath) {
 		boolean ret;
 
 		repaintAnything();
 
 		synchronized (lockHeaderUpdate) {
 			ret = CBasicPNGWriterV3.write(fileNamePath, image, changeHeader);
 		}
 
 		repaintAnything();
 
 		return ret;
 	}
 
 	/**
 	 * Switches 'false colour switching meaningfulness' on or off. Get/Set. This
 	 * method will do nothing if the meaningfulness of false colour switching is
 	 * already in the state about to be set. Repainting is enforced to have an
 	 * immediate update.
 	 * 
 	 * The variable behind this get/set was invented to have an indication
 	 * whether false colour switching is meaningful (false colour data) or not
 	 * meaningful (colour data). For colour data no proper transformation to
 	 * false colour is provided (usually it is not necessary simply) so false
 	 * colour switching would be logically meaningless.
 	 * 
 	 * @param enabled
 	 *            <ul>
 	 *            <li>true false colour switching is meaningful (allowed)
 	 *            <li>false switching of false colour is not meaningful
 	 *            (allowed)
 	 *            </ul>
 	 */
 	public void setFalseColorSwitchingAllowed(boolean enabled) {
 		if (this.falseColorSwitchingAllowed == enabled)
 			return;
 		this.falseColorSwitchingAllowed = enabled;
 
 		firePropertyChange("falseColorSwitchingAllowed",
 				!falseColorSwitchingAllowed, falseColorSwitchingAllowed);
 		repaintAnything();
 	}
 
 	/**
 	 * returns whether false colour switching is currently meaningful. Get/Set.
 	 * 
 	 * @return true - false colour switching is meaningful (allowed)<br>
 	 *         false - false colour switching is not meaningful (allowed)
 	 */
 	public boolean isFalseColorSwitchingAllowed() {
 		return falseColorSwitchingAllowed;
 	}
 
 	/**
 	 * 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 offload 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() {
 		image = null;
 		memoryImageSource = null;
 		displayImageBuffer = null;
 		colorLookupTableArray = null;
 		isDoUpdateColorLookupTable = true;
 		lastFrameNumber = -1;
 		droppedFrames = 0;
 		receivedFrames = 0;
 		ratio = -0.001;
 	}
 
 	/**
 	 * passes/injects a new image into image processing, drawing and redrawing
 	 * pipeline.
 	 * 
 	 * Uses thread locking for proper synchronisation. Drawing and Displaying is
 	 * done inside invoked Swing thread.
 	 * 
 	 * @param aHdr
 	 *            new video frame (marshalled into CVideoHeader3 instance)
 	 */
 	public void updateValue(CVideoHeader3 aHdr) {
 		synchronized (lockHeaderUpdate) {
 			constHeader = cloneVideoFrame(aHdr, false);
 			// TODO this is safe, but slow
 			changeHeader = cloneVideoFrame(aHdr, true);
 			calculateDroppedFrames();
 			uncompressIfNecessary();
 		}
 
 		Runnable r = new Runnable() {
 			public void run() {
 				drawAndUpdate(true);
 			}
 		};
 
 		if (SwingUtilities.isEventDispatchThread()) {
 			r.run();
 		} else {
 			SwingUtilities.invokeLater(r);
 		}
 	}
 
 	// ///////////////////////////////////////////////////////////////////////////
 	//
 	// 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() {
 
 		// initialisation of basic component and subcomponent canvas
 		this.setSize(559, 387);
 		this.setMinimumSize(new Dimension(MIN_X, MIN_Y));
 		this.setLayout(new BorderLayout());
 
 		videoCanvas = new Canvas();
 		videoCanvas.setBackground(Color.darkGray);
 		videoCanvas.setBounds(5, 5, 200, 200);
 		videoCanvas.setIgnoreRepaint(true);
 
 		// set defined (valid) start-up settings
 		isLiveTransfer = false;
 		isDoUpdateColorLookupTable = true;
 		overlayState = OverlayState.AUTO;
 
 		isVideoCanvasMouseInOverlay = false;
 		isVideoCanvasMouseInCanvas = false;
 		isVideoCanvasMouseLeftButtonDown = false;
 		isAOIZoom = false;
 		isHistogramEqualisation = false;
 
 		// create mouse listeners for exiting, entering of canvas and left mouse
 		// button
 		// handling
 		videoCanvas.addMouseListener(new MouseAdapter() {
 			public void mouseExited(MouseEvent e) {
 				boolean old = isVideoCanvasMouseInOverlay;
 				isVideoCanvasMouseInOverlay = false;
 				isVideoCanvasMouseInCanvas = false;
 
 				// DEBUG SW!
 				// System.out.println("Mouse exited.");
 
 				if (old)
 					repaintAnything();
 			}
 
 			public void mouseEntered(MouseEvent e) {
 				boolean old = isVideoCanvasMouseInOverlay;
 				isVideoCanvasMouseInCanvas = true;
 
 				// DEBUG SW!
 				// System.out.println("Mouse entered.");
 
 				if (old)
 					repaintAnything();
 			}
 
 			public void mousePressed(MouseEvent e) {
 				// if (e.getModifiers() == MouseEvent.BUTTON1_DOWN_MASK)
 				isVideoCanvasMouseLeftButtonDown = true;
 
 				// DEBUG SW!
 				// System.out.println("Mouse down.");
 
 			}
 
 			public void mouseReleased(MouseEvent e) {
 				// if (e.getModifiers() == MouseEvent.BUTTON1_DOWN_MASK)
 				isVideoCanvasMouseLeftButtonDown = false;
 
 				// DEBUG SW!
 				// System.out.println("Mouse up.");
 			}
 
 		});
 
 		// creates mouse motion listener subclass for proper mouse move
 		// events inside the image drawing canvas if left mouse button is
 		// pressed
 		videoCanvas.addMouseMotionListener(new MouseMotionAdapter() {
 			public void mouseDragged(MouseEvent e) {
 				// so that the event is also transferred down in case
 				// of mouse button clicks
 				onMouseMoveInCanvas(e);
 			}
 
 			public void mouseMoved(MouseEvent e) {
 				onMouseMoveInCanvas(e);
 			}
 		});
 
 		// create a component listener for flexible drawing
 		this.addComponentListener(new ComponentAdapter() {
 			public void componentResized(ComponentEvent ce) {
 				repaintAnything();
 			}
 
 			public void componentMoved(ComponentEvent ce) {
 				repaintAnything();
 			}
 
 			public void componentShown(ComponentEvent ce) {
 				repaintAnything();
 			}
 		});
 
 		// create instance of color lookup table
 		colorLookupTable = new CColorLookupTable();
 
 		// create splash screen (java TINE IMAGE type) by calling appropriate
 		// helper method
 		IMAGE splashScreen = new IMAGE();
 		createSplashScreen(splashScreen);
 
 		// create error screen (java TINE IMAGE type) by calling appropriate
 		// helper method
 		errorScreen = new IMAGE();
 		createErrorScreen(errorScreen);
 
 		// finally, add the canvas to the center of the component
 		this.add(videoCanvas, BorderLayout.CENTER);
 
 		// set the splashScreen as current image to be (re-)drawn
 		updateValue(new CVideoHeader3(splashScreen));
 	}
 
 	/**
 	 * 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 aSplashScreen
 	 *            reference to the IMAGE instance that will store the splash
 	 *            screen
 	 */
 	private void createSplashScreen(IMAGE aSplashScreen) {
 		if (CIMMLoader.loadImageFile("splash.imm", aSplashScreen) == false) {
 
 			if (CBasicImageLoaderV3.loadImageFile("splash.png", aSplashScreen) == false) {
 
 				// obtain references:
 				IMAGE.FrameHeader frameHeader = aSplashScreen.getFrameHeader();
 				IMAGE.SourceHeader sourceHeader = aSplashScreen
 						.getSourceHeader();
 
 				// set data of frameHeader
 				frameHeader.aoiHeight = -1;
 				frameHeader.aoiWidth = -1;
 				frameHeader.bytesPerPixel = 1;
 				frameHeader.appendedFrameSize = 768 * 576 * frameHeader.bytesPerPixel;
 				frameHeader.effectiveBitsPerPixel = 8;
 				frameHeader.eventNumber = 0;
 				frameHeader.frameNumber = 0;
 				frameHeader.fspare1 = (float) -1.0;
 				frameHeader.fspare2 = (float) -1.0;
 				frameHeader.fspare3 = (float) -1.0;
 				frameHeader.horizontalBinning = 0;
 				frameHeader.imageFlags = (int) CVideoHeader3.CF_IMAGE_FLAG_IMAGE_LOSSLESS
 						| (int) CVideoHeader3.CF_IMAGE_FLAG_LITTLE_ENDIAN_BYTE_ORDER;
 				frameHeader.imageFormat = (int) CVideoHeader3.CF_IMAGE_FORMAT_GRAY;
 				frameHeader.imageRotation = (float) 0.0;
 				frameHeader.ispare1 = -1;
 				frameHeader.ispare2 = -1;
 				frameHeader.ispare3 = -1;
 				frameHeader.sourceFormat = (int) CVideoHeader3.CF_IMAGE_FORMAT_GRAY;
 				frameHeader.sourceHeight = 576;
 				frameHeader.sourceWidth = 768;
 				frameHeader.verticalBinning = 0;
 				frameHeader.xScale = (float) 1.000;
 				frameHeader.xStart = 0;
 				frameHeader.yScale = (float) 1.000;
 				frameHeader.yStart = 0;
 
 				// set data of sourceHeader
 				sourceHeader.baseTag = (int) CVideoHeader3.CF_IMAGE_MAGIC_01;
 				sourceHeader.cameraPortName = "Internal Backup Splashscreen";
 				// SW! Oct 01, 2008
 				sourceHeader.cameraPortId = (int) CVideoHeader3.CF_IMAGE_NO_CAMERA_PORT_ID;
 				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 = CVideoHeader3.HDRSIZE
 						+ frameHeader.appendedFrameSize;
 				sourceHeader.versionTag = CVideoHeader3.CF_IMAGE_VERSION;
 
 				// create, generate and set video frame buffer
 
 				byte[] buf = new byte[frameHeader.appendedFrameSize];
 
 				// imperformant, but easy solution:
 				int pos = 0;
 				for (int i = 0; i < frameHeader.sourceWidth
 						* frameHeader.sourceHeight; i++) {
 					buf[pos++] = (byte) 0;
 				}
 				aSplashScreen.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 analogue
 	 * 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 aErrorScreen
 	 *            reference to the IMAGE instance that will store the error
 	 *            screen in memory
 	 */
 	private void createErrorScreen(IMAGE aErrorScreen) {
 		if (CBasicImageLoaderV3.loadImageFile("error.png", aErrorScreen) == false) {
 
 			// obtain references:
 			IMAGE.FrameHeader frameHeader = aErrorScreen.getFrameHeader();
 			IMAGE.SourceHeader sourceHeader = aErrorScreen.getSourceHeader();
 
 			// set data of frameHeader
 			frameHeader.aoiHeight = -1;
 			frameHeader.aoiWidth = -1;
 			frameHeader.appendedFrameSize = 768 * 576;
 			frameHeader.bytesPerPixel = 1;
 			frameHeader.effectiveBitsPerPixel = 8;
 			frameHeader.eventNumber = 0;
 			frameHeader.frameNumber = 0;
 			frameHeader.fspare1 = (float) -1.0;
 			frameHeader.fspare2 = (float) -1.0;
 			frameHeader.fspare3 = (float) -1.0;
 			frameHeader.horizontalBinning = 0;
 			frameHeader.imageFlags = (int) CVideoHeader3.CF_IMAGE_FLAG_IMAGE_LOSSLESS
 					| (int) CVideoHeader3.CF_IMAGE_FLAG_LITTLE_ENDIAN_BYTE_ORDER;
 			frameHeader.imageFormat = (int) CVideoHeader3.CF_IMAGE_FORMAT_GRAY;
 			frameHeader.imageRotation = (float) 0.0;
 			frameHeader.ispare1 = -1;
 			frameHeader.ispare2 = -1;
 			frameHeader.ispare3 = -1;
 			frameHeader.sourceFormat = (int) CVideoHeader3.CF_IMAGE_FORMAT_GRAY;
 			frameHeader.sourceHeight = 576;
 			frameHeader.sourceWidth = 768;
 			frameHeader.verticalBinning = 0;
 			frameHeader.xScale = (float) 1.000;
 			frameHeader.xStart = 0;
 			frameHeader.yScale = (float) 1.000;
 			frameHeader.yStart = 0;
 
 			// set data of sourceHeader
 			sourceHeader.baseTag = (int) CVideoHeader3.CF_IMAGE_MAGIC_01;
 			sourceHeader.cameraPortName = "Internal Backup Splashscreen";
 			// SW! Oct 01, 2008
 			//sourceHeader.specificTag = (int) CVideoHeader3.CF_IMAGE_MAGIC_02;
 			sourceHeader.cameraPortId = (int) CVideoHeader3.CF_IMAGE_NO_CAMERA_PORT_ID;
 			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 = CVideoHeader3.HDRSIZE
 					+ frameHeader.appendedFrameSize;
 			sourceHeader.versionTag = CVideoHeader3.CF_IMAGE_VERSION;
 
 			// create, generate and set video frame buffer
 
 			byte[] buf = new byte[frameHeader.appendedFrameSize];
 
 			// imperformant, but easy solution:
 			int pos = 0;
 			for (int i = 0; i < frameHeader.sourceWidth
 					* frameHeader.sourceHeight; i++) {
 				buf[pos++] = (byte) (Math.random() * 256.0); // grayscale
 				// noise
 			}
 
 			aErrorScreen.setImageFrameBuffer(buf);
 		}
 	}
 
 	/**
 	 * returns instance of AlphaComposite based on passed float alpha type. This
 	 * is a helper function.
 	 * 
 	 * @param alpha
 	 *            alpha (transparency) value (0 = full transparent,
 	 *            1=intransparent)
 	 * @return parameter als AlphaComposite
 	 */
 	private AlphaComposite makeComposite(float alpha) {
 		int type = AlphaComposite.SRC_OVER;
 		return (AlphaComposite.getInstance(type, alpha));
 	}
 
 	/**
 	 * helper function called by mouse events catched in subclasses. It handles
 	 * the proper setting of variables in order to do overlay drawing on demand
 	 * if mouse arrow is inside proper regions of video canvas. In addition, the
 	 * overlay is especially redrawn if the mouse arrow is inside the video
 	 * canvas and the left mouse button is pressed, so that "value under cursor"
 	 * is properly redrawn.
 	 * 
 	 * @param e
 	 *            MouseEvent about to be analysed
 	 */
 	private void onMouseMoveInCanvas(MouseEvent e) {
 		// int xpos = e.getX();
 
 		int ypos = e.getY();
 
 		boolean old = isVideoCanvasMouseInOverlay;
 
 		if (((ypos > 0) && (ypos < 50))
 				|| ((ypos > videoCanvas.getHeight() - 50) && (ypos < videoCanvas
 						.getHeight())))
 			isVideoCanvasMouseInOverlay = true;
 
 		if (((ypos <= 0) || (ypos >= videoCanvas.getHeight())))
 			isVideoCanvasMouseInOverlay = false;
 
 		isVideoCanvasMouseInCanvas = true;
 
 		if (old != isVideoCanvasMouseInOverlay)
 			repaintAnything();
 
 		// ---------------------------------------------------
 
 		// update if left mouse button if pressed (display of value
 		// under cursor)
 		if (isVideoCanvasMouseLeftButtonDown && isVideoCanvasMouseInCanvas) {
 			// note: high cpu load might be caused!
 			if (isLiveTransfer == false)
 				updateImageCanvas();
 		}
 	}
 
 	/**
 	 * helper function that does real 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. It uses
 	 * synchronize locking object in order that no important variable is
 	 * overwritten while drawing is performed.
 	 * 
 	 */
 	private void updateImageCanvas() {
 
 		if (constHeader == null || image == null || changeHeader == null) {
 			// DEBUG SW!
 			// System.out.println("Display error: one of important values is
 			// null!");
 			return;
 		}
 
 		if (isBufferStrategyCreated == false) {
 			if (isDisplayable()) {
 				videoCanvas.createBufferStrategy(2);
 				flipStrategy = videoCanvas.getBufferStrategy();
 				isBufferStrategyCreated = true;
 			}
 		}
 
 		if (isBufferStrategyCreated == false) {
 			// DEBUG SW!
 			// System.out.println("Buffer Strategy not yet created!");
 			return;
 		}
 
 		synchronized (lockHeaderUpdate) {
 
 			try {
 
 				Graphics g = null;
 				do {
 					// The following loop ensures that the contents of the
 					// drawing
 					// buffer
 					// are consistent in case the underlying surface was
 					// recreated
 
 					// - values used for calculations or as reference for other
 					// values
 					// are taken from the changeHdr
 
 					// - values only used for display are taken from constHdr!
 
 					do {
 						try {
 							g = flipStrategy.getDrawGraphics();
 							Graphics2D g2d = (Graphics2D) g;
 
 							videoCanvas.paint(g);
 
 							java.awt.Rectangle imgR = new java.awt.Rectangle();
 							java.awt.Rectangle srcR = new java.awt.Rectangle();
 							java.awt.Rectangle dstR = new java.awt.Rectangle();
 
 							java.awt.Rectangle dstROrig = new java.awt.Rectangle();
 
 							imgR.x = 0;
 							imgR.y = 0;
 							imgR.width = changeHeader.frameHeader.sourceWidth;
 							imgR.height = changeHeader.frameHeader.sourceHeight;
 
 							srcR.x = changeHeader.frameHeader.xStart;
 							srcR.y = changeHeader.frameHeader.yStart;
 							srcR.width = changeHeader.frameHeader.aoiWidth;
 							srcR.height = changeHeader.frameHeader.aoiHeight;
 							if (srcR.width == -1)
 								srcR.width = imgR.width;
 							if (srcR.height == -1)
 								srcR.height = imgR.height;
 
 							dstROrig.x = 2;
 							dstROrig.y = 2;
 							dstROrig.width = videoCanvas.getWidth() - 4;
 							dstROrig.height = videoCanvas.getHeight() - 4;
 
 							dstR.x = 2;
 							dstR.y = 2;
 							dstR.width = videoCanvas.getWidth() - 4;
 							dstR.height = videoCanvas.getHeight() - 4;
 
 							if (isKeepAspectRatioEnabled) {
 								double whratiovideo = 1.0;
 								if (imgR.height > 0)
 									whratiovideo = ((double) imgR.width)
 											/ ((double) imgR.height);
 
 								for (;;) {
 									dstR.height = (int) Math.round((dstR.width)
 											/ whratiovideo);
 									if (dstR.height > dstROrig.height) {
 										dstR.width--;
 										continue;
 									} else if (dstR.width <= dstROrig.width)
 										break;
 									else
 										dstR.width = dstROrig.width - 1;
 								}
 
 								dstR.x = dstROrig.x
 										+ ((dstROrig.width - dstR.width) / 2);
 								dstR.y = dstROrig.y
 										+ ((dstROrig.height - dstR.height) / 2);
 							}
 
 							// after: now width and height are adjusted properly
 							// to
 							// canvas for whole big image
 							if ((isAOIZoom == false)
 									&& ((srcR.width != imgR.width) || (srcR.height != imgR.height))) {
 								g2d.setColor(Color.black);
 								g2d.fillRect(dstR.x, dstR.y, dstR.width,
 										dstR.height);
 							}
 
 							if (isAOIZoom) {
 
 								if (isKeepAspectRatioEnabled) {
 									int widthaoi = srcR.width;
 									int heightaoi = srcR.height;
 
 									double whratioaoi = 1.0;
 									if (heightaoi > 0)
 										whratioaoi = ((double) widthaoi)
 												/ ((double) heightaoi);
 
 									// heightaoi = height;
 									widthaoi = dstROrig.width;
 
 									for (;;) {
 										heightaoi = (int) Math.round((widthaoi)
 												/ whratioaoi);
 										if (heightaoi > dstROrig.height) {
 											widthaoi--;
 											continue;
 										} else if (widthaoi <= dstROrig.width)
 											break;
 										else {
 											widthaoi = dstROrig.width;
 										}
 									}
 
 									dstR.width = widthaoi;
 									dstR.height = heightaoi;
 
 								}
 
 								dstR.x = dstROrig.x
 										+ ((dstROrig.width - dstR.width) / 2);
 								dstR.y = dstROrig.y
 										+ ((dstROrig.height - dstR.height) / 2);
 							} else {
 								double wscale_full = (dstR.width * 1.0
 										/ imgR.width * 1.0);
 								double hscale_full = (dstR.height * 1.0
 										/ imgR.height * 1.0);
 
 								dstR.width = (int) Math.round(srcR.width
 										* wscale_full);
 								dstR.height = (int) Math.round(srcR.height
 										* hscale_full);
 
 								dstR.x += ((int) (srcR.x * wscale_full));
 								dstR.y += ((int) (srcR.y * hscale_full));
 							}
 
 							g2d.drawImage(image, dstR.x, dstR.y, dstR.width,
 									dstR.height, null);
 
 							if (changeHeader.sourceHeader.cameraPortName == null) {
 								String s1 = "Error: Video Frame could not be decoded or displayed properly.";
 								String s2 = "# "
 										+ constHeader.frameHeader.frameNumber;
 
 								Font f = g2d.getFont();
 								Font f1 = f.deriveFont(Font.BOLD, (float) 12.0);
 								g2d.setFont(f1);
 
 								int maxAreaWidth = g2d.getFontMetrics()
 										.stringWidth(s1);
 
 								if (g2d.getFontMetrics().stringWidth(s2) > maxAreaWidth)
 									maxAreaWidth = g2d.getFontMetrics()
 											.stringWidth(s2);
 
 								maxAreaWidth += 40;
 								int maxAreaHeight = g2d.getFontMetrics()
 										.getHeight() * 2 + 20;
 
 								g2d.setColor(Color.black);
 								g2d
 										.fillRect(
 												((videoCanvas.getWidth() - maxAreaWidth) / 2),
 												(videoCanvas.getHeight() - maxAreaHeight) / 2,
 												maxAreaWidth, maxAreaHeight);
 
 								g2d.setColor(Color.red);
 								g2d
 										.drawString(
 												s1,
 												((videoCanvas.getWidth() - g2d
 														.getFontMetrics()
 														.stringWidth(s1)) / 2),
 												((videoCanvas.getHeight() - maxAreaHeight) / 2) + 20);
 
 								g2d.setColor(Color.white);
 								g2d
 										.drawString(
 												s2,
 												((videoCanvas.getWidth() - g2d
 														.getFontMetrics()
 														.stringWidth(s2)) / 2),
 												((videoCanvas.getHeight() - maxAreaHeight) / 2)
 														+ 25
 														+ g2d.getFontMetrics()
 																.getHeight());
 
 								g2d.setFont(f);
 
 							}
 
 							String sAddPixelValue = "";
 
 							if ((overlayState == OverlayState.ON)
 									|| (overlayState == OverlayState.AUTO && isVideoCanvasMouseInOverlay)) {
 								if (isVideoCanvasMouseInCanvas
 										&& isVideoCanvasMouseLeftButtonDown) {
 									sAddPixelValue = "";
 									try {
 										Point p = videoCanvas
 												.getMousePosition();
 										if (p != null) {
 											int pixelindex = 0;
 
 											sAddPixelValue += "  (out of dimension)";
 
 											if (((p.x >= dstR.x) && (p.x <= (dstR.x + dstR.width)))
 													&& ((p.y >= dstR.y) && (p.y <= (dstR.y + dstR.height)))) {
 												// do coordinate transform, src,
 												// dst
 
 												double dst2srcWidthRelation = 1.0
 														* srcR.width
 														/ dstR.width;
 												double dst2srcHeightRelation = 1.0
 														* srcR.height
 														/ dstR.height;
 
 												int pixelx = (int) ((1.0 * (p.x - dstR.x)) * dst2srcWidthRelation);
 												int pixely = (int) ((1.0 * (p.y - dstR.y)) * dst2srcHeightRelation);
 												if (pixelx >= srcR.width)
 													pixelx = srcR.width - 1;
 												if (pixely >= srcR.height)
 													pixely = srcR.height - 1;
 
 												pixelindex = (srcR.width
 														* pixely + pixelx);
 
 												sAddPixelValue = "  px("
 														+ (pixelx + 1 + srcR.x)
 														+ ","
 														+ (pixely + 1 + srcR.y)
 														+ ") = ";
 
 												if (changeHeader.frameHeader.imageFormat == CVideoHeader3.CF_IMAGE_FORMAT_GRAY) {
 													byte[] rawBuffer = changeHeader
 															.getImage()
 															.getImageFrameBuffer();
 													long pxvalue = ((long) rawBuffer[pixelindex
 															* changeHeader.frameHeader.bytesPerPixel]) & 0xff;
 													if (changeHeader.frameHeader.bytesPerPixel > 1)
 														pxvalue |= (((long) rawBuffer[pixelindex
 																* changeHeader.frameHeader.bytesPerPixel
 																+ 1]) & 0xff) << 8;
 													if (changeHeader.frameHeader.bytesPerPixel > 2)
 														pxvalue |= (((long) rawBuffer[pixelindex
 																* changeHeader.frameHeader.bytesPerPixel
 																+ 2]) & 0xff) << 16;
 													if (changeHeader.frameHeader.bytesPerPixel > 3)
 														pxvalue |= (((long) rawBuffer[pixelindex
 																* changeHeader.frameHeader.bytesPerPixel
 																+ 3]) & 0xff) << 24;
 
 													int maxpxvalue = (1 << changeHeader.frameHeader.effectiveBitsPerPixel) - 1;
 
 													sAddPixelValue += pxvalue
 															+ " (out of "
 															+ maxpxvalue + ")";
 												} else if (changeHeader.frameHeader.imageFormat == CVideoHeader3.CF_IMAGE_FORMAT_RGB) {
 													int pixel = displayImageBuffer[pixelindex];
 													long redvalue = ((long) pixel >> 16) & 0xff;
 													long greenvalue = ((long) pixel >> 8) & 0xff;
 													long bluevalue = ((long) pixel) & 0xff;
 
 													sAddPixelValue += "("
 															+ redvalue + "/"
 															+ greenvalue + "/"
 															+ bluevalue + ")";
 												} else if (changeHeader.frameHeader.imageFormat == CVideoHeader3.CF_IMAGE_FORMAT_RGBA) {
 													int pixel = displayImageBuffer[pixelindex];
 													long redvalue = ((long) pixel >> 16) & 0xff;
 													long greenvalue = ((long) pixel >> 8) & 0xff;
 													long bluevalue = ((long) pixel) & 0xff;
 
 													sAddPixelValue += "("
 															+ redvalue + "/"
 															+ greenvalue + "/"
 															+ bluevalue + ")";
 												} else if (changeHeader.frameHeader.imageFormat == CVideoHeader3.CF_IMAGE_FORMAT_JPEG) {
 													int pixel = displayImageBuffer[pixelindex];
 													long redvalue = ((long) pixel >> 16) & 0xff;
 													long greenvalue = ((long) pixel >> 8) & 0xff;
 													long bluevalue = ((long) pixel) & 0xff;
 
 													sAddPixelValue += "("
 															+ redvalue + "/"
 															+ greenvalue + "/"
 															+ bluevalue + ")";
 												} else {
 													sAddPixelValue += "(unknown)";
 												}
 											} // if (p.x >= ...)
 										} // if (p!= null)
 									} catch (HeadlessException ex1) {
 										// ex.printStackTrace();
 										// DEBUG SW!
 									}
 								}
 							}
 
 							if (overlayState == OverlayState.ON || //
 									(overlayState == OverlayState.AUTO && isVideoCanvasMouseInOverlay)) {
 
 								int canvasWidth = videoCanvas.getWidth();
 								int canvasHeight = videoCanvas.getHeight();
 
 								Dimension canvasDim = new Dimension(
 										canvasWidth, canvasHeight);
 								Point inset = new Point(10, 16);
 
 								Composite orgComposite = g2d.getComposite();
 								g2d.setColor(Color.lightGray);
 								g2d.setComposite(makeComposite(0.85F));
 								g2d.fillRect(2, 2, canvasWidth - 4, 40);
 								g2d.fillRect(2, canvasHeight - 42,
 										canvasWidth - 4, 40);
 								g2d.setComposite(orgComposite);
 
 								g2d.setColor(Color.black);
 
 								DateFormat df = new SimpleDateFormat(
 										"HH:mm:ss.SSS");
 								FrameHeader frameHdr = constHeader.frameHeader;
 
 								String leftStr, rightStr;
 								leftStr = "Source: "
 										+ constHeader.sourceHeader.cameraPortName
 										+ " ("
 										+ CVideoHeader3
 												.formatToString(frameHdr.sourceFormat)
 										+ ")";
 								rightStr = "# "
 										+ frameHdr.frameNumber
 										+ " - "
 										+ df.format(constHeader
 												.getTimestampAsDate());
 								drawCanvasString(g2d, canvasDim, leftStr,
 										rightStr, new Point(0, 0), inset);
 
 								leftStr = "Size: " + frameHdr.sourceWidth
 										+ " px * " + frameHdr.sourceHeight
 										+ " px * "
 										+ frameHdr.effectiveBitsPerPixel
 										+ " of " + frameHdr.bytesPerPixel * 8
 										+ " bpp ";
 
 								if (frameHdr.aoiWidth != -1
 										|| frameHdr.aoiHeight != -1)
 									leftStr += "(AOI: L " + frameHdr.xStart
 											+ ", T " + frameHdr.yStart + ", W "
 											+ frameHdr.aoiWidth + ", H "
 											+ frameHdr.aoiHeight + ")";
 								else
 									leftStr += "(AOI: none)";
 
 								rightStr = "Drop: "
 										+ droppedFrames
 										+ " ("
 										+ String.format("%4.3f", Double
 												.valueOf(ratio * 100.0)) + "%)";
 								drawCanvasString(g2d, canvasDim, leftStr,
 										rightStr, new Point(0, 18), inset);
 								leftStr = "Format: "
 										+ CVideoHeader3
 												.formatToString(frameHdr.imageFormat)
 										+ sAddPixelValue;
 								drawCanvasString(g2d, canvasDim, leftStr, null,
 										new Point(0, canvasHeight - 42), inset);
 
 								leftStr = "Flags: "
 										+ CVideoHeader3
 												.flagsToString(frameHdr.imageFlags);
 
 								double rotation = frameHdr.imageRotation;
 								rightStr = "Rotation: "
 										+ String.format("%4.2f", Double
 												.valueOf(Math.abs(rotation)))
 										+ "%";
 								if (rotation > 0.0)
 									rightStr += " cw";
 								else if (rotation < 0.0)
 									rightStr += " ccw";
 
 								drawCanvasString(g2d, canvasDim, leftStr,
 										rightStr, new Point(0,
 												canvasHeight - 24), inset);
 
 							}
 
 						} catch (Exception ex) {
 							// ex.printStackTrace();
 							// DEBUG SW!
 							// "NullPointerException at getDrawGraphics"
 						} finally {
 							if (g != null) {
 								g.dispose();
 							}
 						}
 					} while (flipStrategy.contentsRestored());
 
 					// Display the buffer
 					flipStrategy.show();
 
 					// Repeat the rendering if the drawing buffer was lost
 				} while (flipStrategy.contentsLost());
 
 			} catch (Exception ex) {
 				// DEBUG SW!
 				// ex.printStackTrace();
 				// "Exception in thread "AWT-EventQueue-0"
 				// java.lang.NullPointerException"
 				// at flipStrategy.show() or flipStrategy.contentsLost()
 			}
 
 		}
 		// synchronized(lockHeaderUpdate)
 
 	}
 
 	/**
 	 * @author mdavid
 	 */
 	private void drawCanvasString(Graphics2D g2d, Dimension canvas, //
 			String strL, String strR, Point pos, Point inset) {
 
 		FontMetrics fm = g2d.getFontMetrics();
 		int strLWidth = fm.stringWidth(strL) + inset.x;
 		drawCanvasString(strL, canvas, g2d, fm, pos, inset);
 		drawCanvasString(strR, canvas, g2d, fm, new Point(-strLWidth, pos.y),
 				inset);
 	}
 
 	/**
 	 * @author mdavid
 	 */
 	private void drawCanvasString(String str, Dimension canvas, Graphics2D g2d,
 			FontMetrics fm, Point pos, Point inset) {
 
 		if (str == null || str.length() == 0)
 			return;
 
 		boolean isRight = (pos.x < 0);
 		if (isRight)
 			pos.x = -pos.x;
 
 		int area = canvas.width - pos.x;
 		int strWidth = fm.stringWidth(str) + inset.x;
 
 		if (strWidth + inset.x > area) {
 			String suffix = "...";
 			int suffixWidth = fm.stringWidth(suffix) + inset.x;
 			strWidth = inset.x + suffixWidth;
 
 			StringBuilder sb = new StringBuilder();
 			for (int i = 0; i < str.length(); i++) {
 				if (strWidth >= area)
 					break;
 				sb.append(str.charAt(i));
 				strWidth = inset.x + fm.stringWidth(sb.toString())
 						+ suffixWidth;
 			}
 			g2d.drawString(sb.append(suffix).toString(), pos.x + inset.x, pos.y
 					+ inset.y);
 
 		} else
 			g2d.drawString(str, (isRight ? canvas.width - strWidth : pos.x
 					+ inset.x), pos.y + inset.y);
 	}
 
 	/**
 	 * helper function in oder to redraw contents of GUI and video canvas
 	 * display properly on-demand.
 	 * 
 	 * If more than one second no new video image came in (updateValue), the
 	 * video canvas is redrawn, too. Otherwise it is not redrawn due to
 	 * performance reasons.
 	 * 
 	 */
 	private void repaintAnything() {
 
 		// more than one second no new image came in:
 		// disable live transfer for this call only; update everything else
 		boolean shouldnotdraw = isLiveTransfer;
 
 		if (java.lang.System.currentTimeMillis() > reenableAlwaysUpdateVideoCanvas)
 			shouldnotdraw = false;
 
 		if (shouldnotdraw == false) {
 			updateImageCanvas();
 		}
 
 		super.repaint();
 	}
 
 	/**
 	 * uncompresses the image data if necessary.
 	 * 
 	 * @return
 	 * <ul>
 	 * <li>true in case of successful decompression or no decompression was
 	 * necessary
 	 * <li>false error on decompression
 	 * </ul>
 	 */
 	private boolean uncompressIfNecessary() {
 		byte[] compressedBuf = null;
 		int pixellength = changeHeader.getAppendedWidth()
 				* changeHeader.getAppendedHeight();
 		int uncompressed_byte_length = pixellength
 				* changeHeader.frameHeader.bytesPerPixel;
 
 		if ((changeHeader.frameHeader.imageFormat == CVideoHeader3.CF_IMAGE_FORMAT_HUFFYUV)
 				&& (changeHeader.frameHeader.sourceFormat == CVideoHeader3.CF_IMAGE_FORMAT_GRAY)) {
 
 			compressedBuf = new byte[changeHeader.frameHeader.appendedFrameSize];
 
 			System.arraycopy(changeHeader.getImage().getImageFrameBuffer(), 0,
 					compressedBuf, 0,
 					changeHeader.frameHeader.appendedFrameSize);
 
 			CHuffmanDecompression.DecompressHuffYUV(compressedBuf,
 					0,// CVideoHeader3.HDRSIZE
 					changeHeader.getImage().getImageFrameBuffer(), 0,
 					uncompressed_byte_length);
 
 			compressedBuf = null;
 
 			// adjust header after compression
 			changeHeader.frameHeader.imageFormat = (int) CVideoHeader3.CF_IMAGE_FORMAT_GRAY;
 			changeHeader.sourceHeader.totalLength = uncompressed_byte_length
 					+ CVideoHeader3.HDRSIZE;
 			changeHeader.frameHeader.appendedFrameSize = uncompressed_byte_length;
 		}
 
 		return true;
 	}
 
 	/**
 	 * calculates dropped frames and dropped frames percentage for each new
 	 * subsequent incoming frame.<br>
 	 * <br>
 	 * The following class member variables might be updated:
 	 * <ul>
 	 * <li>droppedFrames
 	 * <li>ratio
 	 * <li>receivedFrames
 	 * <li>lastFrameNumber
 	 * </ul>
 	 */
 	private void calculateDroppedFrames() {
 		// calculate variables:
 		// droppedFrames
 		// ratio
 		// receivedFrames
 		//
 		// by this, the following variables might be updated:
 		// lastFrameNumber
 
 		if (lastFrameNumber == -1) {
 			lastFrameNumber = changeHeader.frameHeader.frameNumber;
 			droppedFrames = 0;
 			receivedFrames++;
 		} else {
 			if (changeHeader.frameHeader.frameNumber == lastFrameNumber) {
 				// TODO this case should be subject to some error output
 				// SW! DEBUG
 				// System.out.println("Theyre same: " +
 				// changeHeader.frameHeader.frameNumber + " " + lastFrameNumber
 				// + " !");
 
 			} else if (changeHeader.frameHeader.frameNumber < lastFrameNumber) {
 				receivedFrames++;
 			} else {
 				droppedFrames += (changeHeader.frameHeader.frameNumber
 						- lastFrameNumber - 1);
 				receivedFrames++;
 			}
 			lastFrameNumber = changeHeader.frameHeader.frameNumber;
 
 		}
 
 		if (receivedFrames != 0)
 			ratio = ((1.0 * droppedFrames) / (1.0 * (receivedFrames)));
 	}
 
 	/**
 	 * renders the display image buffer. Creates (if not exist) a
 	 * MemoryImageSource for easy and fast transformation from
 	 * 'displayImageBuffer' to java.awt.Image and forces transformation by
 	 * calling memoryImageSource.newPixels().
 	 * 
 	 * @return
 	 * <ul>
 	 * <li>true in case rendering was successful
 	 * <li>false rendering to java.awt.Image was not successful
 	 * </ul>
 	 */
 	private boolean renderDisplayImageBuffer() {
 		// (3) java: create or renew memory image source and create java
 		// awt.Image out of it
 
 		if (memoryImageSource == null) {
 			memoryImageSource = new MemoryImageSource(changeHeader
 					.getAppendedWidth(), changeHeader.getAppendedHeight(),
 					displayImageBuffer, 0, changeHeader.getAppendedWidth());
 			memoryImageSource.setAnimated(true);
 			memoryImageSource.setFullBufferUpdates(true);
 			image = null;
 		}
 
 		if (image == null) {
 			image = Toolkit.getDefaultToolkit().createImage(memoryImageSource);
 		}
 
 		memoryImageSource.newPixels();
 
 		return true;
 	}
 
 	/**
 	 * 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>
 	 * If the parameter is set to true, the video canvas is redrawn, too.
 	 * 
 	 * @param aUpdateGraphics
 	 *            <ul>
 	 *            <li>true redraw image in canvas
 	 *            <li>false do updating of graphics, just "redraw" inside
 	 *            pipeline
 	 *            </ul>
 	 */
 	private void drawAndUpdate(boolean aUpdateGraphics) {
 		synchronized (lockHeaderUpdate) {
 			if (createDisplayBuffer(changeHeader) == false) {
 				changeHeader = new CVideoHeader3(errorScreen);
 				changeHeader.sourceHeader.cameraPortName = null;
 				createDisplayBuffer(changeHeader);
 			}
 			renderDisplayImageBuffer();
 		}
 
 		if (aUpdateGraphics) {
 			reenableAlwaysUpdateVideoCanvas = java.lang.System
 					.currentTimeMillis()
 					+ TIMEOUT;
 			updateImageCanvas(); // draw & display
 		}
 	}
 
 	/**
 	 * clones (1:1 copy) a video frame header and bits. It is used to have an
 	 * unchanged video header for meta information printing and a changed header
 	 * and bits for displaying later on.
 	 * 
 	 * 
 	 * @param aSrc
 	 *            source video image marshalled as CVideoHeader3
 	 * @param aFrameDataToo
 	 *            <ul>
 	 *            <li>true if the frame data (image bits) should be cloned, too
 	 *            <li>false if the image bits will not be cloned (much faster,
 	 *            less memory consumption)
 	 *            </ul>
 	 * @return cloned aSrc
 	 */
 	private CVideoHeader3 cloneVideoFrame(CVideoHeader3 aSrc,
 			boolean aFrameDataToo) {
 		// TODO there is a better way to do it
 
 		IMAGE img = new IMAGE();
 		IMAGE.FrameHeader frameHeader = img.getFrameHeader();
 		IMAGE.SourceHeader sourceHeader = img.getSourceHeader();
 
 		frameHeader.aoiHeight = aSrc.frameHeader.aoiHeight;
 		frameHeader.aoiWidth = aSrc.frameHeader.aoiWidth;
 		frameHeader.appendedFrameSize = aSrc.frameHeader.appendedFrameSize;
 		frameHeader.bytesPerPixel = aSrc.frameHeader.bytesPerPixel;
 		frameHeader.effectiveBitsPerPixel = aSrc.frameHeader.effectiveBitsPerPixel;
 		frameHeader.eventNumber = aSrc.frameHeader.eventNumber;
 		frameHeader.frameNumber = aSrc.frameHeader.frameNumber;
 		frameHeader.fspare1 = aSrc.frameHeader.fspare1;
 		frameHeader.fspare2 = aSrc.frameHeader.fspare2;
 		frameHeader.fspare3 = aSrc.frameHeader.fspare3;
 		frameHeader.horizontalBinning = aSrc.frameHeader.horizontalBinning;
 		frameHeader.imageFlags = aSrc.frameHeader.imageFlags;
 		frameHeader.imageFormat = aSrc.frameHeader.imageFormat;
 		frameHeader.imageRotation = aSrc.frameHeader.imageRotation;
 		frameHeader.ispare1 = aSrc.frameHeader.ispare1;
 		frameHeader.ispare2 = aSrc.frameHeader.ispare2;
 		frameHeader.ispare3 = aSrc.frameHeader.ispare3;
 		frameHeader.sourceFormat = aSrc.frameHeader.sourceFormat;
 		frameHeader.sourceHeight = aSrc.frameHeader.sourceHeight;
 		frameHeader.sourceWidth = aSrc.frameHeader.sourceWidth;
 		frameHeader.verticalBinning = aSrc.frameHeader.verticalBinning;
 		frameHeader.xScale = aSrc.frameHeader.xScale;
 		frameHeader.xStart = aSrc.frameHeader.xStart;
 		frameHeader.yScale = aSrc.frameHeader.yScale;
 		frameHeader.yStart = aSrc.frameHeader.yStart;
 
 		sourceHeader.baseTag = aSrc.sourceHeader.baseTag;
 		//sourceHeader.specificTag = aSrc.sourceHeader.specificTag;
 		sourceHeader.cameraPortId = aSrc.sourceHeader.cameraPortId;
 		sourceHeader.cameraPortName = new String(
 				aSrc.sourceHeader.cameraPortName);
 		//sourceHeader.specificTag = aSrc.sourceHeader.specificTag;
 		sourceHeader.timestampMicroseconds = aSrc.sourceHeader.timestampMicroseconds;
 		sourceHeader.timestampSeconds = aSrc.sourceHeader.timestampSeconds;
 		sourceHeader.totalLength = aSrc.sourceHeader.totalLength;
 		sourceHeader.versionTag = aSrc.sourceHeader.versionTag;
 
 		if (aFrameDataToo)
 			img.setImageFrameBuffer((byte[]) aSrc.getImage()
 					.getImageFrameBuffer().clone());
 		else
 			img.setImageFrameBuffer(new byte[1]); // TODO enhance this dummy
 		// hack
 
 		CVideoHeader3 temp = new CVideoHeader3(img);
 		return temp;
 	}
 
 	/**
 	 * Apply RGB colour histogram equalisation to the display image buffer. This
 	 * method is used for JPEG, RGB and ARGB input data types.<br>
 	 * <br>
 	 * <b>Note: </b>Quality of current colour histogram equalisation algorithm
 	 * is not very good and subject to further improvement.
 	 * 
 	 * @return true in case normalisation was applied false in case
 	 *         normalisation was not applied (no error, already good image,
 	 *         normalisation not necessary (possible) )
 	 */
 	private boolean normalizeDisplayImageBuffer() {
 		// this function is used/necessary for rgb color image normalisation
 		//
 		// TODO the current normalisation algorithm makes the image a little bit
 		// too
 		// bright (clipping occurs)
 		// IDEA: maybe use photoshop algorithm:
 		// http://www.lonestardigital.com/autocontrast.htm
 		// display image buffer contains ARGB
 
 		// (1) calculate min and max of Y (luminosity) from RGB value(s) of this
 		// buffer
 		double minY = 256.0;
 		double maxY = 0;
 		int x = 0;
 
 		try {
 			for (;;) {
 				int pixel = displayImageBuffer[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 ex) {
 			// DEBUG SW!
 			// ex.printStackTrace();
 		}
 
 		// (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 = displayImageBuffer[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;
 
 				displayImageBuffer[x++] = 0xFF000000 | (r2 << 16) | (g2 << 8)
 						| (b2);
 			}
 		} catch (ArrayIndexOutOfBoundsException ex) {
 			// DEBUG SW!
 			// ex.printStackTrace();
 
 		}
 
 		return true;
 	}
 
 	/**
 	 * updates JAVA TYPE_INT_ARGB displayImageBuffer based on grayscale data
 	 * passed as parameter. In addition, false colour normalisation is applied.
 	 * The normalisation is numerically precise and quite good, however
 	 * consideration of algorithm modification is considered for future.<br>
 	 * 
 	 * @param aHdr
 	 *            marshalled greyscale image and header
 	 * @return
 	 *            <ul>
 	 *            <li>false - no update was done, error on creation or
 	 *            conversion
 	 *            <li>true - success
 	 *            </ul>
 	 * 
 	 */
 	private boolean createDisplayBufferFromGREY(CVideoHeader3 aHdr) {
 		if (aHdr.frameHeader.imageFormat != CVideoHeader3.CF_IMAGE_FORMAT_GRAY) {
 			return false;
 		}
 
 		byte[] inBuf = aHdr.getImage().getImageFrameBuffer();
 		final int pixellength = aHdr.getAppendedHeight()
 				* aHdr.getAppendedWidth();
 
 		// enable switching of false color table if data format is gray and the
 		// switching
 		// was not enabled before
 		if (falseColorSwitchingAllowed == false) {
 			// enable false color switching in gui
 			setFalseColorSwitchingAllowed(true);
 		}
 
 		// perform adjustment of color lookup table, if necessary
 
 		// force updating of color lookup table here in special case
 		if ((colorLookupTableArray == null)
 				|| (colorLookupTableArray.length != (1 << (aHdr.frameHeader.bytesPerPixel * 8))))
 			isDoUpdateColorLookupTable = true;
 
 		// if color lookup table update is pending, do it NOW!
 		if (isDoUpdateColorLookupTable) {
 			boolean ret = colorLookupTable.AdjustTable(colorMode,
 					aHdr.frameHeader.bytesPerPixel,
 					aHdr.frameHeader.effectiveBitsPerPixel);
 			if (ret || colorLookupTableArray == null)
 				colorLookupTableArray = colorLookupTable.getColorLookupTable();
 			isDoUpdateColorLookupTable = false;
 		}
 
 		final int maxcol = (1 << aHdr.frameHeader.effectiveBitsPerPixel) - 1;
 
 		// if normalisation is switched on, perform
 		// histogram equalisation on single-z-dimension (e.g. luminosity only)
 		// data
 
 		if (isHistogramEqualisation) {
 			// with histogram equalisation (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)
 			if (aHdr.frameHeader.bytesPerPixel == 1) {
 				try {
 					int index = 0; // performance-tip
 					while (index < pixellength) {
 						int pixel = (inBuf[index] & maxcol);
 						if (pixel < lowest)
 							lowest = pixel;
 						if (pixel > highest && pixel <= maxcol)
 							highest = pixel;
 						index++;
 					}
 				} catch (ArrayIndexOutOfBoundsException ex) {
 					// DEBUG SW!
 					// ex.printStackTrace();
 				}
 			} else if (aHdr.frameHeader.bytesPerPixel == 2) {
 				try {
 					int index = 0; // performance-tip
 					int bytelength = pixellength * 2;
 					while (index < bytelength) {
 						int pixel = ((inBuf[index]) & 0xff)
 								+ (((inBuf[index + 1]) & 0xff) << 8);
 
 						if (pixel < lowest)
 							lowest = pixel;
 						if (pixel > highest && pixel <= maxcol)
 							highest = pixel;
 						index += 2;
 					}
 				} catch (ArrayIndexOutOfBoundsException ex) {
 					// DEBUG SW!
 					// ex.printStackTrace();
 				}
 			} else // 3 bytes per pixel
 			{
 				try {
 					int index = 0; // performance-tip
 					int bytelength = pixellength * 3;
 					while (index < bytelength) {
 						int pixel = ((inBuf[index]) & 0xff)
 								+ (((inBuf[index + 1]) & 0xff) << 8)
 								+ (((inBuf[index + 2]) & 0xff) << 16);
 
 						if (pixel < lowest)
 							lowest = pixel;
 						if (pixel > highest && pixel <= maxcol)
 							highest = pixel;
 
 						index += 3;
 					}
 				} catch (ArrayIndexOutOfBoundsException ex) {
 					// DEBUG SW!
 					// ex.printStackTrace();
 				}
 			}
 
 			// only rescale if it is necessary(!)
 			if (lowest != highest)
 
 			{ // rescale the inBuf
 				// note: affects saving, as we save wysiwyg
 
 				// TODO: found on aug01, 2008: affects not only saving, which is
 				// logical, but also switching it off again (which cannot be
 				// seen
 				// by updated image in canvas because _source data_ was altered
 
 				// 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)
 				if (aHdr.frameHeader.bytesPerPixel == 1) {
 					try {
 						int index = 0; // performance-tip
 						final int bytelength = pixellength * 1;
 						while (index < bytelength) {
 							int pixel = (inBuf[index] & 0xff);
 
 							if (pixel <= maxcol)
 								pixel = ((int) ((step * (double) pixel)))
 										+ offset;
 
 							inBuf[index] = (byte) (pixel);
 							index++;
 						}
 					} catch (ArrayIndexOutOfBoundsException ex) {
 						// DEBUG SW!
 						// ex.printStackTrace();
 					}
 				} else if (aHdr.frameHeader.bytesPerPixel == 2) {
 					try {
 						int index = 0; // performance-tip
 						final int bytelength = pixellength * 2;
 						while (index < bytelength) {
 							int pixel = ((inBuf[index]) & 0xff)
 									+ (((inBuf[index + 1]) & 0xff) << 8);
 
 							if (pixel <= maxcol)
 								pixel = ((int) ((step * (double) pixel)))
 										+ offset;
 
 							inBuf[index] = (byte) (pixel & 0xff);
 							inBuf[index + 1] = (byte) ((pixel >> 8) & 0xff);
 
 							index += 2;
 						}
 					} catch (ArrayIndexOutOfBoundsException ex) {
 						// DEBUG SW!
 						// ex.printStackTrace();
 					}
 				} else // 3 bytes per pixel
 				{
 					try {
 						int index = 0; // performance-tip
 						final int bytelength = pixellength * 3;
 						while (index < bytelength) {
 							int pixel = ((inBuf[index]) & 0xff)
 									+ (((inBuf[index + 1]) & 0xff) << 8)
 									+ (((inBuf[index + 2]) & 0xff) << 16);
 
 							if (pixel <= maxcol)
 								pixel = ((int) ((step * (double) pixel)))
 										+ offset;
 
 							inBuf[index] = (byte) (pixel & 0xff);
 							inBuf[index + 1] = (byte) ((pixel >> 8) & 0xff);
 							inBuf[index + 2] = (byte) ((pixel >> 16) & 0xff);
 
 							index += 3;
 						}
 					} catch (ArrayIndexOutOfBoundsException ex) {
 						// DEBUG SW!
 						// ex.printStackTrace();
 					}
 				} // for different bits per pixel
 			} // lowest != highest
 		} // apply normalisation
 
 		// (2) convert to DisplayImageBuffer using false-color table
 		// in other words: transform greyscale to ARGB32 values for java display
 		// distinct for each supported bytes per pixel setting (1, 2, 3)
 		if (aHdr.frameHeader.bytesPerPixel == 1) {
 			try {
 				int index = 0; // performance-tip
 				for (;;) {
 					displayImageBuffer[index] = colorLookupTableArray[inBuf[index] & 0xff];
 					index++;
 				}
 			} catch (ArrayIndexOutOfBoundsException ex) {
 				// DEBUG SW!
 				// ex.printStackTrace();
 			}
 		} else if (aHdr.frameHeader.bytesPerPixel == 2) {
 			try {
 				int index = 0; // performance-tip
 				for (;;) {
 					int pixel = ((inBuf[2 * index]) & 0xff)
 							+ (((inBuf[2 * index + 1]) & 0xff) << 8);
 
 					displayImageBuffer[index] = colorLookupTableArray[pixel];
 					index++;
 				}
 			} catch (ArrayIndexOutOfBoundsException ex) {
 				// DEBUG SW!
 				// ex.printStackTrace();
 			}
 		} else // 3 bytes per pixel
 		{
 			try {
 				int index = 0; // performance-tip
 				for (;;) {
 					int pixel = ((inBuf[3 * index]) & 0xff)
 							+ (((inBuf[3 * index + 1]) & 0xff) << 8)
 							+ (((inBuf[3 * index + 2]) & 0xff) << 16);
 
 					displayImageBuffer[index] = colorLookupTableArray[pixel];
 					index++;
 				}
 			} catch (ArrayIndexOutOfBoundsException ex) {
 				// DEBUG SW!
 				// ex.printStackTrace();
 			}
 		}
 
 		return true;
 	}
 
 	/**
 	 * updates JAVA TYPE_INT_ARGB displayImageBuffer based on colour data and
 	 * header passed as parameter. In addition, colour normalisation is applied
 	 * on demand.<br>
 	 * 
 	 * @param aHdr
 	 *            marshalled RGB (24bpp r-g-b) image data and header
 	 * @return
 	 *            <ul>
 	 *            <li>false - no update was done, error on creation or
 	 *            conversion
 	 *            <li>true - success
 	 *            </ul>
 	 * 
 	 */
 	private boolean createDisplayBufferFromRGB(CVideoHeader3 aHdr) {
 		if (aHdr.frameHeader.imageFormat != CVideoHeader3.CF_IMAGE_FORMAT_RGB)
 			return false;
 
 		if (falseColorSwitchingAllowed) {
 			// disable false color switching in gui
 			setFalseColorSwitchingAllowed(false);
 		}
 		byte[] inBuf = aHdr.getImage().getImageFrameBuffer();
 
 		// transform RGB24 color into ARGB32 color for java awt.Image
 		int index = 0;
 		int index1 = 0;
 
 		try {
 			for (;;) {
 				int red16 = inBuf[index1++] & 0xFF;
 				int green8 = inBuf[index1++] & 0xFF;
 				int blue = inBuf[index1++] & 0xFF;
 
 				displayImageBuffer[index++] = 0xFF000000 | (red16 << 16)
 						| (green8 << 8) | (blue);
 				//  
 			}
 		} catch (ArrayIndexOutOfBoundsException ex) {
 			// DEBUG SW!
 			// ex.printStackTrace();
 		}
 
 		if (isHistogramEqualisation)
 			normalizeDisplayImageBuffer();
 
 		return true;
 	}
 
 	/**
 	 * updates JAVA TYPE_INT_ARGB displayImageBuffer based on colour data and
 	 * header passed as parameter. In addition, colour normalisation is applied
 	 * on demand.<br>
 	 * 
 	 * @param aHdr
 	 *            marshalled RGB (32bpp a-r-g-b) image data and header, alpha is
 	 *            <b>not</b> taken into account
 	 * @return
 	 *            <ul>
 	 *            <li>false - no update was done, error on creation or
 	 *            conversion
 	 *            <li>true - success
 	 *            </ul>
 	 * 
 	 */
 	private boolean createDisplayBufferFromARGB(CVideoHeader3 aHdr) {
 		if (aHdr.frameHeader.imageFormat != CVideoHeader3.CF_IMAGE_FORMAT_RGBA)
 			return false;
 
 		if (falseColorSwitchingAllowed) {
 			// disable false color switching in gui
 			setFalseColorSwitchingAllowed(false);
 		}
 
 		int pixellength = aHdr.getAppendedHeight() * aHdr.getAppendedWidth();
 		byte[] inBuf = aHdr.getImage().getImageFrameBuffer();
 
 		System.arraycopy(java.nio.ByteBuffer.wrap(inBuf).asIntBuffer(), 0,
 				displayImageBuffer, 0, pixellength);
 
 		if (isHistogramEqualisation)
 			normalizeDisplayImageBuffer();
 
 		return true;
 	}
 
 	/**
 	 * updates JAVA TYPE_INT_ARGB displayImageBuffer based on JPEG file bits
 	 * data and header passed as parameter. In addition, colour normalisation is
 	 * applied on demand.<br>
 	 * 
 	 * @param aHdr
 	 *            marshalled JPEG file bits (whole file attached) image data and
 	 *            header
 	 * 
 	 * @return
 	 * <ul>
 	 * <li>false - no update was done, error on creation or conversion
 	 * <li>true - success
 	 * </ul>
 	 * 
 	 */
 	private boolean createDisplayBufferFromJPEG(CVideoHeader3 aHdr) {
 		if (aHdr.frameHeader.imageFormat != CVideoHeader3.CF_IMAGE_FORMAT_JPEG)
 			return false;
 
 		if (falseColorSwitchingAllowed) {
 			// disable false color switching in gui
 			setFalseColorSwitchingAllowed(false);
 		}
 
 		// decode Java image
 		BufferedImage jimg = null;
 		try {
 			Image i1 = Toolkit.getDefaultToolkit().createImage(
 					aHdr.getImage().getImageFrameBuffer());
 			try {
 				MediaTracker tracker = new MediaTracker(this);
 				tracker.addImage(i1, 0);
 				tracker.waitForID(0);
 			} catch (InterruptedException ex) {
 				// DEBUG SW!
 				// ex.printStackTrace();
 				return false;
 			}
 
 			jimg = new BufferedImage(aHdr.getAppendedWidth(), aHdr
 					.getAppendedHeight(), BufferedImage.TYPE_INT_ARGB);
 
 			Graphics2D bufImageGraphics = jimg.createGraphics();
 			bufImageGraphics.drawImage(i1, 0, 0, null);
 		} catch (Exception ex) {
 			// DEBUG SW!
 			// ex.printStackTrace();
 			return false;
 		}
 
 		// get ARGB data from java image into display buffer
 		int imgWidth = jimg.getWidth();
 		int imgHeight = jimg.getHeight();
 
 		if (imgWidth != aHdr.getAppendedWidth())
 			return false;
 		if (imgHeight != aHdr.getAppendedHeight())
 			return false;
 
 		if (jimg.getRGB(0, 0, imgWidth, imgHeight, displayImageBuffer, 0,
 				imgWidth) == null)
 			return false;
 
 		if (isHistogramEqualisation)
 			normalizeDisplayImageBuffer();
 
 		return true;
 	}
 
 	/**
 	 * Takes a snapshot of the currently displayed image.
 	 * 
 	 * @return a snapshot of the current image
 	 */
 	public Image getSnapshotImage() {
 		synchronized (lockHeaderUpdate) {
 			if (image == null)
 				return null;
 
 			BufferedImage bf = new BufferedImage(image.getWidth(this), image
 					.getHeight(this), BufferedImage.TYPE_INT_RGB);
 			bf.getGraphics().drawImage(image, 0, 0, this);
 			return bf;
 		}
 	}
 
 	/**
 	 * updates JAVA TYPE_INT_ARGB displayImageBuffer based on any input data and
 	 * header the image displayer is capable of processing. In addition,
 	 * normalisation of given input data type is applied on demand.<br>
 	 * 
 	 * @param aHdr
 	 *            RGB, ARGB, JPEG or Luminosity (Grayscale) image data and
 	 *            header
 	 * @return
 	 *            <ul>
 	 *            <li>false - no update was done, error on creation or
 	 *            conversion
 	 *            <li>true - success
 	 *            </ul>
 	 * 
 	 */
 	private boolean createDisplayBuffer(CVideoHeader3 aHdr) {
 		// (1) if
 
 		int iFmt = aHdr.frameHeader.imageFormat;
 		// int sFmt = changeHeader.frameHeader.sourceFormat;
 
 		// if ((iFmt != CVideoHeader3.CF_IMAGE_FORMAT_GRAY) &&
 		// && (sFmt != CVideoHeader3.CF_IMAGE_FORMAT_GRAY)
 
 		if ((iFmt != CVideoHeader3.CF_IMAGE_FORMAT_GRAY)
 				&& (iFmt != CVideoHeader3.CF_IMAGE_FORMAT_HUFFYUV)
 				&& (iFmt != CVideoHeader3.CF_IMAGE_FORMAT_RGB)
 				&& (iFmt != CVideoHeader3.CF_IMAGE_FORMAT_RGBA)
 				&& (iFmt != CVideoHeader3.CF_IMAGE_FORMAT_JPEG)) {
 			return false;
 		}
 
 		int pixellength = aHdr.getAppendedWidth() * aHdr.getAppendedHeight();
 
 		// (1) readjust storage location for display image buffer if length
 		// differs
 
 		if (displayImageBuffer == null) {
 			displayImageBuffer = new int[pixellength];
 			memoryImageSource = null; // invalidate!
 		} else if (displayImageBuffer.length != pixellength) {
 			displayImageBuffer = new int[pixellength];
 			memoryImageSource = null; // invalidate!
 		}
 
 		// perform branch based on image format
 		if (aHdr.frameHeader.imageFormat == CVideoHeader3.CF_IMAGE_FORMAT_GRAY)
 			return createDisplayBufferFromGREY(aHdr);
 		else if (aHdr.frameHeader.imageFormat == CVideoHeader3.CF_IMAGE_FORMAT_RGB)
 			return createDisplayBufferFromRGB(aHdr);
 		else if (aHdr.frameHeader.imageFormat == CVideoHeader3.CF_IMAGE_FORMAT_RGBA)
 			return createDisplayBufferFromARGB(aHdr);
 		else if (aHdr.frameHeader.imageFormat == CVideoHeader3.CF_IMAGE_FORMAT_JPEG)
 			return createDisplayBufferFromJPEG(aHdr);
 		else {
 			return false;
 		}
 	}
 
 }