/*===========================================================================*
 * postdct.c                                                                 *
 *                                                                           *
 *      Procedures concerned with MPEG post-DCT processing:                  *
 *          quantization and RLE Huffman encoding                            *
 *                                                                           *
 * EXPORTED PROCEDURES:                                                      *
 *      Mpost_QuantZigBlock                                                  *
 *      Mpost_RLEHuffIBlock                                                  *
 *      Mpost_RLEHuffPBlock                                                  *
 *      Mpost_UnQuantZigBlock                                                *
 *                                                                           *
 *===========================================================================*/

/*
 * Copyright (c) 1995 The Regents of the University of California.
 * All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement is
 * hereby granted, provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 */

/*
 *  $Header: /n/picasso/project/mm/mpeg/mpeg_dist/mpeg_encode/RCS/postdct.c,v 1.12 1995/06/21 18:26:39 smoot Exp $
 *  $Log: postdct.c,v $
 * Revision 1.12  1995/06/21  18:26:39  smoot
 * added length estimator for P-blocks
 *
 * Revision 1.11  1995/04/23  23:22:59  eyhung
 * nothing changed
 *
 * Revision 1.10  1995/04/14  23:10:46  smoot
 * Added overflow detection to MPOST_DCT so it will adjust Qscales (above)
 *
 * Revision 1.9  1995/02/15  23:15:32  smoot
 * killed useless asserts
 *
 * Revision 1.8  1995/02/01  21:48:41  smoot
 * assure out is set properly, short circuit 0 revquant
 *
 * Revision 1.7  1995/01/30  19:56:37  smoot
 * Killed a <0 shift
 *
 * Revision 1.6  1995/01/25  23:07:33  smoot
 * Better DBG_PRINTs, multiply/divide instead of shifts
 *
 * Revision 1.5  1995/01/19  23:09:10  eyhung
 * Changed copyrights
 *
 * Revision 1.4  1995/01/16  08:17:08  eyhung
 * added realQuiet
 *
 * Revision 1.3  1994/11/12  02:11:58  keving
 * nothing
 *
 * Revision 1.2  1994/03/15  00:27:11  keving
 * nothing
 *
 * Revision 1.2  1994/03/15  00:27:11  keving
 * nothing
 *
 * Revision 1.1  1993/12/22  19:19:01  keving
 * nothing
 *
 * Revision 1.11  1993/07/22  22:23:43  keving
 * nothing
 *
 * Revision 1.10  1993/06/30  20:06:09  keving
 * nothing
 *
 * Revision 1.9  1993/06/03  21:08:08  keving
 * nothing
 *
 * Revision 1.8  1993/02/24  18:57:19  keving
 * nothing
 *
 * Revision 1.7  1993/02/23  22:58:36  keving
 * nothing
 *
 * Revision 1.6  1993/02/23  22:54:56  keving
 * nothing
 *
 * Revision 1.5  1993/02/17  23:18:20  dwallach
 * checkin prior to keving's joining the project
 *
 * Revision 1.4  1993/01/18  10:20:02  dwallach
 * *** empty log message ***
 *
 * Revision 1.3  1993/01/18  10:17:29  dwallach
 * RCS headers installed, code indented uniformly
 *
 * Revision 1.3  1993/01/18  10:17:29  dwallach
 * RCS headers installed, code indented uniformly
 *
 */


/*==============*
 * HEADER FILES *
 *==============*/

#include <assert.h>
#include "all.h"
#include "mtypes.h"
#include "bitio.h"
#include "huff.h"
#include "postdct.h"
#include "opts.h"

/*==================*
 * STATIC VARIABLES *
 *==================*/

/* ZAG[i] is the natural-order position of the i'th element of zigzag order. */
int ZAG[] = {
    0, 1, 8, 16, 9, 2, 3, 10,
    17, 24, 32, 25, 18, 11, 4, 5,
    12, 19, 26, 33, 40, 48, 41, 34,
    27, 20, 13, 6, 7, 14, 21, 28,
    35, 42, 49, 56, 57, 50, 43, 36,
    29, 22, 15, 23, 30, 37, 44, 51,
    58, 59, 52, 45, 38, 31, 39, 46,
    53, 60, 61, 54, 47, 55, 62, 63
};

