/*
 * License Applicability. Except to the extent portions of this file are
 * made subject to an alternative license as permitted in the SGI Free
 * Software License B, Version 1.1 (the "License"), the contents of this
 * file are subject only to the provisions of the License. You may not use
 * this file except in compliance with the License. You may obtain a copy
 * of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
 * Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
 * 
 * http://oss.sgi.com/projects/FreeB
 * 
 * Note that, as provided in the License, the Software is distributed on an
 * "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
 * DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
 * CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
 * PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
 * 
 * Original Code. The Original Code is: OpenGL Sample Implementation,
 * Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
 * Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
 * Copyright in any portions created by third parties is as indicated
 * elsewhere herein. All Rights Reserved.
 * 
 * Additional Notice Provisions: The application programming interfaces
 * established by SGI in conjunction with the Original Code are The
 * OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
 * April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
 * 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
 * Window System(R) (Version 1.3), released October 19, 1998. This software
 * was created using the OpenGL(R) version 1.2.1 Sample Implementation
 * published by SGI, but has not been independently verified as being
 * compliant with the OpenGL(R) version 1.2.1 Specification.
 */

package net.java.games.jogl.impl.mipmap;

import net.java.games.jogl.GL;
import java.nio.*;

/**
 *
 * @author  Administrator
 */
public class HalveImage {
  
  private static final int BOX2 = 2;
  private static final int BOX4 = 4;
  private static final int BOX8 = 8;
  
  public static void halveImage( int components, int width, int height,
          ShortBuffer datain, ShortBuffer dataout ) {
    int i, j, k;
    int newwidth, newheight;
    int delta;
    int t = 0;
    short temp = 0;
    
    newwidth = width / 2;
    newheight = height /2;
    delta = width * components;
    
    // Piece of cake
    for( i = 0; i < newheight; i++ ) {
      for( j = 0; j < newwidth; j++ ) {
        for( k = 0; k < components; k++ ) {
          datain.position( t );
          temp = datain.get();
          datain.position( t + components );
          temp += datain.get();
          datain.position( t + delta );
          temp += datain.get();
          datain.position( t + delta + components );
          temp +=datain.get();
          temp += 2;
          temp /= 4;
          dataout.put( temp );
          t++;
        }
        t += components;
      }
      t += delta;
    }
  }
  
  public static void halveImage_ubyte( int components, int width, int height,
                                      ByteBuffer datain, ByteBuffer dataout,
                                      int element_size, int ysize, int group_size ) {
    int i, j, k;
    int newwidth, newheight;
    int s;
    int t;
    
    // Handle case where there is only 1 column/row
    if( width == 1 || height == 1 ) {
      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
      halve1Dimage_ubyte( components, width, height, datain, dataout, element_size, ysize, group_size );
      return;
    }
    
    newwidth = width / 2;
    newheight = height / 2;
    s = 0;
    t = 0;
    
    int temp = 0;
    // piece of cake
    for( i = 0; i < newheight; i++ ) {
      for( j = 0; j < newwidth; j++ ) {
        for( k = 0; k < components; k++ ) {
          datain.position( t );
          temp = ( 0x000000FF & datain.get() );
          datain.position( t + group_size );
          temp += ( 0x000000FF & datain.get() );
          datain.position( t + ysize );
          temp += ( 0x000000FF & datain.get() );
          datain.position( t + ysize + group_size );
          temp += ( 0x000000FF & datain.get() ) + 2;
          dataout.put( (byte)(temp / 4) );
          t += element_size;
        }
        t += group_size;
      }
      t += ysize;
    }
  }
  
