package ij.plugin.filter;
import ij.*;
import ij.process.*;
import ij.gui.*;
import ij.io.*;
import ij.plugin.Animator;
import java.awt.*;
import java.awt.image.*;
import java.io.*;
import java.util.*;
import javax.imageio.ImageIO;

/**
This plugin implements the File/Save As/AVI command.
Supported formats:
  Uncompressed 8-bit (gray or indexed color), 24-bit (RGB),
  JPEG and PNG compression of individual frames
  16-bit and 32-bit (float) images are converted to 8-bit
The plugin is based on the FileAvi class written by William Gandler,
part of Matthew J. McAuliffe's MIPAV program, available from
http://mipav.cit.nih.gov/.
2008-06-05: Support for jpeg and png-compressed output and
composite images by Michael Schmid.
2015-09-28: Writes AVI 2.0 if the file size would be above approx. 0.9 GB

* The AVI format written looks like this:
* RIFF AVI            RIFF HEADER, AVI CHUNK					
*   | LIST hdrl       MAIN AVI HEADER
*   | | avih          AVI HEADER
*   | | LIST strl     STREAM LIST(s) (One per stream)
*   | | | strh        STREAM HEADER (Required after above; fourcc type is 'vids' for video stream)
*   | | | strf        STREAM FORMAT (for video: BitMapInfo; may also contain palette)
*   | | | strn        STREAM NAME
*   | | | indx        MAIN 'AVI 2.0' INDEX of 'ix00' indices
*   | LIST movi       MOVIE DATA (maximum approx. 0.95 GB)
*   | | 00db or 00dc  FRAME (b=uncompressed, c=compressed)
*   | | 00db or 00dc  FRAME
*   | | ...
*   | | ix00          AVI 2.0-style index of frames within this 'movi' list
* RIFF AVIX	          Only if required by size (this is AVI 2.0 extension)
*   | LIST movi       MOVIE DATA (maximum approx. 0.95 GB)
*   | | 00db or 00dc  FRAME
*   | | ...
*   | | ix00          AVI 2.0-style index of frames within this 'movi' list
* RIFF AVIX	          further chunks, each approx 0.95 GB (AVI 2.0)
* ...
*/

public class AVI_Writer implements PlugInFilter {
    //four-character codes for compression
    // Note: byte sequence in four-cc is reversed - ints in Intel (little endian) byte order.
    // Note that compression codes BI_JPEG=4 and BI_PNG=5 are not understood by avi players
    // (even not by MediaPlayer, even though these codes are specified by Microsoft).
    public final static int  NO_COMPRESSION   = 0;            //no compression, also named BITMAPINFO.BI_RGB
    public final static int  JPEG_COMPRESSION = 0x47504a4d;   //'MJPG' JPEG compression of individual frames
    public final static int  PNG_COMPRESSION  = 0x20676e70;   //'png ' PNG compression of individual frames
    private final static int FOURCC_00db = 0x62643030;        //'00db' uncompressed frame
    private final static int FOURCC_00dc = 0x63643030;        //'00dc' compressed frame
    private final static int MAX_INDX_SIZE = 3072;            //max length of index of indices 'indx'
    private final static int JUNK_SIZE_THRESHOLD = 950*1024*1024;   //if size exceeds this, makes a new RIFF AVIX chunk
    //compression options: dialog parameters
    private int      compressionIndex = 2; //0=none, 1=PNG, 2=JPEG
    private static int      jpegQuality = 90;    //0 is worst, 100 best (not currently used)
    private final static String[] COMPRESSION_STRINGS = new String[] {"Uncompressed", "PNG", "JPEG"};
    private final static int[] COMPRESSION_TYPES = new int[] {NO_COMPRESSION, PNG_COMPRESSION, JPEG_COMPRESSION};