/*
 * possible optimization: reorder the qtable in the correct zigzag order, to
 * reduce the number of necessary lookups
 *
 * this table comes from the MPEG draft, p. D-16, Fig. 2-D.15.
 */
int32 qtable[] = {
    8, 16, 19, 22, 26, 27, 29, 34,
    16, 16, 22, 24, 27, 29, 34, 37,
    19, 22, 26, 27, 29, 34, 34, 38,
    22, 22, 26, 27, 29, 34, 37, 40,
    22, 26, 27, 29, 32, 35, 40, 48,
    26, 27, 29, 32, 35, 40, 48, 58,
    26, 27, 29, 34, 38, 46, 56, 69,
    27, 29, 35, 38, 46, 56, 69, 83
};

int32 niqtable[] = {
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16
};

int32   *customQtable = NULL;
int32   *customNIQtable = NULL;

/*==================*
 * GLOBAL VARIABLES *
 *==================*/

extern boolean realQuiet;

/*=====================*
 * EXPORTED PROCEDURES *
 *=====================*/

/*===========================================================================*
 *
 * Mpost_UnQuantZigBlock
 *
 *      unquantize and zig-zag (decode) a single block
 *      see section 2.4.4.1 of MPEG standard
 *
 * RETURNS:     nothing
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
void
Mpost_UnQuantZigBlock(in, out, qscale, iblock)
    FlatBlock in;
    Block out;
    int qscale;
    boolean iblock;
{
    register int index;
    int     start;
    int     position;
    register int            qentry;
    int     level, coeff;

    if ( iblock ) {
        /* qtable[0] must be 8 */
        out[0][0] = (int16)(in[0] * 8);

        /* don't need to do anything fancy here, because we saved orig
            value, not encoded dc value */
        start = 1;
    } else {
        start = 0;
    }

    for ( index = start;  index < DCTSIZE_SQ;  index++ ) {
        position = ZAG[index];
        level = in[index];

        if (level == 0) {
          ((int16 *)out)[position] = 0;
          continue;
        }


        if ( iblock ) {
            qentry = qtable[position] * qscale;
            coeff = (level*qentry)/8;
            if ( (coeff & 1) == 0 ) {
                if ( coeff < 0 ) {
                    coeff++;
                } else if ( coeff > 0 ) {
                    coeff--;
                }
            }
        } else {
            qentry = niqtable[position] * qscale;
            if ( level == 0 ) {
                coeff = 0;
            } else if ( level < 0 ) {
                coeff = (((2*level)-1)*qentry) / 16;
                if ( (coeff & 1) == 0 ) {
                    coeff++;
                }
            } else {
                coeff = (((2*level)+1)*qentry) >> 4;
                if ( (coeff & 1) == 0 ) {
                    coeff--;
                }
            }

            if ( coeff > 2047 ) {
                coeff = 2047;
            } else if ( coeff < -2048 ) {
                coeff = -2048;
            }
        }

        ((int16 *)out)[position] = coeff;
    }
}