  public static void halve1Dimage_ubyte( int components, int width, int height,
                      ByteBuffer datain, ByteBuffer dataout, 
                      int element_size, int ysize, int group_size ) {
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int src = 0;
    int dest = 0;
    int jj;
    int temp = 0;
    
    assert( width == 1 || height == 1 ); // Must be 1D
    assert( width != height ); // can't be square
    
    if( height == 1 ) { // 1 row
      assert( width != 1 ); // widthxheight can't be 1x1
      halfHeight = 1;
      
      for( jj = 0; jj < halfWidth; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          datain.position( src );
          temp = ( 0x000000FF & datain.get() );
          datain.position( src + group_size );
          temp += ( 0x000000FF & datain.get() );
          temp /= 2;
          dataout.put( (byte)temp );
          /*
          dataout.setByte( (byte)(((0x000000FF & datain.setIndexInBytes(src).getByte()) + 
                    (0x000000FF & datain.setIndexInBytes( src + group_size ).getByte())) / 2 ) );
           */
          src += element_size;
          //dataout.plusPlus();
          dest++;
        }
        src += group_size; // skip to next 2
      }
      int padBytes = ysize - ( width * group_size );
      src += padBytes; // for assertion only
    } else if( width == 1 ) { // 1 column
      int padBytes = ysize - ( width * group_size );
      assert( height != 1 );
      halfWidth = 1;
      // one vertical column with possible pad bytes per row
      // average two at a time
      for( jj = 0; jj < halfHeight; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          datain.position( src );
          temp = ( 0x000000FF & datain.get() );
          datain.position( src + ysize );
          temp += ( 0x000000FF & datain.get() );
          temp /= 2;
          dataout.put( (byte)temp );
          /*
          dataout.setByte( (byte)(((0x000000FF & datain.setIndexInBytes(src).getByte()) + 
                    (0x000000FF & datain.setIndexInBytes(src + ysize).getByte()) ) / 2 ) );
           */
          src += element_size;
          //dataout.plusPlus();
          dest++;
        }
        src += padBytes; // add pad bytes, if any, to get to end of row
        src += ysize;
      }
    }
    assert( src == ysize * height );
    assert( dest == components * element_size * halfWidth * halfHeight );
  }
  
  public static void halveImage_byte( int components, int width, int height,
                    ByteBuffer datain, ByteBuffer dataout, int element_size,
                    int ysize, int group_size ) {
    int i, j, k;
    int newwidth, newheight;
    int s = 0;
    int t = 0;
    byte temp = (byte)0;
    
    // handle case where there is only 1 column
    if( width == 1 || height == 1 ) {
      assert( !( width == 1 && height == 1 ) );
      halve1Dimage_byte( components, width, height, datain, dataout, element_size,
                                                            ysize, group_size );
      return;
    }
    
    newwidth = width / 2;
    newheight = height / 2;
    
    for( i = 0; i < newheight; i++ ) {
      for( j = 0; j < newwidth; j++ ) {
        for( k = 0; k < components; k++ ) {
          datain.position( t );
          temp = datain.get();
          datain.position( t + group_size );
          temp += datain.get();
          datain.position( t + ysize );
          temp += datain.get();
          datain.position( t + ysize + group_size );
          temp += datain.get();
          temp += 2;
          temp /= 4;
          dataout.put( temp );
          t += element_size;
        }
        t += group_size;
      }
      t += ysize;
    }
  }
  
  public static void halve1Dimage_byte( int components, int width, int height,
                      ByteBuffer datain, ByteBuffer dataout,
                      int element_size, int ysize, int group_size ) {
    int halfWidth = width / 2;
    int halfHeight = width / 2;
    int src = 0;
    int dest = 0;
    int jj;
    byte temp = (byte)0;
    
    assert( width == 1 || height == 1 ); // must be 1D
    assert( width != height ); // can't be square
    
    if( height == 1 ) { // 1 row
      assert( width != 1 ); // widthxheight can't be 1
      halfHeight = 1;
      
      for( jj = 0; jj < halfWidth; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          datain.position( src );
          temp = datain.get();
          datain.position( src + group_size );
          temp += datain.get();
          temp /= 2;
          dataout.put( temp );
          src += element_size;
          dest++;
        }
        src += group_size; // skip to next 2
      }
      int padBytes = ysize - ( width * group_size );
      src += padBytes; // for assert only
    } else if( width == 1 ) { // 1 column
      int padBytes = ysize - ( width * group_size );
      assert( height != 1 ); // widthxheight can't be 1
      halfWidth = 1;
      // one vertical column with possible pad bytes per row
      // average two at a time
      
      for( jj = 0; jj < halfHeight; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          datain.position( src );
          temp = datain.get();
          datain.position( src + ysize );
          temp += datain.get();
          temp /= 2;
          src += element_size;
          dest++;
        }
        src += padBytes; // add pad bytes, if any, to get to end of row
        src += ysize;
      }
      assert( src == ysize * height );
    }
    assert( dest == components * element_size * halfWidth * halfHeight );
  }
  
  public static void halveImage_ushort( int components, int width, int height,
                          ByteBuffer datain, ShortBuffer dataout, int element_size,
                          int ysize, int group_size, boolean myswap_bytes ) {
    int i, j, k, l;
    int newwidth, newheight;
    int s = 0;
    int t = 0;
    int temp = 0;
    // handle case where there is only 1 column/row
    if( width == 1 || height == 1 ) {
      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
      halve1Dimage_ushort( components, width, height, datain, dataout, element_size,
                                ysize, group_size, myswap_bytes );
      return;
    }
    
    newwidth = width / 2;
    newheight = height / 2;
    
    // Piece of cake
    if( !myswap_bytes ) {
      for( i = 0; i < newheight; i++ ) {
        for( j = 0; j < newwidth; j++ ) {
          for( k = 0; k < components; k++ ) {
            datain.position( t );
            temp = ( 0x0000FFFF & datain.getShort() );
            datain.position( t + group_size );
            temp += ( 0x0000FFFF & datain.getShort() );
            datain.position( t + ysize );
            temp += ( 0x0000FFFF & datain.getShort() );
            datain.position( t + ysize + group_size );
            temp += ( 0x0000FFFF & datain.getShort() );
            dataout.put( (short)( ( temp + 2 ) / 4 ) );
            t += element_size;
          }
          t += group_size;
        }
        t += ysize;
      }
    } else {
      for( i = 0; i < newheight; i++ ) {
        for( j = 0; j < newwidth; j++ ) {
          for( k = 0; k < components; k++ ) {
            datain.position( t );
            temp = ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
            datain.position( t + group_size );
            temp += ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
            datain.position( t + ysize );
            temp += ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
            datain.position( t + ysize + group_size );
            temp += ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
            dataout.put( (short)( ( temp + 2 ) / 4 ) );
            t += element_size;
          }
          t += group_size;
        }
        t += ysize;
      }
    }
  }
  
  public static void halve1Dimage_ushort( int components, int width, int height,
                      ByteBuffer datain, ShortBuffer dataout, int element_size,
                      int ysize, int group_size, boolean myswap_bytes ) {
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int src = 0;
    int dest = 0;
    int jj;
    
    assert( width == 1 || height == 1 ); // must be 1D
    assert( width != height ); // can't be square
    
    if( height == 1 ) { // 1 row
      assert( width != 1 ); // widthxheight can't be 1
      halfHeight = 1;
      
      for( jj = 0; jj < halfWidth; jj++ ) {
        int kk;
        for( kk = 0; kk < halfHeight; kk++ ) {
          int[] ushort = new int[BOX2];
          if( myswap_bytes ) {
            datain.position( src );
            ushort[0] = ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
            datain.position( src + group_size );
            ushort[1] = (0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
          } else {
            datain.position( src );
            ushort[0] = (0x0000FFFF & datain.getShort() );
            datain.position( src + group_size );
            ushort[1] = (0x0000FFFF & datain.getShort() );
          }
          dataout.put( (short)( (ushort[0] + ushort[1]) / 2 ) );
          src += element_size;
          dest += 2;
        }
        src += group_size; // skip to next 2
      }
      int padBytes = ysize - ( width * group_size );
      src += padBytes; // for assertion only
    } else if( width == 1 ) { // 1 column
      int padBytes = ysize - ( width * group_size );
      assert( height != 1 ); // widthxheight can't be 1
      halfWidth = 1;
      // one vertical column with possible pad bytes per row
      // average two at a time
      
      for( jj = 0; jj < halfHeight; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          int[] ushort = new int[BOX2];
          if( myswap_bytes ) {
            datain.position( src );
            ushort[0] = ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
            datain.position( src + ysize );
            ushort[0] = ( 0x0000FFFF & Mipmap.GLU_SWAP_2_BYTES( datain.getShort() ) );
          } else {
            datain.position( src );
            ushort[0] = ( 0x0000FFFF & datain.getShort() );
            datain.position( src + ysize );
            ushort[1] = ( 0x0000FFFF & datain.getShort() );
          }
          dataout.put( (short)((ushort[0] + ushort[1]) / 2) );
          src += element_size;
          dest += 2;
        }
        src += padBytes; // add pad bytes, if any, to get to end of row
        src += ysize;
      }
      assert( src == ysize * height );
    }
    assert( dest == components * element_size * halfWidth * halfHeight );
  }
  
  public static void halveImage_short( int components, int width, int height,
                        ByteBuffer datain, ShortBuffer dataout, int element_size,
                        int ysize, int group_size, boolean myswap_bytes ) {
    int i, j, k, l;
    int newwidth, newheight;
    int s = 0;
    int t = 0;
    short temp = (short)0;
    // handle case where there is only 1 column/row
    if( width == 1 || height == 1 ) {
      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
      halve1Dimage_short( components, width, height, datain, dataout, element_size,
                            ysize, group_size, myswap_bytes );
      return;
    }
    
    newwidth = width / 2;
    newheight = height / 2;
    
    // Piece of cake
    if( !myswap_bytes ) {
      for( i = 0; i < newheight; i++ ) {
        for( j = 0; j < newwidth; j++ ) {
          for( k = 0; k < components; k++ ) {
            datain.position( t );
            temp = datain.getShort();
            datain.position( t + group_size );
            temp += datain.getShort();
            datain.position( t + ysize );
            temp += datain.getShort();
            datain.position( t + ysize + group_size );
            temp += datain.getShort();
            temp += 2;
            temp /= 4;
            dataout.put( (short)temp );
            t += element_size;
          }
          t += group_size;
        }
        t += ysize;
      }
    } else {
      for( i = 0; i < newheight; i++ ) {
        for( j = 0; j < newwidth; j++ ) {
          for( k = 0; k < components; k++ ) {
            short b;
            int buf;
            datain.position( t );
            temp = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
            datain.position( t + group_size );
            temp += Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
            datain.position( t + ysize );
            temp += Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
            datain.position( t + ysize + group_size );
            temp += Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
            temp += 2;
            temp /= 4;
            dataout.put( temp );
            t += element_size;
          }
          t += group_size;
        }
        t += ysize;
      }
    }
  }
  
  public static void halve1Dimage_short( int components, int width, int height,
              ByteBuffer datain, ShortBuffer dataout, int element_size, int ysize,
              int group_size, boolean myswap_bytes ) {
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int src = 0;
    int dest = 0;
    int jj;
    
    assert( width == 1 || height == 1 ); // must be 1D
    assert( width != height ); // can't be square
    
    if( height == 1 ) { // 1 row
      assert( width != 1 ); // can't be 1x1
      halfHeight = 1;
      
      for( jj = 0; jj < halfWidth; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          short[] sshort = new short[BOX2];
          if( myswap_bytes ) {
            datain.position( src );
            sshort[0] = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
            datain.position( src + group_size );
            sshort[1] = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
          } else {
            datain.position( src );
            sshort[0] = datain.getShort();
            datain.position( src + group_size );
            sshort[1] = datain.getShort();
          }
          dataout.put( (short)(( sshort[0] + sshort[1] ) / 2) );
          src += element_size;
          dest += 2;
        }
        src += group_size; // skip to next 2
      }
      int padBytes = ysize - ( width * group_size );
      src += padBytes; // for assertion only
    } else if( width == 1 ) {
      int padBytes = ysize - ( width * group_size );
      assert( height != 1 );
      halfWidth = 1;
      // one vertical column with possible pad bytes per row
      // average two at a time
      
      for( jj = 0; jj < halfHeight; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          short[] sshort = new short[BOX2];
          if( myswap_bytes ) {
            datain.position( src );
            sshort[0] = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
            datain.position( src + ysize );
            sshort[1] = Mipmap.GLU_SWAP_2_BYTES( datain.getShort() );
          } else {
            datain.position( src );
            sshort[0] = datain.getShort();
            datain.position( src + ysize );
            sshort[1] = datain.getShort();
          }
          dataout.put( (short)(( sshort[0] + sshort[1] ) / 2) );
          src += element_size;
          dest += 2;
        }
        src += padBytes; // add pad bytes, if any, to get to end of row
        src += ysize;
      }
      assert( src == ysize * height );
    }
    assert( dest == ( components * element_size * halfWidth * halfHeight ) );
  }
  
  public static void halveImage_uint( int components, int width, int height,
                          ByteBuffer datain, IntBuffer dataout, int element_size,
                          int ysize, int group_size, boolean myswap_bytes ) {
    int i, j, k, l;
    int newwidth, newheight;
    int s = 0;
    int t = 0;
    double temp = 0;
    
    // handle case where there is only 1 column/row
    if( width == 1 || height == 1 ) {
      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
      halve1Dimage_uint( components, width, height, datain, dataout, element_size,
                                ysize, group_size, myswap_bytes );
      return;
    }
    
    newwidth = width / 2;
    newheight = height / 2;
    
    // Piece of cake
    if( !myswap_bytes ) {
      for( i = 0; i < newheight; i++ ) {
        for( j = 0; j < newwidth; j++ ) {
          for( k = 0; k < components; k++ ) {
            datain.position( t );
            temp = (0x000000007FFFFFFFL & datain.getInt() );
            datain.position( t + group_size );
            temp += (0x000000007FFFFFFFL & datain.getInt() );
            datain.position( t + ysize );
            temp += (0x000000007FFFFFFFL & datain.getInt() );
            datain.position( t + ysize + group_size );
            temp += (0x000000007FFFFFFFL & datain.getInt() );
            dataout.put( (int)( ( temp / 4 ) + 0.5 ) );
            t += element_size;
          }
          t += group_size;
        }
        t += ysize;
      }
    } else {
      for( i = 0; i < newheight; i++ ) {
        for( j = 0; j < newwidth; j++ ) {
          for( k = 0; k < components; k++ ) {
            // need to cast to double to hold large unsigned ints
            double buf;
            datain.position( t );
            buf = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            datain.position( t + group_size );
            buf += ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            datain.position( t + ysize );
            buf += ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            datain.position( t + ysize + group_size );
            buf += ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            temp /= 4;
            temp += 0.5;
            dataout.put( (int)temp );
            t += element_size;
          }
          t += group_size;
        }
        t += ysize;
      }
    }
  }
  
  public static void halve1Dimage_uint( int components, int width, int height,
                      ByteBuffer datain, IntBuffer dataout, int element_size, int ysize,
                      int group_size, boolean myswap_bytes ) {
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int src = 0;
    int dest = 0;
    int jj;
    
    assert( width == 1 || height == 1 ); // must be 1D
    assert( width != height ); // can't be square
    
    if( height == 1 ) { // 1 row
      assert( width != 1 ); // widthxheight can't be 1
      halfHeight = 1;
      
      for( jj = 0; jj < halfWidth; jj++ ) {
        int kk;
        for( kk = 0; kk < halfHeight; kk++ ) {
          long[] uint = new long[BOX2];
          if( myswap_bytes ) {
            datain.position( src );
            uint[0] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            datain.position( src + group_size );
            uint[1] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
          } else {
            datain.position( src );
            uint[0] = ( 0x00000000FFFFFFFF & datain.getInt() );
            datain.position( src + group_size );
            uint[1] = (0x00000000FFFFFFFF & datain.getInt() );
          }
          dataout.put( (int)( ( uint[0] + uint[1] ) / 2.0 ) );
          src += element_size;
          dest += 4;
        }
        src += group_size; // skip to next 2
      }
      int padBytes = ysize - ( width * group_size );
      src += padBytes; // for assertion only
    } else if( width == 1 ) { // 1 column
      int padBytes = ysize - ( width * group_size );
      assert( height != 1 ); // widthxheight can't be 1
      halfWidth = 1;
      // one vertical column with possible pad bytes per row
      // average two at a time
      
      for( jj = 0; jj < halfHeight; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          long[] uint = new long[BOX2];
          if( myswap_bytes ) {
            datain.position( src );
            uint[0] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            datain.position( src + group_size );
            uint[0] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
          } else {
            datain.position( src );
            uint[0] = ( 0x00000000FFFFFFFF & datain.getInt() );
            datain.position( src + ysize );
            uint[1] = ( 0x00000000FFFFFFFF & datain.getInt() );
          }
          dataout.put( (int)( ( uint[0] + uint[1] ) / 2.0 ) );
          src += element_size;
          dest += 4;
        }
        src += padBytes; // add pad bytes, if any, to get to end of row
        src += ysize;
      }
      assert( src == ysize * height );
    }
    assert( dest == components * element_size * halfWidth * halfHeight );
  }
  
  public static void halveImage_int( int components, int width, int height,
                        ByteBuffer datain, IntBuffer dataout, int element_size,
                        int ysize, int group_size, boolean myswap_bytes ) {
    int i, j, k, l;
    int newwidth, newheight;
    int s = 0;
    int t = 0;
    int temp = 0;
    
    // handle case where there is only 1 column/row
    if( width == 1 || height == 1 ) {
      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
      halve1Dimage_int( components, width, height, datain, dataout, element_size,
                            ysize, group_size, myswap_bytes );
      return;
    }
    
    newwidth = width / 2;
    newheight = height / 2;
    
    // Piece of cake
    if( !myswap_bytes ) {
      for( i = 0; i < newheight; i++ ) {
        for( j = 0; j < newwidth; j++ ) {
          for( k = 0; k < components; k++ ) {
            datain.position( t );
            temp = datain.getInt();
            datain.position( t + group_size );
            temp += datain.getInt();
            datain.position( t + ysize );
            temp += datain.getInt();
            datain.position( t + ysize + group_size );
            temp += datain.getInt();
            temp = (int)( ( temp / 4.0f ) + 0.5f );
            dataout.put( temp );
            t += element_size;
          }
          t += group_size;
        }
        t += ysize;
      }
    } else {
      for( i = 0; i < newheight; i++ ) {
        for( j = 0; j < newwidth; j++ ) {
          for( k = 0; k < components; k++ ) {
            long b;
            float buf;
            datain.position( t );
            b = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            buf = b;
            datain.position( t + group_size );
            b = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            buf += b;
            datain.position( t + ysize );
            b = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            buf += b;
            datain.position( t + ysize + group_size );
            b = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            buf += b;
            dataout.put( (int)( ( buf / 4.0f ) + 0.5f ) );
            t += element_size;
          }
          t += group_size;
        }
        t += ysize;
      }
    }
  }
  
  public static void halve1Dimage_int( int components, int width, int height,
              ByteBuffer datain, IntBuffer dataout, int element_size, int ysize,
              int group_size, boolean myswap_bytes ) {
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int src = 0;
    int dest = 0;
    int jj;
    
    assert( width == 1 || height == 1 ); // must be 1D
    assert( width != height ); // can't be square
    
    if( height == 1 ) { // 1 row
      assert( width != 1 ); // can't be 1x1
      halfHeight = 1;
      
      for( jj = 0; jj < halfWidth; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          long[] uint = new long[BOX2];
          if( myswap_bytes ) {
            datain.position( src );
            uint[0] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            datain.position( src + group_size );
            uint[1] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
          } else {
            datain.position( src );
            uint[0] = ( 0x00000000FFFFFFFF & datain.getInt() );
            datain.position( src + group_size );
            uint[1] = ( 0x00000000FFFFFFFF & datain.getInt() );
          }
          dataout.put( (int)( ( (float)uint[0] + (float)uint[1] ) / 2.0f) );
          src += element_size;
          dest += 4;
        }
        src += group_size; // skip to next 2
      }
      int padBytes = ysize - ( width * group_size );
      src += padBytes; // for assertion only
    } else if( width == 1 ) {
      int padBytes = ysize - ( width * group_size );
      assert( height != 1 );
      halfWidth = 1;
      // one vertical column with possible pad bytes per row
      // average two at a time
      
      for( jj = 0; jj < halfHeight; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          long[] uint = new long[BOX2];
          if( myswap_bytes ) {
            datain.position( src );
            uint[0] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
            datain.position( src + ysize );
            uint[1] = ( 0x00000000FFFFFFFF & Mipmap.GLU_SWAP_4_BYTES( datain.getInt() ) );
          } else {
            datain.position( src );
            uint[0] = ( 0x00000000FFFFFFFF & datain.getInt() );
            datain.position( src + ysize );
            uint[1] = ( 0x00000000FFFFFFFF & datain.getInt() );
          }
          dataout.put( (int)(( (float)uint[0] + (float)uint[1] ) / 2.0f) );
          src += element_size;
          dest += 4;
        }
        src += padBytes; // add pad bytes, if any, to get to end of row
        src += ysize;
      }
      assert( src == ysize * height );
    }
    assert( dest == ( components * element_size * halfWidth * halfHeight ) );
  }
  
  public static void halveImage_float( int components, int width, int height,
                    ByteBuffer datain, FloatBuffer dataout, int element_size,
                    int ysize, int group_size, boolean myswap_bytes ) {
    int i, j, k, l;
    int newwidth, newheight;
    int s = 0;
    int t = 0;
    float temp = 0.0f;
    // handle case where there is only 1 column/row
    if( width == 1 || height == 1 ) {
      assert( !( width == 1 && height == 1 ) ); // can't be 1x1
      halve1Dimage_float( components, width, height, datain, dataout, element_size,
                                              ysize, group_size, myswap_bytes );
      return;
    }
    
    newwidth = width / 2;
    newheight = height / 2;
    
    // Piece of cake
    if( !myswap_bytes ) {
      for( i = 0; i < newheight; i++ ) {
        for( j = 0; j < newwidth; j++ ) {
          for( k = 0; k < components; k++ ) {
            datain.position( t );
            temp = datain.getFloat();
            datain.position( t + group_size );
            temp += datain.getFloat();
            datain.position( t + ysize );
            temp += datain.getFloat();
            datain.position( t + ysize + group_size );
            temp /= 4.0f;
            dataout.put( temp );
            t += element_size;
          }
          t += group_size;
        }
        t += ysize;
      }
    } else {
      for( i = 0; i < newheight; i++ ) {
        for( j = 0; j < newwidth; j++ ) {
          for( k = 0; k < components; k++ ) {
            float buf;
            datain.position( t );
            buf = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
            datain.position( t + group_size );
            buf += Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
            datain.position( t + ysize );
            buf += Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
            datain.position( t + ysize + group_size );
            buf += Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
            dataout.put( buf / 4.0f );
            t += element_size;
          }
          t += group_size;
        }
        t += ysize;
      }
    }
  }
  
  public static void halve1Dimage_float( int components, int width, int height,
              ByteBuffer datain, FloatBuffer dataout, int element_size, int ysize,
              int group_size, boolean myswap_bytes ) {
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int src = 0;
    int dest = 0;
    int jj;
    
    assert( width == 1 || height == 1 ); // must be 1D
    assert( width != height ); // can't be square
    
    if( height == 1 ) { // 1 row
      assert( width != 1 ); // can't be 1x1
      halfHeight = 1;
      
      for( jj = 0; jj < halfWidth; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          float[] sfloat = new float[BOX2];
          if( myswap_bytes ) {
            datain.position( src );
            sfloat[0] = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
            datain.position( src + group_size );
            sfloat[1] = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
          } else {
            datain.position( src );
            sfloat[0] = datain.getFloat();
            datain.position( src + group_size );
            sfloat[1] = datain.getFloat();
          }
          dataout.put( (sfloat[0] + sfloat[1]) / 2.0f );
          src += element_size;
          dest += 4;
        }
        src += group_size; // skip to next 2
      }
      int padBytes = ysize - ( width * group_size );
      src += padBytes; // for assertion only
    } else if( width == 1 ) {
      int padBytes = ysize - ( width * group_size );
      assert( height != 1 );
      halfWidth = 1;
      // one vertical column with possible pad bytes per row
      // average two at a time
      
      for( jj = 0; jj < halfHeight; jj++ ) {
        int kk;
        for( kk = 0; kk < components; kk++ ) {
          float[] sfloat = new float[BOX2];
          if( myswap_bytes ) {
            datain.position( src );
            sfloat[0] = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
            datain.position( src + ysize );
            sfloat[1] = Mipmap.GLU_SWAP_4_BYTES( datain.getFloat() );
          } else {
            datain.position( src );
            sfloat[0] = datain.getFloat();
            datain.position( src + ysize );
            sfloat[1] = datain.getFloat();
          }
          dataout.put( ( sfloat[0] + sfloat[1] ) / 2.0f );
          src += element_size;
          dest += 4;
        }
        src += padBytes; // add pad bytes, if any, to get to end of row
        src += ysize;
      }
      assert( src == ysize * height );
    }
    assert( dest == ( components * element_size * halfWidth * halfHeight ) );
  }
  
  public static void halveImagePackedPixel( int components, Extract extract, int width, 
          int height, ByteBuffer datain, ByteBuffer dataout, 
          int pixelSizeInBytes, int rowSizeInBytes, boolean isSwap ) {
    if( width == 1 || height == 1 ) {
      assert( !( width == 1 && height == 1 ) );
      halve1DimagePackedPixel( components, extract, width, height, datain, dataout,
                          pixelSizeInBytes, rowSizeInBytes, isSwap );
      return;
    }
    int ii, jj;
    
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int src = 0;
    int padBytes = rowSizeInBytes - ( width * pixelSizeInBytes );
    int outIndex = 0;
    
    for( ii = 0; ii < halfHeight; ii++ ) {
      for( jj = 0; jj < halfWidth; jj++ ) {
        float totals[] = new float[4];
        float extractTotals[][] = new float[BOX4][4];
        int cc;
        
        datain.position( src );
        extract.extract( isSwap, datain, extractTotals[0] );
        datain.position( src + pixelSizeInBytes );
        extract.extract( isSwap, datain, extractTotals[1] );
        datain.position( src + rowSizeInBytes );
        extract.extract( isSwap, datain, extractTotals[2] );
        datain.position( src + rowSizeInBytes + pixelSizeInBytes );
        extract.extract( isSwap, datain, extractTotals[3] );
        for( cc = 0; cc < components; cc++ ) {
          int kk = 0;
          // grab 4 pixels to average
          totals[cc] = 0.0f;
          for( kk = 0; kk < BOX4; kk++ ) {
            totals[cc] += extractTotals[kk][cc];
          }
          totals[cc] /= BOX4;
        }
        extract.shove( totals, outIndex, dataout );
        outIndex++;
        src += pixelSizeInBytes + pixelSizeInBytes;
      }
      // skip past pad bytes, if any, to get to next row
      src += padBytes;
      src += rowSizeInBytes;
    }
    assert( src == rowSizeInBytes * height );
    assert( outIndex == halfWidth * halfHeight );
  }
  
  public static void halve1DimagePackedPixel( int components, Extract extract, int width,
              int height, ByteBuffer datain, ByteBuffer dataout,
              int pixelSizeInBytes, int rowSizeInBytes, boolean isSwap ) {
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int src = 0;
    int jj;
    
    assert( width == 1 || height == 1 );
    assert( width != height );
    
    if( height == 1 ) {
      int outIndex = 0;
      
      assert( width != 1 );
      halfHeight = 1;
      
      // one horizontal row with possible pad bytes
      
      for( jj = 0; jj < halfWidth; jj++ ) {
        float[] totals = new float[4];
        float[][] extractTotals = new float[BOX2][4];
        int cc;
        
        datain.position( src );
        extract.extract( isSwap, datain, extractTotals[0] );
        datain.position( src + pixelSizeInBytes );
        extract.extract( isSwap, datain, extractTotals[1] );
        for( cc = 0; cc < components; cc++ ) {
          int kk = 0;
          // grab 4 pixels to average
          totals[cc] = 0.0f;
          for( kk = 0; kk < BOX2; kk++ ) {
            totals[cc] += extractTotals[kk][cc];
          }
          totals[cc] /= BOX2;
        }
        extract.shove( totals, outIndex, dataout );
        outIndex++;
        // skip over to next group of 2
        src += pixelSizeInBytes + pixelSizeInBytes;
      }
      int padBytes = rowSizeInBytes - ( width * pixelSizeInBytes );
      src += padBytes;
      
      assert( src == rowSizeInBytes );
      assert( outIndex == halfWidth * halfHeight );
    } else if( width == 1 ) {
      int outIndex = 0;
      
      assert( height != 1 );
      halfWidth = 1;
      // one vertical volumn with possible pad bytes per row
      // average two at a time
      
      for( jj = 0; jj < halfHeight; jj++ ) {
        float[] totals = new float[4];
        float[][] extractTotals = new float[BOX2][4];
        int cc;
        // average two at a time, instead of four
        datain.position( src );
        extract.extract( isSwap, datain, extractTotals[0] );
        datain.position( src + rowSizeInBytes );
        extract.extract( isSwap, datain, extractTotals[1] );
        for( cc = 0; cc < components; cc++ ) {
          int kk = 0;
          // grab 4 pixels to average
          totals[cc] = 0.0f;
          for( kk = 0; kk < BOX2; kk++ ) {
            totals[cc] += extractTotals[kk][cc];
          }
          totals[cc] /= BOX2;
        }
        extract.shove( totals, outIndex, dataout );
        outIndex++;
        // skip over to next group of 2
        src += rowSizeInBytes + rowSizeInBytes;
      }
      assert( src == rowSizeInBytes );
      assert( outIndex == halfWidth * halfHeight );
    }
  }
  
  public static void halveImagePackedPixelSlice( int components, Extract extract,
          int width, int height, int depth, ByteBuffer dataIn,
          ByteBuffer dataOut, int pixelSizeInBytes, int rowSizeInBytes,
          int imageSizeInBytes, boolean isSwap ) {
    int ii, jj;
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int halfDepth = depth / 2;
    int src = 0;
    int padBytes = rowSizeInBytes - ( width * pixelSizeInBytes );
    int outIndex = 0;
    
    assert( (width == 1 || height == 1) && depth >= 2 );
    
    if( width == height ) {
      assert( width == 1 && height == 1 );
      assert( depth >= 2 );
      
      for( ii = 0; ii < halfDepth; ii++ ) {
        float totals[] = new float[4];
        float extractTotals[][] = new float[BOX2][4];
        int cc;
        
        dataIn.position( src );
        extract.extract( isSwap, dataIn, extractTotals[0] );
        dataIn.position( src + imageSizeInBytes );
        extract.extract( isSwap, dataIn, extractTotals[1] );
        
        for( cc = 0; cc < components; cc++ ) {
          int kk;
          
          // average only 2 pixels since a column
          totals[cc]= 0.0f;
          for( kk = 0; kk < BOX2; kk++ ) {
            totals[cc] += extractTotals[kk][cc];
          }
          totals[cc] /= BOX2;
        } // for cc
        
        extract.shove( totals, outIndex, dataOut );
        outIndex++;
        // skip over to next group of 2
        src += imageSizeInBytes + imageSizeInBytes;
      } // for ii
    } else if( height == 1 ) {
      assert( width != 1 );
      
      for( ii = 0; ii < halfDepth; ii++ ) {
        for( jj = 0; jj < halfWidth; jj++ ) {
          float totals[] = new float[4];
          float extractTotals[][] = new float[BOX4][4];
          int cc;
          
          dataIn.position( src );
          extract.extract( isSwap, dataIn, extractTotals[0] );
          dataIn.position( src + pixelSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[1] );
          dataIn.position( src + imageSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[2] );
          dataIn.position( src + pixelSizeInBytes + imageSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[3] );
          
          for( cc = 0; cc < components; cc++ ) {
            int kk;
            
            // grab 4 pixels to average
            totals[cc] = 0.0f;
            for( kk = 0; kk < BOX4; kk++ ) {
              totals[cc]+= extractTotals[kk][cc];
            }
            totals[cc]/= (float)BOX4;
          }
          extract.shove( totals, outIndex, dataOut );
          outIndex++;
          // skip over to next horizontal square of 4
          src += imageSizeInBytes + imageSizeInBytes;
        }
      }
    } else if( width == 1 ) {
      assert( height != 1 );
      
      for( ii = 0; ii < halfDepth; ii++ ) {
        for( jj = 0; jj < halfWidth; jj++ ) {
          float totals[] = new float[4];
          float extractTotals[][] = new float[BOX4][4];
          int cc;
          
          dataIn.position( src );
          extract.extract( isSwap, dataIn, extractTotals[0] );
          dataIn.position( src + rowSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[1] );
          dataIn.position( src + imageSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[2] );
          dataIn.position( src + rowSizeInBytes + imageSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[3] );
          
          for( cc = 0; cc < components; cc++ ) {
            int kk;
            
            // grab 4 pixels to average
            totals[cc] = 0.0f;
            for( kk = 0; kk < BOX4; kk++ ) {
              totals[cc]+= extractTotals[kk][cc];
            }
            totals[cc]/= (float)BOX4;
          }
          extract.shove( totals, outIndex, dataOut );
          outIndex++;
          // skip over to next horizontal square of 4
          src += imageSizeInBytes + imageSizeInBytes;
        }
      }
    }
  }
  
  public static void halveImageSlice( int components, ExtractPrimitive extract, int width,
          int height, int depth, ByteBuffer dataIn, ByteBuffer dataOut,
          int elementSizeInBytes, int groupSizeInBytes, int rowSizeInBytes,
          int imageSizeInBytes, boolean isSwap ) {
    int ii, jj;
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int halfDepth = depth / 2;
    int src = 0;
    int padBytes = rowSizeInBytes - ( width * groupSizeInBytes );
    int outIndex = 0;
    
    assert( (width == 1 || height == 1) && depth >= 2 );
    
    if( width == height ) {
      assert( width == 1 && height == 1 );
      assert( depth >= 2 );
      
      for( ii = 0; ii < halfDepth; ii++ ) {
        int cc;
        for( cc = 0; cc < components; cc++ ) {
          double[] totals = new double[4];
          double[][] extractTotals = new double[BOX2][4];
          int kk;
          
          dataIn.position( src );
          extractTotals[0][cc] = extract.extract( isSwap, dataIn );
          dataIn.position( src + imageSizeInBytes );
          extractTotals[1][cc] = extract.extract( isSwap, dataIn );
          
          // average 2 pixels since only a column
          totals[cc] = 0.0f;
          // totals[red] = extractTotals[0][red] + extractTotals[1][red];
          // totals[red] = red / 2;
          for( kk = 0; kk < BOX2; kk++ ) {
            totals[cc] += extractTotals[kk][cc];
          }
          totals[cc] /= (double)BOX2;
          
          extract.shove( totals[cc], outIndex, dataOut );
          outIndex++;
          src += elementSizeInBytes;
        } // for cc
        // skip over next group of 2
        src += rowSizeInBytes;
      } // for ii
      
      assert( src == rowSizeInBytes * height * depth );
      assert( outIndex == halfDepth * components );
    } else if( height == 1 ) {
      assert( width != 1 );
      
      for( ii = 0; ii < halfDepth; ii++ ) {
        for( jj = 0; jj < halfWidth; jj++ ) {
          int cc;
          for( cc = 0; cc < components; cc++ ) {
            int kk;
            double totals[] = new double[4];
            double extractTotals[][] = new double[BOX4][4];
            
            dataIn.position( src );
            extractTotals[0][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + groupSizeInBytes );
            extractTotals[1][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + imageSizeInBytes );
            extractTotals[2][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + imageSizeInBytes + groupSizeInBytes );
            extractTotals[3][cc] = extract.extract( isSwap, dataIn );
            
            // grab 4 pixels to average
            totals[cc] = 0.0f;
            // totals[red] = extractTotals[0][red] + extractTotals[1][red] +
            //               extractTotals[2][red] + extractTotals[3][red];
            // totals[red] /= (double)BOX4;
            for( kk = 0; kk < BOX4; kk++ ) {
              totals[cc] += extractTotals[kk][cc];
            }
            totals[cc] /= (double)BOX4;
            
            extract.shove( totals[cc], outIndex, dataOut );
            outIndex++;
            src += elementSizeInBytes;
          } // for cc
          // skip over to next horizontal square of 4
          src += elementSizeInBytes;
        } // for jj
        src += padBytes;
        src += rowSizeInBytes;
      } // for ii
      assert( src == rowSizeInBytes * height * depth );
      assert( outIndex == halfWidth * halfDepth * components );
    } else if( width == 1 ) {
      assert( height != 1 );
      
      for( ii = 0; ii < halfDepth; ii++ ) {
        for( jj = 0; jj < halfHeight; jj++ ) {
          int cc;
          for( cc = 0; cc < components; cc++ ) {
            int kk;
            double totals[] = new double[4];
            double extractTotals[][] = new double[BOX4][4];
            
            dataIn.position( src );
            extractTotals[0][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + rowSizeInBytes );
            extractTotals[1][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + imageSizeInBytes );
            extractTotals[2][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + imageSizeInBytes + groupSizeInBytes );
            extractTotals[3][cc] = extract.extract( isSwap, dataIn );
            
            
            // grab 4 pixels to average
            totals[cc] = 0.0f;
            // totals[red] = extractTotals[0][red] + extractTotals[1][red] +
            //               extractTotals[2][red] + extractTotals[3][red];
            // totals[red] /= (double)BOX4;
            for( kk = 0; kk < BOX4; kk++ ) {
              totals[cc] += extractTotals[kk][cc];
            }
            totals[cc] /= (double)BOX4;
            
            extract.shove( totals[cc], outIndex, dataOut );
            outIndex++;
            src += elementSizeInBytes;
          } // for cc
          // skip over to next horizontal square of 4
          src += padBytes;
          src += rowSizeInBytes;
        } // for jj
        src += imageSizeInBytes;
      } // for ii
      assert( src == rowSizeInBytes * height * depth );
      assert( outIndex == halfWidth * halfDepth * components );
    }
  }
  
  public static void halveImage3D( int components, ExtractPrimitive extract,
          int width, int height, int depth, ByteBuffer dataIn, ByteBuffer dataOut,
          int elementSizeInBytes, int groupSizeInBytes, int rowSizeInBytes,
          int imageSizeInBytes, boolean isSwap ) {
    assert( depth > 1 );
    
    // horizontal/vertical/onecolumn slice viewed from top
    if( width == 1 || height == 1 ) {
      assert( 1 <= depth );
      
      halveImageSlice( components, extract, width, height, depth, dataIn, dataOut,
              elementSizeInBytes, groupSizeInBytes, rowSizeInBytes, imageSizeInBytes,
              isSwap );
      return;
    }
    
    int ii, jj, dd;
    
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int halfDepth = depth / 2;
    int src = 0;
    int padBytes = rowSizeInBytes - ( width * groupSizeInBytes );
    int outIndex = 0;
    
    for( dd = 0; dd < halfDepth; dd++ ) {
      for( ii = 0; ii < halfHeight; ii++ ) {
        for( jj = 0; jj < halfWidth; jj++ ) {
          int cc;
          for( cc = 0; cc < components; cc++ ) {
            int kk;
            double totals[] = new double[4];
            double extractTotals[][] = new double[BOX8][4];
            
            dataIn.position( src );
            extractTotals[0][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + groupSizeInBytes );
            extractTotals[1][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + rowSizeInBytes );
            extractTotals[2][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + rowSizeInBytes + groupSizeInBytes );
            extractTotals[3][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + imageSizeInBytes );
            extractTotals[4][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + groupSizeInBytes + imageSizeInBytes );
            extractTotals[5][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + rowSizeInBytes + imageSizeInBytes );
            extractTotals[6][cc] = extract.extract( isSwap, dataIn );
            dataIn.position( src + rowSizeInBytes + imageSizeInBytes + groupSizeInBytes );
            extractTotals[7][cc] = extract.extract( isSwap, dataIn );
            
            totals[cc] = 0.0f;
            
            for( kk = 0; kk < BOX8; kk++ ) {
              totals[cc] += extractTotals[kk][cc];
            }
            totals[cc] /= (double)BOX8;
            
            extract.shove( totals[cc], outIndex, dataOut );
            outIndex++;
            
            src += elementSizeInBytes;
          } // for cc
          // skip over to next square of 4
          src += groupSizeInBytes;
        } // for jj
        // skip past pad bytes, if any, to get to next row
        src += padBytes;
        src += rowSizeInBytes;
      } // for ii
      src += imageSizeInBytes;
    } // for dd
    assert( src == rowSizeInBytes * height * depth );
    assert( outIndex == halfWidth * halfHeight * halfDepth * components );
  }
  
  public static void halveImagePackedPixel3D( int components, Extract extract,
          int width, int height, int depth, ByteBuffer dataIn, 
          ByteBuffer dataOut, int pixelSizeInBytes, int rowSizeInBytes,
          int imageSizeInBytes, boolean isSwap ) {
    if( depth == 1 ) {
      assert( 1 <= width && 1 <= height );
      
      halveImagePackedPixel( components, extract, width, height, dataIn, dataOut,
              pixelSizeInBytes, rowSizeInBytes, isSwap );
      return;
    } else if( width == 1 || height == 1 ) { // a horizontal or vertical slice viewed from top
      assert( 1 <= depth );
      
      halveImagePackedPixelSlice( components, extract, width, height, depth, dataIn,
              dataOut, pixelSizeInBytes, rowSizeInBytes, imageSizeInBytes, isSwap );
      return;
    }
    int ii, jj, dd;
    
    int halfWidth = width / 2;
    int halfHeight = height / 2;
    int halfDepth = depth / 2;
    int src = 0;
    int padBytes = rowSizeInBytes - ( width * pixelSizeInBytes );
    int outIndex = 0;
    
    for( dd = 0; dd < halfDepth; dd++ ) {
      for( ii = 0; ii < halfHeight; ii++ ) {
        for( jj = 0; jj < halfWidth; jj++ ) {
          float totals[] = new float[4]; // 4 is max components
          float extractTotals[][] = new float[BOX8][4];
          int cc;
          
          dataIn.position( src );
          extract.extract( isSwap, dataIn, extractTotals[0] );
          dataIn.position( src + pixelSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[1] );
          dataIn.position( src + rowSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[2] );
          dataIn.position( src + rowSizeInBytes + pixelSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[3] );
          dataIn.position( src + imageSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[4] );
          dataIn.position( src + pixelSizeInBytes + imageSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[5] );
          dataIn.position( src + rowSizeInBytes + imageSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[6] );
          dataIn.position( src + rowSizeInBytes + pixelSizeInBytes + imageSizeInBytes );
          extract.extract( isSwap, dataIn, extractTotals[7] );
          
          for( cc = 0; cc < components; cc++ ) {
            int kk;
            // grab 8 pixels to average
            totals[cc] = 0.0f;
            for( kk = 0; kk < BOX8; kk++ ) {
              totals[cc] += extractTotals[kk][cc];
            }
            totals[cc] /= (float)BOX8;
          }
          extract.shove( totals, outIndex, dataOut );
          outIndex++;
          // skip over to next square of 4
          src += pixelSizeInBytes + pixelSizeInBytes;
        }
        // skip past pad bytes, if any, to get to next row
        src += padBytes;
        src += rowSizeInBytes;
      }
      src += imageSizeInBytes;
    }
    assert( src == rowSizeInBytes * height * depth );
    assert( outIndex == halfWidth * halfHeight * halfDepth );
  }
}