    private ImagePlus imp;
    private RandomAccessFile raFile;
    private int             xDim,yDim;      //image size
    private int             zDim;           //number of movie frames (stack size)
    private int             bytesPerPixel;  //8 or 24
    private int             frameDataSize;  //in bytes (uncompressed)
    private int             biCompression;  //compression type (0, 'JPEG, 'PNG')
    private int             linePad;        //no. of bytes to add for padding of data lines to 4*n length
    private byte[]          bufferWrite;    //output buffer for image data
    private BufferedImage   bufferedImage;  //data source for writing compressed images
    private RaOutputStream  raOutputStream; //output stream for writing compressed images
    private long[]          sizePointers =  //a stack of the pointers to the chunk sizes (pointers are
                                new long[5];//  remembered to write the sizes later, when they are known)
    private int             stackPointer;   //points to first free position in sizePointers stack
    private int             endHeadPointer; //position of first 'movi' chunk, i.e., end of the space reserved for indx
    // AVI-2 related:
    private long            pointer2indx;   //points to main index-of-indices 'indx'
    private int             nIndxEntries=0; //number of 'indx' entries
    private long            pointer2indxNEntriesInUse;  //points to 'nEntriesInUse' of 'indx'
    private long            pointer2indxNextEntry;   //points to next free slot of 'indx'

    public int setup(String arg, ImagePlus imp) {
        this.imp = imp;
        return DOES_ALL+NO_CHANGES;
    }

    /** Asks for the compression type and filename; then saves as AVI file */
    public void run(ImageProcessor ip) {
        if (!showDialog(imp)) return;          //compression type dialog
        SaveDialog sd = new SaveDialog("Save as AVI...", imp.getTitle(), ".avi");
        String fileName = sd.getFileName();
        if (fileName == null)
            return;
        String fileDir = sd.getDirectory();
        FileInfo fi = imp.getOriginalFileInfo();
        if (fi!=null && imp.getStack().isVirtual() && fileDir.equals(fi.directory) && fileName.equals(fi.fileName)) {
            IJ.error("AVI Writer", "Virtual stacks cannot be saved in place.");
            return;
        }
        try {
            writeImage(imp, fileDir + fileName, COMPRESSION_TYPES[compressionIndex], jpegQuality);
            IJ.showStatus("");
        } catch (IOException e) {
            IJ.error("AVI Writer", "An error occured writing the file.\n \n" + e);
        }
        IJ.showStatus("");
    }

    private boolean showDialog(ImagePlus imp) {
    	String options = Macro.getOptions();
    	if (options!=null && options.indexOf("compression=")==-1)
    		Macro.setOptions("compression=Uncompressed "+options);
  		double fps = getFrameRate(imp);
 		int decimalPlaces = (int) fps == fps?0:1;
        GenericDialog gd = new GenericDialog("Save as AVI...");
        gd.addChoice("Compression:", COMPRESSION_STRINGS, COMPRESSION_STRINGS[compressionIndex]);
        //gd.addNumericField("JPEG Quality (0-100):", jpegQuality, 0, 3, "");
		gd.addNumericField("Frame Rate:", fps, decimalPlaces, 3, "fps");
        gd.showDialog();                            // user input (or reading from macro) happens here
        if (gd.wasCanceled())                       // dialog cancelled?
            return false;
        gd.setSmartRecording(compressionIndex==2);
        compressionIndex = gd.getNextChoiceIndex();
        gd.setSmartRecording(false);
        //jpegQuality = (int)gd.getNextNumber();
        fps = gd.getNextNumber();
        if (fps<=0.5) fps = 0.5;
        //if (fps>60.0) fps = 60.0;
		imp.getCalibration().fps = fps;
		return true;
    }

