package de.desy.video.sw;
   
   import java.io.File;
   
   import de.desy.tine.types.*;
   //file to BufferedImage
   import java.awt.image.BufferedImage;
   import java.net.URL;
   import java.io.IOException;
  import javax.imageio.ImageIO;
  import java.net.URISyntaxException;
  
  /**
  * <code>CBasicImageLoaderV3</code> provides loading of any Java SE supported bitmap image 
  * file format to Video System v3 TINE IMAGE format type. While loading, conversion to 
  * grayscale image data can be done if desired. Main interest for current usage is PNG file loading from disk.<br>
  * <br>
  * The loadable formats are (according to tests using {@link printLoadableFormats()}):
  * <ul>
  * <li>BMP
  * <li>bmp
  * <li>jpg
  * <li>JPG
  * <li>wbmp
  * <li>jpeg
  * <li>png
  * <li>PNG
  * <li>JPEG
  * <li>WBMP
  * <li>GIF
  * <li>gif 
  * </ul>
  * Please note that upper- and lowercase file extensions are outlined, which I think could 
  * mean that case sensitivity of file extention plays a role and (possibly, unchecked) .PnG
  * file extension is rejected. 
  *    
  * @author <a href="mailto:stefan.weisse@desy.de">Stefan Weisse</a>
  * @version $Id: Templates.xml,v 1.10 2008/06/20 16:00:13 sweisse Exp $
  *
  */
  public final class CBasicImageLoaderV3 {
  
  	/**
  	 * prints all formats that Java ImageIO class is able to read to stdout. This helps
  	 * when getting to know which file formats are supported.
  	 */
  	public static final void printLoadableFormats() {
  		String[] names = ImageIO.getReaderFormatNames();
  		for ( String name: names )
  		{
  			System.out.println( name );
  		}
  	}
  
  	// e.g. file put in JAR file, ...
  	/**
  	 * loads an image file with a give filename out of a resource bundle (e.g. JAR file)
  	 * and puts its contents to TINE IMAGE data type
  	 * <br>
  	 * <br>
  	 * <b>This method is untested!</b>
  	 * <br>
  	 * @param aFileName file name (may include relative resource path)
  	 * @param aOutImage TINE IMAGE data type to put image contents to
  	 * @param @param aChangeToGrey	if true, image data is downscaled to grayscale before returned
  	 * @return true - image contents were successfully put into aOutImage<br>
  	 *         false - some error (aOutImage is null, IOException, URISyntaxException, img.getRGB error)
  	 */
  
  	public static final boolean loadImageResource( String aFileName, IMAGE aOutImage, boolean aChangeToGrey)
  	{
  		if (aOutImage == null) return false;
  		
  		// (1) load file into java buffered image
  		BufferedImage img = null;
  		File imgFile = null;
  		try {
  			URL fileURL = Thread.currentThread().getContextClassLoader().getResource(aFileName);
  			 imgFile = new File( fileURL.toURI() );
  			img = ImageIO.read( fileURL );
  		}
  		catch(IOException ex)
  		{
  			return false;
  		}
  		catch(URISyntaxException ex)
  		{
  			return false;
  		}
  		
  		return postProcess(imgFile, img, aOutImage, aChangeToGrey);
  	}
  
  	/**
  	 * convenience overload, defaults grayscale conversion to false
  	 * 
  	 * @see loadImageFile( String, IMAGE, boolean )
  	 */ 
  	
 	public static final boolean loadImageFile( String aFileName, IMAGE aOutImage)
 	{
 		return loadImageFile( aFileName, aOutImage, false);
 	}
 	
 	// purpose: load in known fileformats from disk
 	// at the moment, png, jpeg, gif, ... are supported directly by java image loading functions
 	/**
 	 * loads an image file with a give filename from disk
 	 * and puts its contents to TINE IMAGE data type
 	 * <br>
 	 * @param aFileName file name (may include path)
 	 * @param aOutImage TINE IMAGE data type to put image contents to
 	 * @param aChangeToGrey	if true, image data is downscaled to grayscale before returned
 	 * @return true - image contents were successfully put into aOutImage<br>
 	 * 		   false - some error (aOutImage is null, IOException, URISyntaxException, error img.getRGB)
 	 */
 	public static final boolean loadImageFile( String aFileName, IMAGE aOutImage, boolean aChangeToGrey)
 	{
 		if (aOutImage == null) return false;
 		
 		// (1) load file into java buffered image
 		BufferedImage img = null;
 		File imgFile = null;
 		try {
 			imgFile = new File( aFileName );
 			img = ImageIO.read( imgFile );
 		}
 		catch(IOException ex)
 		{
 			return false;
 		}
 		
 		return postProcess(imgFile, img, aOutImage, aChangeToGrey);
 	}
 	
 	/* no javadoc
 	 * 
 	 * postprocesses the java buffered image and creates a VSv3 transport layer compatible image
 	 * out of it, color-to-grayscale can be performed in this step on demand, File class is 
 	 * necessary for file name string only
 	 * 
 	 * returns false in the following cases
 	 *	  img.getRGB error
 	 */
 	private static final boolean postProcess(File imgFile, BufferedImage img, IMAGE aOutImage, boolean aChangeToGrey)
 	{
 		// (1) obtain TYPE_INT_ARGB pixel array out of "img"
 		
 		int imgWidth = img.getWidth();
 		int imgHeight = img.getHeight();
 		
 		int[] pixelArr = new int[imgWidth*imgHeight];
 				
 		if (img.getRGB(0,0,imgWidth, imgHeight, pixelArr, 0, imgWidth) == null)
 			return false;
 
 		// (2) create TINE IMAGE type out of it
 		
 		IMAGE.FrameHeader frameHeader = aOutImage.getFrameHeader();
 		IMAGE.SourceHeader sourceHeader = aOutImage.getSourceHeader();
 
 		if (aChangeToGrey == true) {
 			frameHeader.bytesPerPixel = 1;
 			frameHeader.effectiveBitsPerPixel = 8;
 			frameHeader.imageFormat = (int) CVideoHeader3.CF_IMAGE_FORMAT_GRAY;
 			frameHeader.sourceFormat = (int) CVideoHeader3.CF_IMAGE_FORMAT_GRAY;
 		}
 		else
 		{
 			// keep RGB
 			frameHeader.bytesPerPixel = 3;
 			frameHeader.effectiveBitsPerPixel = 24;
 			frameHeader.imageFormat = (int) CVideoHeader3.CF_IMAGE_FORMAT_RGB;
 			frameHeader.sourceFormat = (int) CVideoHeader3.CF_IMAGE_FORMAT_RGB;
 		}
 	
 
 		frameHeader.appendedFrameSize = imgWidth*imgHeight*frameHeader.bytesPerPixel;
 		
 		frameHeader.aoiHeight = -1;
 		frameHeader.aoiWidth = -1;
 
 		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.imageRotation = (float) 0.0;
 		frameHeader.ispare1 = -1;
 		frameHeader.ispare2 = -1;
 		frameHeader.ispare3 = -1;
 		frameHeader.sourceHeight = imgHeight;
 		frameHeader.sourceWidth = imgWidth;
 		frameHeader.verticalBinning = 0;
 		frameHeader.xScale = (float) 1.000;
 		frameHeader.xStart = 0;
 		frameHeader.yScale = (float) 1.000;
 		frameHeader.yStart = 0;
 		
 		sourceHeader.baseTag = (int) CVideoHeader3.CF_IMAGE_MAGIC_01;
 		sourceHeader.cameraPortName = "file://"+imgFile.getName(); // TODO: could be too long and truncated badly
 		sourceHeader.cameraPortId = (int) CVideoHeader3.CF_IMAGE_NO_CAMERA_PORT_ID;
 
 		long msTimeEpoch = imgFile.lastModified();
 		sourceHeader.timestampMicroseconds = (int) (((msTimeEpoch%((long)1000))*((long)1000)));
 		sourceHeader.timestampSeconds = (int) (((msTimeEpoch)/((long)1000)));
 
 		sourceHeader.totalLength = CVideoHeader3.HDRSIZE + frameHeader.appendedFrameSize;
 		sourceHeader.versionTag = CVideoHeader3.CF_IMAGE_VERSION;
 		
 		byte[] buf = new byte[frameHeader.appendedFrameSize];
 
 		// imperformant, but fast-to-implement solution:
 		// Note: maybe make faster!
 		
 		if (aChangeToGrey == true)
 		{
 			for (int i=0;i<frameHeader.sourceWidth*frameHeader.sourceHeight;i++)
 			{
 				double r = (double) ((pixelArr[i]>>16)&0xff);
 				double g = (double) ((pixelArr[i]>>8)&0xff);
 				double b = (double) (pixelArr[i]&0xff);
 				buf[i] = (byte) (0.114*b+0.587*g+0.299*r);
 			}
 		}
 		else
 		{
 			int pos = 0;
 			for (int i=0;i<frameHeader.sourceWidth*frameHeader.sourceHeight;i++)
 			{
 				buf[pos++] = (byte) ((pixelArr[i]>>16)&0xff); // R
 				buf[pos++] = (byte) ((pixelArr[i]>>8)&0xff); // G
 				buf[pos++] = (byte) (pixelArr[i]&0xff); // B
 			}
 		}
 
 		aOutImage.setImageFrameBuffer(buf);
 				
 		return true;
 	}
 }