/*===========================================================================*
 *
 * Mpost_QuantZigBlock
 *
 *      quantize and zigzags a block
 *
 * RETURNS:     MPOST_OVERFLOW if a generated value is outside |255|
 *              MPOST_ZERO     if all coeffs are zero
 *              MPOST_NON_ZERO otherwisw
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
int
Mpost_QuantZigBlock(in, out, qscale, iblock)
    Block in;
    FlatBlock out;
    register int qscale;
    int iblock;
{
  register int i;
  register int16 temp;
  register int qentry;
  register int position;
  boolean nonZero = FALSE;
  boolean overflow = FALSE;

  DBG_PRINT(("Mpost_QuantZigBlock...\n"));
  if (iblock) {
    /*
     * the DC coefficient is handled specially -- it's not
     * sensitive to qscale, but everything else is
     */
    temp = ((int16 *) in)[ZAG[0]];
    qentry = qtable[ZAG[0]];

    if (temp < 0) {
      temp = -temp;
      temp += (qentry >> 1);
      temp /= qentry;
      temp = -temp;
    } else {
      temp += (qentry >> 1);
      temp /= qentry;
    }
    if ( temp != 0 ) {
      nonZero = TRUE;
    }
    out[0] = temp;

    for (i = 1; i < DCTSIZE_SQ; i++) {
      position = ZAG[i];
      temp = ((int16 *) in)[position];
      qentry = qtable[position] * qscale;

      /* see 1993 MPEG doc, section D.6.3.4 */
      if (temp < 0) {
        temp = -temp;
        temp = (temp << 3);     /* temp > 0 */
        temp += (qentry >> 1);
        temp /= qentry;
        temp = -temp;
      } else {
        temp = (temp << 3);     /* temp > 0 */
        temp += (qentry >> 1);
        temp /= qentry;
      }

      if ( temp != 0 ) {
        nonZero = TRUE;
        out[i] = temp;
        if (temp < -255) {
          temp = -255;
          overflow = TRUE;
        } else if (temp > 255) {
          temp = 255;
          overflow = TRUE;
        }
      } else out[i]=0;
    }
  } else {
    for (i = 0; i < DCTSIZE_SQ; i++) {
      position = ZAG[i];
      temp = ((int16 *) in)[position];

      /* multiply by non-intra qtable */
      qentry = qscale * niqtable[position];

      /* see 1993 MPEG doc, D.6.4.5 */
      temp *= 8;
      temp /= qentry;       /* truncation toward 0 -- correct */

      if ( temp != 0 ) {
        nonZero = TRUE;
        out[i] = temp;
        if (temp < -255) {
          temp = -255;
          overflow = TRUE;
        } else if (temp > 255) {
          temp = 255;
          overflow = TRUE;
        }

      } else out[i]=0;
    }
  }

 if (overflow) return MPOST_OVERFLOW;
 if (nonZero)  return MPOST_NON_ZERO;
 return MPOST_ZERO;
}



/*===========================================================================*
 *
 * Mpost_RLEHuffIBlock
 *
 *      generate the huffman bits from an I-block
 *
 * RETURNS:     nothing
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
void
Mpost_RLEHuffIBlock(in, out)
    FlatBlock in;
    BitBucket *out;
{
    register int i;
    register int nzeros = 0;
    register int16 cur;
    register int16 acur;
    register uint32 code;
    register int nbits;

    /*
     * yes, Virginia, we start at 1.  The DC coefficient is handled
     * specially, elsewhere.  Not here.
     */
    for (i = 1; i < DCTSIZE_SQ; i++) {
        cur = in[i];
        acur = ABS(cur);
        if (cur) {
            if ( (nzeros < HUFF_MAXRUN) && (acur < huff_maxlevel[nzeros])) {
                /*
                 * encode using the Huffman tables
                 */

                DBG_PRINT(("rle_huff %02d.%02d: Run %02d, Level %4d\n", i,  ZAG[i], nzeros, cur));
                code = (huff_table[nzeros])[acur];
                nbits = (huff_bits[nzeros])[acur];

                if (cur < 0) {
                    code |= 1;  /* the sign bit */
                }
                Bitio_Write(out, code, nbits);
            } else {
                /*
                 * encode using the escape code
                 */
                DBG_PRINT(("Escape\n"));
                Bitio_Write(out, 0x1, 6);       /* ESCAPE */
                DBG_PRINT(("Run Length\n"));
                Bitio_Write(out, nzeros, 6);    /* Run-Length */

                /*
                 * this shouldn't happen, but the other
                 * choice is to bomb out and dump core...
                 * Hmmm, seems to happen with small Qtable entries (1) -srs
                 */
                if (cur < -255) {
                    cur = -255;
                } else if (cur > 255) {
                    cur = 255;
                }

                DBG_PRINT(("Level\n"));
                if (acur < 128) {
                    Bitio_Write(out, cur, 8);
                } else {
                    if (cur < 0) {
                        Bitio_Write(out, 0x8001 + cur + 255, 16);
                    } else {
                        Bitio_Write(out, cur, 16);
                    }
                }
            }
            nzeros = 0;
        } else {
            nzeros++;
        }
    }
    DBG_PRINT(("End of block\n"));
    Bitio_Write(out, 0x2, 2);   /* end of block marker */
}