    /** Writes an ImagePlus (stack) as AVI file. */
    public void writeImage (ImagePlus imp, String path, int compression, int jpegQuality)
            throws IOException {
        if (compression!=NO_COMPRESSION && compression!=JPEG_COMPRESSION && compression!=PNG_COMPRESSION)
            throw new IllegalArgumentException("Unsupported Compression 0x"+Integer.toHexString(compression));
        this.biCompression = compression;
        if (jpegQuality < 0) jpegQuality = 0;
        if (jpegQuality > 100) jpegQuality = 100;
        this.jpegQuality = jpegQuality;
        File file = new File(path);
        raFile = new RandomAccessFile(file, "rw");
        raFile.setLength(0);
        imp.startTiming();

        //  G e t   s t a c k   p r o p e r t i e s
        boolean isComposite = imp.isComposite();
        boolean isHyperstack = imp.isHyperStack();
        boolean isOverlay = imp.getOverlay()!=null && !imp.getHideOverlay();
        xDim = imp.getWidth();   //image width
        yDim = imp.getHeight();   //image height
        zDim = imp.getStackSize(); //number of frames in video
		boolean saveFrames=false, saveSlices=false, saveChannels=false;
        int channels = imp.getNChannels();
		int slices = imp.getNSlices();
		int frames = imp.getNFrames();
		int channel = imp.getChannel();
		int slice = imp.getSlice();
		int frame = imp.getFrame();
		if (isHyperstack || isComposite) {
			if (frames>1) {
				saveFrames = true;
				zDim = frames;
			} else if (slices>1) {
				saveSlices = true;
				zDim = slices;
			} else if (channels>1) {
				saveChannels = true;
				zDim = channels;
			} else
				isHyperstack = false;
		}

        if (imp.getType()==ImagePlus.COLOR_RGB || isComposite || biCompression==JPEG_COMPRESSION || isOverlay)
            bytesPerPixel = 3;  //color and JPEG-compressed files
        else
            bytesPerPixel = 1;  //gray 8, 16, 32 bit and indexed color: all written as 8 bit
        boolean writeLUT = bytesPerPixel==1; // QuickTime reads the avi palette also for PNG
        linePad = 0;
        int minLineLength = bytesPerPixel*xDim;
        if (biCompression==NO_COMPRESSION && minLineLength%4!=0)
            linePad = 4 - minLineLength%4; //uncompressed lines written must be a multiple of 4 bytes
        frameDataSize = (bytesPerPixel*xDim+linePad)*yDim;
        int microSecPerFrame = (int)Math.round((1.0/getFrameRate(imp))*1.0e6);
        int dwChunkId = biCompression==NO_COMPRESSION ? FOURCC_00db : FOURCC_00dc;
        long sizeEstimate = bytesPerPixel*xDim*yDim*(long)zDim;
        int nAvixChunksEstimate = (int)(sizeEstimate/JUNK_SIZE_THRESHOLD);  //estimated number of AVIX junks
        endHeadPointer = 4096+((nAvixChunksEstimate*16+1000)/1024)*1024;       //reserve plenty of space for 'indx'

        //  W r i t e   A V I   f i l e   h e a d e r
        writeString("RIFF");    // signature
        chunkSizeHere();        // size of file (nesting level 0)
        writeString("AVI ");    // RIFF type
        writeString("LIST");    // first LIST chunk, which contains information on data decoding
        chunkSizeHere();        // size of LIST (nesting level 1)
        writeString("hdrl");    // LIST chunk type
        writeString("avih");    // Write the avih sub-CHUNK
        writeInt(0x38);         // length of the avih sub-CHUNK (38H) not including the
                                // the first 8 bytes for avihSignature and the length
        writeInt(microSecPerFrame); // dwMicroSecPerFrame - Write the microseconds per frame
        writeInt(0);            // dwMaxBytesPerSec (maximum data rate of the file in bytes per second)
        writeInt(0);            // dwReserved1 - Reserved1 field set to zero
        writeInt(0x10);         // dwFlags - just set the bit for AVIF_HASINDEX
                                //   10H AVIF_HASINDEX: The AVI file has an idx1 chunk containing
                                //   an index at the end of the file.  For good performance, all
                                //   AVI files should contain an index.
        writeInt(zDim);         // dwTotalFrames - total frame number
        writeInt(0);            // dwInitialFrames -Initial frame for interleaved files.
                                // Noninterleaved files should specify 0.
        writeInt(1);            // dwStreams - number of streams in the file - here 1 video and zero audio.
        writeInt(0);      // dwSuggestedBufferSize 
         writeInt(xDim);         // dwWidth - image width in pixels
        writeInt(yDim);         // dwHeight - image height in pixels
        writeInt(0);            // dwReserved[4]
        writeInt(0);
        writeInt(0);
        writeInt(0);

        //  W r i t e   s t r e a m   i n f o r m a t i o n
        writeString("LIST");    // List of stream headers
        chunkSizeHere();        // size of LIST (nesting level 2)
        writeString("strl");    // LIST chunk type: stream list
        writeString("strh");    // stream header 
        writeInt(56);           // Write the length of the strh sub-CHUNK
        writeString("vids");    // fccType - type of data stream - here 'vids' for video stream
        writeString("DIB ");    // 'DIB ' for Microsoft Device Independent Bitmap.
        writeInt(0);            // dwFlags
        writeInt(0);            // wPriority, wLanguage
        writeInt(0);            // dwInitialFrames
        writeInt(1);            // dwScale
        writeInt((int)Math.round(getFrameRate(imp))); //  dwRate - frame rate for video streams
        writeInt(0);            // dwStart - this field is usually set to zero
        writeInt(zDim);         // dwLength - playing time of AVI file as defined by scale and rate
                                // Set equal to the number of frames
        writeInt(0);            // dwSuggestedBufferSize for reading the stream.
                                // Typically, this contains a value corresponding to the largest chunk
                                // in a stream.
        writeInt(-1);           // dwQuality - encoding quality given by an integer between
                                // 0 and 10,000.  If set to -1, drivers use the default
                                // quality value.
        writeInt(0);            // dwSampleSize. 0 means that each frame is in its own chunk
        writeShort((short)0);   // left of rcFrame if stream has a different size than dwWidth*dwHeight(unused)
        writeShort((short)0);   // top
        writeShort((short)0);   // right
        writeShort((short)0);   // bottom
        // end of 'strh' chunk, stream format follows
        writeString("strf");    // stream format chunk
        chunkSizeHere();        // size of 'strf' chunk (nesting level 3)
        writeInt(40);           // biSize - Write header size of BITMAPINFO header structure
                                // Applications should use this size to determine which BITMAPINFO header structure is
                                // being used.  This size includes this biSize field.
        writeInt(xDim);         // biWidth - width in pixels
        writeInt(yDim);         // biHeight - image height in pixels. (May be negative for uncompressed
                                // video to indicate vertical flip).
        writeShort(1);          // biPlanes - number of color planes in which the data is stored
        writeShort((short)(8*bytesPerPixel)); // biBitCount - number of bits per pixel #
        writeInt(biCompression); // biCompression - type of compression used (uncompressed: NO_COMPRESSION=0)
        int biSizeImage =       // Image Buffer. Quicktime needs 3 bytes also for 8-bit png
                (biCompression==NO_COMPRESSION)?0:xDim*yDim*bytesPerPixel;
        writeInt(biSizeImage);  // biSizeImage (buffer size for decompressed mage) may be 0 for uncompressed data
        writeInt(0);            // biXPelsPerMeter - horizontal resolution in pixels per meter
        writeInt(0);            // biYPelsPerMeter - vertical resolution in pixels per meter
        writeInt(writeLUT ? 256:0); // biClrUsed (color table size; for 8-bit only)
        writeInt(0);            // biClrImportant - specifies that the first x colors of the color table
                                // are important to the DIB.  If the rest of the colors are not available,
                                // the image still retains its meaning in an acceptable manner.  When this
                                // field is set to zero, all the colors are important, or, rather, their
                                // relative importance has not been computed.
        if (writeLUT)           // write color lookup table
            writeLUT(imp.getProcessor());
        chunkEndWriteSize();    //'strf' chunk finished (nesting level 3)
        
        writeString("strn");    // Use 'strn' to provide a zero terminated text string describing the stream
        writeInt(16);           // length of the strn sub-CHUNK (must be even)
        writeString("ImageJ AVI     \0"); //must be 16 bytes as given above (including the terminating 0 byte)
        pointer2indx = raFile.getFilePointer();
        writeString("indx");    // 'indx' chunk type: Index of indices
        chunkSizeHere();        // size of 'indx' (nesting level 3)
        writeShort(4);          // wLongsPerEntry = 4 ('Longs' are 32-bit here!)
        writeByte(0);           // bIndexSubType=0
        writeByte(0);           // bIndexType=0: AVI_INDEX_OF_INDEXES
        pointer2indxNEntriesInUse = raFile.getFilePointer();
        writeInt(0);            // nEntriesInUse, will be filled in later
        writeInt(dwChunkId);    // dwChunkId, '00dc' or '00db'
        writeInt(0); writeInt(0); writeInt(0); // dwReserved[3]
        pointer2indxNextEntry = raFile.getFilePointer();
        chunkEndWriteSize();    //'indx' chunk finished (nesting level 3), will be modified by writeMainIndxEntry
        writeString("JUNK");    // write a JUNK chunk for padding (will be moved and shortened by writeMainIndxEntry)
        chunkSizeHere();        // size of 'JUNK' for padding (nesting level 3)
        raFile.seek(endHeadPointer);      // we continue here
        chunkEndWriteSize();    // 'JUNK' finished (nesting level 3)
        chunkEndWriteSize();    // LIST 'strl' finished (nesting level 2)
        chunkEndWriteSize();    // LIST 'hdrl' finished (nesting level 1)

        //  P r e p a r e   f o r   w r i t i n g   d a t a
        if (biCompression == NO_COMPRESSION)
            bufferWrite = new byte[frameDataSize];
        else
            raOutputStream = new RaOutputStream(raFile); //needed for writing compressed formats
        //int maxChunkLength = 0;                 // needed for dwSuggestedBufferSize
        int[] dataChunkOffset = new int[zDim];  // remember chunk positions...
        int[] dataChunkLength = new int[zDim];  // ... and sizes for the index

        int currentFilePart = 0;// 0 is inside RIFF AVI (AVI 1.0 compatible), >0 is RIFF AVIX (data chunk of AVI 2.0)

        //  W r i t e   f r a m e   d a t a   a n d   i n d i c e s
        int iFrame = 0;
        while (iFrame < zDim) {
            if (currentFilePart > 0) {  // open new RIFF AVIX chunk
                writeString("RIFF");
                chunkSizeHere();        // size of chunk (nesting level 0)
                writeString("AVIX");    // RIFF type
                //IJ.log("AVIX starts at iFrame="+iFrame);
            }
            writeString("LIST");        // this LIST chunk contains the AVI-2 style index and the actual data
            chunkSizeHere();            // size of LIST (nesting level 1)
            long moviPointer = raFile.getFilePointer();
            writeString("movi");        // write LIST type 'movi'

            int firstFrameInChunk = iFrame;

            //   W r i t e   s i n g l e   f r a m e
            while (iFrame<zDim) {
                if (iFrame %10==0) {
                    IJ.showProgress(iFrame, zDim);
                    IJ.showStatus(iFrame+"/"+zDim);
                }
                ImageProcessor ip = null;      // get the image to write ...
                if (isComposite || isHyperstack || isOverlay) {
                    if (saveFrames)
                        imp.setPositionWithoutUpdate(channel, slice, iFrame+1);
                    else if (saveSlices)
                        imp.setPositionWithoutUpdate(channel, iFrame+1, frame);
                    else if (saveChannels)
                        imp.setPositionWithoutUpdate(iFrame+1, slice, frame);
                    ImagePlus imp2 = imp;
                    if (isOverlay) {
                        if (!(saveFrames||saveSlices||saveChannels))
                            imp.setSliceWithoutUpdate(iFrame+1);
                        imp2 = imp.flatten();
                    }
                    ip = new ColorProcessor(imp2.getImage());
                } else
                    ip = zDim==1 ? imp.getProcessor() : imp.getStack().getProcessor(iFrame+1);
                int chunkPointer = (int)raFile.getFilePointer();
                writeInt(dwChunkId);            // start writing chunk: '00db' or '00dc'
                chunkSizeHere();                // size of '00db' or '00dc' chunk (nesting level 2)
                if (biCompression == NO_COMPRESSION) {
                    if (bytesPerPixel==1)
                        writeByteFrame(ip);
                    else
                        writeRGBFrame(ip);
                } else
                    writeCompressedFrame(ip);
                dataChunkOffset[iFrame] = (int)(chunkPointer - moviPointer);
                dataChunkLength[iFrame] = (int)(raFile.getFilePointer() - chunkPointer - 8); //size excludes '00db' and size fields
                chunkEndWriteSize();            // '00db' or '00dc' chunk finished (nesting level 2)
                //if (IJ.escapePressed()) {
                //    IJ.showStatus("Save as Avi INTERRUPTED");
                //    break;
                //}
                iFrame++;
                if (raFile.getFilePointer() - moviPointer > JUNK_SIZE_THRESHOLD)
                    break;                      // make sure we don't get over 1GB
            } // while (iFrame<zDim)
            int nFramesInChunk = iFrame - firstFrameInChunk;

            //  W r i t e   A V I - 2   I n d e x
            long ix00pointer = raFile.getFilePointer();
            writeString("ix00");        // AVI 2.0 style index of frames within the chunk
            chunkSizeHere();            // size of ix00 chunk (nesting level 2)
            writeShort(2);              // wLongsPerEntry = 2 ('Longs' are 32-bit here!)
            writeByte(0);               // bIndexSubType=0
            writeByte(1);               // bIndexType=1: AVI_INDEX_OF_CHUNKS
            writeInt(nFramesInChunk);   // nEntriesInUse
            writeInt(dwChunkId);        // dwChunkId, '00dc' or '00db'
            writeLong(moviPointer);     // qwBaseOffset
            writeInt(0);                // dwReserved, first two are qwBaseOffset?
            for (int z=firstFrameInChunk; z<iFrame; z++) {
                writeInt(dataChunkOffset[z]+8); //note: AVI--2 index points to chunk data, not chunk header
                writeInt(dataChunkLength[z]);   //length without chunk header
            }
            //IJ.log("write ix00: frames "+firstFrameInChunk+"-"+(iFrame-1)+" offset "+Long.toHexString(dataChunkOffset[firstFrameInChunk])+"-"+Long.toHexString(dataChunkOffset[iFrame-1]));
            //enter this ix00 index to index of indices:
            writeMainIndxEntry(ix00pointer, (int)(raFile.getFilePointer()-ix00pointer), nFramesInChunk);

            chunkEndWriteSize();        // 'ix00' finished (nesting level 2)
            chunkEndWriteSize();        // LIST 'movi' finished (nesting level 1)

            //  W r i t e   A V I - 1   I n d e x
            if (currentFilePart == 0) {
                writeString("idx1");    // Write the idx1 chunk
                chunkSizeHere();        // size of 'idx1' chunk (nesting level 1)
                for (int z = 0; z < iFrame; z++) {
                    writeInt(dwChunkId);// ckid field: '00db' or '00dc'
                    writeInt(0x10);     // flags: select AVIIF_KEYFRAME
                                 // AVIIF_KEYFRAME 0x00000010
                                 // The flag indicates key frames in the video sequence.
                                 // Key frames do not need previous video information to be decompressed.
                                 // AVIIF_NOTIME 0x00000100 The CHUNK does not influence video timing (for
                                 //   example a palette change CHUNK).
                                 // AVIIF_LIST 0x00000001 marks a LIST CHUNK.
                                 // AVIIF_TWOCC 2L
                                 // AVIIF_COMPUSE 0x0FFF0000 These bits are for compressor use.
                     writeInt(dataChunkOffset[z]); // offset to the chunk header (not data)
                                 // offset can be relative to file start or 'movi'
                     writeInt(dataChunkLength[z]); // length without chunk header
                }  // for (z = 0; z < zDim; z++)
                chunkEndWriteSize();    // 'idx1' finished (nesting level 1)
            }
            chunkEndWriteSize();    // 'RIFF' File finished (nesting level 0)
            currentFilePart++;
        } //while (iFrame < zDim)
        raFile.close();
        IJ.showProgress(1.0);
		if (isComposite || isHyperstack)
			imp.setPosition(channel, slice, frame);
    }

