// Copyright 2000, CERN, Geneva, Switzerland and University of Santa Cruz, California, U.S.A.
   package org.freehep.graphicsio.ps;
   
   import java.awt.Image;
   import java.awt.image.ImageProducer;
   import java.io.DataOutputStream;
   import java.io.IOException;
   import java.io.OutputStream;
   
  import org.freehep.graphicsio.ImageEncoder;
  
  /**
   * 
   * @author Charles Loomis
   * @version $Id: EPSIEncoder.java 8584 2006-08-10 23:06:37Z duns $
   */
  public class EPSIEncoder extends ImageEncoder {
  
      // Number of bits per byte.
      final static int maxBitsPerByte = 8;
  
      // Number of bytes per scan line (maximum here is 254).
      final static int maxBytesPerScan = 128;
  
      // The number of bits to use to represent the grayscale.
      private int grayscaleBits;
  
      // Boolean which gives the orientation of the image.
      private boolean portrait;
  
      // The width and height of the image.
      int width, height;
  
      // The array to hold the pixels.
      byte[][] grayPixels;
  
      // An array which hold enough bytes for one scan line.
      Scanline scanline;
  
      // Private conversion of bytes to hex digits.
      private static char[] hexDigit = { '0', '1', '2', '3', '4', '5', '6', '7',
              '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
  
      // Masks to strip off last n bits.
      final private static byte[] lowBitMask = { (byte) 0, (byte) 1, (byte) 3,
              (byte) 7, (byte) 15, (byte) 31, (byte) 63, (byte) 127, (byte) 255 };
  
      /**
       * Constructor from Image with number of grayscale bits to use.
       * 
       * @param img The image to encode.
       * @param out The stream to write the GIF to.
       * @param grayscaleBits Number of grayscale bits to use.
       * @param portrait Flag indicating a portrait orientation.
       */
      public EPSIEncoder(Image img, OutputStream out, int grayscaleBits,
              boolean portrait) throws IOException {
  
          super(img, new DataOutputStream(out));
          this.grayscaleBits = grayscaleBits;
          this.portrait = portrait;
      }
  
      /**
       * Constructor from ImageProducer with number of grayscale bits to use.
       * 
       * @param prod The ImageProducer to encode.
       * @param out The stream to write the GIF to.
       * @param grayscaleBits Number of grayscale bits to use.
       * @param portrait Flag indicating a portrait orientation.
       */
      public EPSIEncoder(ImageProducer prod, OutputStream out, int grayscaleBits,
              boolean portrait) throws IOException {
  
          super(prod, new DataOutputStream(out));
          this.grayscaleBits = grayscaleBits;
          this.portrait = portrait;
      }
  
      protected void encodeStart(int width, int height) throws IOException {
  
          this.width = width;
          this.height = height;
          grayPixels = new byte[height][width];
  
          // Use the appropriate width and height depending on the orientation.
          int w, h;
          if (portrait) {
              w = width;
              h = height;
          } else {
              w = height;
              h = width;
          }
  
          // Calculate the number of lines in the image.
          int bitsPerScan = w * grayscaleBits;
          int bytesPerScan = (bitsPerScan / maxBitsPerByte)
                  + ((bitsPerScan % maxBitsPerByte == 0) ? 0 : 1);
         int linesPerScan = (bytesPerScan / maxBytesPerScan)
                 + ((bytesPerScan % maxBytesPerScan == 0) ? 0 : 1);
         int lines = linesPerScan * h;
 
         // Make a byte array which holds the information for one scan line.
         scanline = new Scanline(bytesPerScan, grayscaleBits);
 
         // Write out the header.
         putString("%%BeginPreview " + width + " " + height + " "
                 + grayscaleBits + " " + lines + "\n");
     }
 
     protected void encodePixels(int x, int y, int w, int h, int[] rgbPixels,
             int off, int scansize) throws IOException {
 
         // Save the pixels as a grayscale value.
         for (int row = 0; row < h; ++row) {
             for (int column = 0; column < w; column++) {
                 grayPixels[y + row][column] = toGrayscale(rgbPixels[row
                         * scansize + off + column]);
             }
         }
     }
 
     // Convert a value given as AARRGGBB to a single grayscale value.
     private byte toGrayscale(int argb) {
         int mask = 0xFF;
         double blue = ((double) ((argb >> 0) & mask)) / 255.;
         double green = ((double) ((argb >> 8) & mask)) / 255.;
         double red = ((double) ((argb >> 16) & mask)) / 255.;
 
         return (byte) (255. * Math.max(0.,
                 (1. - (0.3 * red + 0.59 * green + 0.11 * blue))));
     }
 
     protected void encodeDone() throws IOException {
 
         if (portrait) {
             for (int row = height - 1; row >= 0; row--) {
                 scanline.reset();
                 for (int col = 0; col < width; col++) {
                     byte gray = grayPixels[row][col];
                     scanline.add(gray);
                 }
                 scanline.put();
             }
         } else {
             for (int col = width - 1; col >= 0; col--) {
                 scanline.reset();
                 for (int row = height - 1; row >= 0; row--) {
                     byte gray = grayPixels[row][col];
                     scanline.add(gray);
                 }
                 scanline.put();
             }
         }
 
         // Write out the trailer.
         putString("%%EndPreview\n");
     }
 
     // Write a string to the file.
     void putString(String s) throws IOException {
 
         out.write(s.getBytes());
     }
 
     // Write out a character to the file.
     void putChar(char c) throws IOException {
 
         out.write(c);
     }
 
     // Write out a byte to the GIF file
     void putByte(byte b) throws IOException {
 
         int highNibble = (b >> 4) & 0xF;
         int lowNibble = b & 0xF;
 
         out.write(hexDigit[highNibble]);
         out.write(hexDigit[lowNibble]);
     }
 
     // This class handles packing the scan data into a hexadecimal byte array.
     // This only works if the number of bits is 1, 2, 4, or 8.
     private class Scanline {
 
         private byte[] line;
 
         private int nbits;
 
         private int currentByte;
 
         private int currentOffset;
 
         public Scanline(int size, int nbits) {
             line = new byte[size];
             this.nbits = nbits;
             reset();
         }
 
         // Reset the scan line. Always zero the last byte in case the
         // scan line isn't fully used by the image.
         public void reset() {
             currentByte = 0;
             currentOffset = 0;
             for (int i = 0; i < line.length; i++) {
                 line[i] = 0;
             }
         }
 
         public void add(byte b) {
 
             // Put the most significant bits in the lowest bits.
             b >>= (maxBitsPerByte - nbits);
             b &= lowBitMask[nbits];
 
             // OR in the information.
             line[currentByte] |= b;
 
             // Update the offsets.
             if (maxBitsPerByte - nbits - currentOffset == 0) {
 
                 // We're reached the end of a byte, just reset the counters.
                 currentOffset = 0;
                 currentByte++;
             } else {
 
                 // Increment the offset and shift the word for the next
                 // bits of information.
                 currentOffset += nbits;
                 line[currentByte] <<= nbits;
             }
         }
 
         public void put() throws IOException {
 
             // Check the last byte. If currentOffset isn't zero then
             // the last byte hasn't been fully shifted into place.
             // Do it now!
             while (maxBitsPerByte - nbits - currentOffset > 0) {
                 line[line.length - 1] <<= nbits;
                 currentOffset += nbits;
             }
 
             for (int i = 0; i < line.length; i++) {
                 if (i % maxBytesPerScan == 0) {
                     if (i != 0)
                         putChar('\n');
                     putChar('%');
                 }
                 putByte(line[i]);
             }
             putChar('\n');
         }
     }
 
 }