/*===========================================================================*
 *
 * Mpost_RLEHuffPBlock
 *
 *      generate the huffman bits from an P-block
 *
 * RETURNS:     nothing
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
void
Mpost_RLEHuffPBlock(in, out)
    FlatBlock in;
    BitBucket *out;
{
    register int i;
    register int nzeros = 0;
    register int16 cur;
    register int16 acur;
    register uint32 code;
    register int nbits;
    boolean first_dct = TRUE;

    /*
     * yes, Virginia, we start at 0.
     */
    for (i = 0; i < DCTSIZE_SQ; i++) {
        cur = in[i];
        acur = ABS(cur);
        if (cur) {
            if ((nzeros < HUFF_MAXRUN) && (acur < huff_maxlevel[nzeros])) {
                /*
                 * encode using the Huffman tables
                 */

                DBG_PRINT(("rle_huff %02d.%02d: Run %02d, Level %4d\n", i, ZAG[i], nzeros, cur));
                if ( first_dct && (nzeros == 0) && (acur == 1) ) {
                    /* actually, only needs = 0x2 */
                    code = (cur == 1) ? 0x2 : 0x3;
                    nbits = 2;
                } else {
                    code = (huff_table[nzeros])[acur];
                    nbits = (huff_bits[nzeros])[acur];
                  }

                assert(nbits);

                if (cur < 0) {
                    code |= 1;  /* the sign bit */
                }
                Bitio_Write(out, code, nbits);
                first_dct = FALSE;
            } else {
                /*
                 * encode using the escape code
                 */
                DBG_PRINT(("Escape\n"));
                Bitio_Write(out, 0x1, 6);       /* ESCAPE */
                DBG_PRINT(("Run Length\n"));
                Bitio_Write(out, nzeros, 6);    /* Run-Length */

                /*
                 * this shouldn't happen, but the other
                 * choice is to bomb out and dump core...
                 * Hmmm, seems to happen with small Qtable entries (1) -srs
                 */
                if (cur < -255) {
                  cur = -255;
                } else if (cur > 255) {
                  cur = 255;
                }

                DBG_PRINT(("Level\n"));
                if (acur < 128) {
                    Bitio_Write(out, cur, 8);
                } else {
                    if (cur < 0) {
                        Bitio_Write(out, 0x8001 + cur + 255, 16);
                    } else {
                        Bitio_Write(out, cur, 16);
                    }
                }

                first_dct = FALSE;
            }
            nzeros = 0;
        } else {
            nzeros++;
        }
    }

    /* actually, should REALLY return FALSE and not use this! */

    if ( first_dct ) {  /* have to give a first_dct even if all 0's */
        fprintf(stderr, "HUFF called with all-zero coefficients\n");
        fprintf(stderr, "exiting...\n");
        exit(1);
    }

    DBG_PRINT(("End of block\n"));
    Bitio_Write(out, 0x2, 2);   /* end of block marker */
}



/*===========================================================================*
 *
 * CalcRLEHuffLength
 *
 *      count the huffman bits for an P-block
 *
 * RETURNS:     number of bits
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
int
CalcRLEHuffLength(in)
    FlatBlock in;
{
  register int i;
  register int nzeros = 0;
  register int16 cur;
  register int16 acur;
  register int nbits;
  register int countbits=0;
  boolean first_dct = TRUE;

  for (i = 0; i < DCTSIZE_SQ; i++) {
    cur = in[i];
    acur = ABS(cur);
    if (cur) {
      if ((nzeros < HUFF_MAXRUN) && (acur < huff_maxlevel[nzeros])) {
        /*
         * encode using the Huffman tables
         */

        if ( first_dct && (nzeros == 0) && (acur == 1) ) {
          nbits = 2;
        } else {
          nbits = (huff_bits[nzeros])[acur];
        }
        countbits += nbits;
        first_dct = FALSE;
      } else {
        countbits += 12;        /* ESCAPE + runlength */

        if (acur < 128) {
          countbits += 8;
        } else {
          countbits += 16;
        }

        first_dct = FALSE;
      }
      nzeros = 0;
    } else {
      nzeros++;
    }
  }

  countbits += 2; /* end of block marker */
  return countbits;
}