    /** Reserve space to write the size of chunk and remember the position
     *  for a later call to chunkEndWriteSize().
     *  Several levels of chunkSizeHere() and chunkEndWriteSize() may be nested.
     */
    private void chunkSizeHere() throws IOException {
        sizePointers[stackPointer] = raFile.getFilePointer();
        writeInt(0);    //for now, write 0 to reserve space for "size" item
        stackPointer++;
    }
    
    /** At the end of a chunk, calculate its size and write it to the
     *  position remembered previously. Also pads to 2-byte boundaries.
     */
    private void chunkEndWriteSize() throws IOException {
        stackPointer--;
        long position = raFile.getFilePointer();
        raFile.seek(sizePointers[stackPointer]);
        writeInt((int)(position - (sizePointers[stackPointer]+4)));
        raFile.seek(((position+1)/2)*2);    //pad to 2-byte boundary
        //IJ.log("chunk at 0x"+Long.toHexString(sizePointers[stackPointer]-4)+"-0x"+Long.toHexString(position));
    }

    /** Enter a local index 'ix00' to 'indx', the index of indices */
    private void writeMainIndxEntry(long ix00pointer, int dwSize, int nFrames) throws IOException {
        if (pointer2indxNextEntry + 16 + 8 > MAX_INDX_SIZE) {
            raFile.close();
            throw new RuntimeException("AVI_Writer ERROR: Index Size Overflow");
        }
        long savePosition = raFile.getFilePointer();
        raFile.seek(pointer2indxNextEntry);
        writeLong(ix00pointer);
        writeInt(dwSize);
        writeInt(nFrames);
        pointer2indxNextEntry += 16;
        nIndxEntries++;
        writeString("JUNK");        // write a JUNK chunk for padding
        chunkSizeHere();            // size of 'JUNK' for padding goes here
        raFile.seek(endHeadPointer);// end of the padded range
        chunkEndWriteSize();        // 'JUNK' finished (nesting level 3)
        raFile.seek(pointer2indx+4);
        writeInt((int)(pointer2indxNextEntry - pointer2indx - 8)); //write new size of 'indx'
        raFile.seek(pointer2indxNEntriesInUse);
        writeInt(nIndxEntries);     //write new number of 'indx' entries
        raFile.seek(savePosition);
    }

    /** Write Grayscale (or indexed color) data. Lines are  
     *  padded to a length that is a multiple of 4 bytes. */
    private void writeByteFrame(ImageProcessor ip) throws IOException {
        ip = ip.convertToByte(true);
        byte[] pixels = (byte[])ip.getPixels();
        int width = ip.getWidth();
        int height = ip.getHeight();
        int c, offset, index = 0;
        for (int y=height-1; y>=0; y--) {
            offset = y*width;
            for (int x=0; x<width; x++)
                bufferWrite[index++] = pixels[offset++];
            for (int i = 0; i<linePad; i++)
                bufferWrite[index++] = (byte)0;
        }
        raFile.write(bufferWrite);
    }

    /** Write RGB data. Each 3-byte triplet in the bitmap array represents
     *  blue, green, and red, respectively, for a pixel.  The color bytes are
     *  in reverse order (Windows convention). Lines are padded to a length
     *  that is a multiple of 4 bytes. */
    private void writeRGBFrame(ImageProcessor ip) throws IOException {
        ip = ip.convertToRGB();
        int[] pixels = (int[])ip.getPixels();
        int width = ip.getWidth();
        int height = ip.getHeight();
        int c, offset, index = 0;
        for (int y=height-1; y>=0; y--) {
            offset = y*width;
            for (int x=0; x<width; x++) {
                c = pixels[offset++];
                bufferWrite[index++] = (byte)(c&0xff); // blue
                bufferWrite[index++] = (byte)((c&0xff00)>>8); //green
                bufferWrite[index++] = (byte)((c&0xff0000)>>16); // red
            }
            for (int i = 0; i<linePad; i++)
                bufferWrite[index++] = (byte)0;
        }
        raFile.write(bufferWrite);
    }

    /** Write a frame as jpeg- or png-compressed image */
	private void writeCompressedFrame(ImageProcessor ip) throws IOException {
		//IJ.log("BufferdImage Type="+bufferedImage.getType()); // 1=RGB, 13=indexed
		if (biCompression==JPEG_COMPRESSION) {
			BufferedImage bi = getBufferedImage(ip);
			ImageIO.write(bi, "jpeg", raOutputStream);
		} else { //if (biCompression==PNG_COMPRESSION) {
			BufferedImage bi = ip.getBufferedImage();
			ImageIO.write(bi, "png", raOutputStream);
		}
	}

	private BufferedImage getBufferedImage(ImageProcessor ip) {
		BufferedImage bi = new BufferedImage(ip.getWidth(), ip.getHeight(), BufferedImage.TYPE_INT_RGB);
		Graphics2D g = (Graphics2D)bi.getGraphics();
		g.drawImage(ip.createImage(), 0, 0, null);
		return bi;
	}

    /** Write the color table entries (for 8 bit grayscale or indexed color).
     *  Byte order or LUT entries: blue byte, green byte, red byte, 0 byte */
    private void writeLUT(ImageProcessor ip) throws IOException {
        IndexColorModel cm = (IndexColorModel)(ip.getCurrentColorModel());
        int mapSize = cm.getMapSize();
        byte[] lutWrite = new byte[4*256];
        for (int i = 0; i<256; i++) {
            if (i<mapSize) {
                lutWrite[4*i] = (byte)cm.getBlue(i);
                lutWrite[4*i+1] = (byte)cm.getGreen(i);
                lutWrite[4*i+2] = (byte)cm.getRed(i);
                lutWrite[4*i+3] = (byte)0;
            }
        }
        raFile.write(lutWrite);
    }

    private double getFrameRate(ImagePlus imp) {
        double rate = imp.getCalibration().fps;
        if (rate==0.0)
            rate = Animator.getFrameRate();
        if (rate<=0.5) rate = 0.5;
        //if (rate>60.0) rate = 60.0;
        return rate;
    }

    private void writeString(String s) throws IOException {
        byte[] bytes =  s.getBytes("UTF8");
        raFile.write(bytes);
    }

    /** Write 8-byte int with Intel (little-endian) byte order
     * (note: RandomAccessFile.writeInt has other byte order than AVI) */
    private void writeLong(long v) throws IOException {
        for (int i=0; i<8; i++) {
            raFile.write((int)(v & 0xFFL));
            v = v>>>8;
        }
        //IJ.log("long: 0x"+Long.toHexString(v)+"="+v);
    }

    /** Write 4-byte int with Intel (little-endian) byte order
     * (note: RandomAccessFile.writeInt has other byte order than AVI) */
    private void writeInt(int v) throws IOException {
        raFile.write(v & 0xFF);
        raFile.write((v >>>  8) & 0xFF);
        raFile.write((v >>> 16) & 0xFF);
        raFile.write((v >>> 24) & 0xFF);
        //IJ.log("int: 0x"+Integer.toHexString(v)+"="+v);
    }

    /** Write 2-byte short with Intel (little-endian) byte order
     * (note: RandomAccessFile.writeShort has other byte order than AVI) */
    private void writeShort(int v) throws IOException {
        raFile.write(v & 0xFF);
        raFile.write((v >>> 8) & 0xFF);
    }

    /** Write a byte */
    private void writeByte(int v) throws IOException {
        raFile.write(v & 0xFF);
    }

    /** An output stream directed to a RandomAccessFile (starting at the current position) */
    class RaOutputStream extends OutputStream {
        RandomAccessFile raFile;
        RaOutputStream (RandomAccessFile raFile) {
            this.raFile = raFile;
        }
        public void write (int b) throws IOException {
            //IJ.log("stream: byte");
            raFile.writeByte(b); //just for completeness, usually not used by image encoders
        }
        public void write (byte[] b) throws IOException {
            //IJ.log("stream: array len="+b.length);
            raFile.write(b);
        }
        public void write (byte[] b, int off, int len) throws IOException {
            //IJ.log("stream: array="+b.length+" off="+off+" len="+len);
            raFile.write(b, off, len);
        }
    }

}
