/*

 * Copyright (c) 1999-2000 Image Power, Inc. and the University of

 *   British Columbia.

 * Copyright (c) 2001-2003 Michael David Adams.

 * All rights reserved.

 */

/* __START_OF_JASPER_LICENSE__

 * 

 * JasPer License Version 2.0

 * 

 * Copyright (c) 2001-2006 Michael David Adams

 * Copyright (c) 1999-2000 Image Power, Inc.

 * Copyright (c) 1999-2000 The University of British Columbia

 * 

 * All rights reserved.

 * 

 * Permission is hereby granted, free of charge, to any person (the

 * "User") obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without restriction,

 * including without limitation the rights to use, copy, modify, merge,

 * publish, distribute, and/or sell copies of the Software, and to permit

 * persons to whom the Software is furnished to do so, subject to the

 * following conditions:

 * 

 * 1.  The above copyright notices and this permission notice (which

 * includes the disclaimer below) shall be included in all copies or

 * substantial portions of the Software.

 * 

 * 2.  The name of a copyright holder shall not be used to endorse or

 * promote products derived from the Software without specific prior

 * written permission.

 * 

 * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS

 * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER

 * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS

 * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING

 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A

 * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO

 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL

 * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING

 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION

 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE

 * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE

 * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.

 * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS

 * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL

 * PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS

 * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE

 * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE

 * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL

 * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,

 * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL

 * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH

 * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,

 * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH

 * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY

 * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.

 * 

 * __END_OF_JASPER_LICENSE__

 */

/*

 * MQ Arithmetic Encoder

 *

 * $Id$

 */

/******************************************************************************\

* Includes.

\******************************************************************************/

#include "jpc_mqenc.h"

#include "jasper/jas_stream.h"

#include "jasper/jas_malloc.h"

#include "jasper/jas_math.h"

#include "jasper/jas_debug.h"

#include <stdlib.h>

/******************************************************************************\

* Macros

\******************************************************************************/

#ifndef NDEBUG

#define JPC_MQENC_CALL(n, x) \

  ((jas_get_debug_level() >= (n)) ? ((void)(x)) : ((void)0))

#else

#define JPC_MQENC_CALL(n, x)

#endif

#define jpc_mqenc_codemps9(areg, creg, ctreg, curctx, enc) \

{ \

  const jpc_mqstate_t *state = *(curctx); \

  (areg) -= state->qeval; \

  if (!((areg) & 0x8000)) { \

    if ((areg) < state->qeval) { \

      (areg) = state->qeval; \

    } else { \

      (creg) += state->qeval; \

    } \

    *(curctx) = state->nmps; \

    jpc_mqenc_renorme((areg), (creg), (ctreg), (enc)); \

  } else { \

    (creg) += state->qeval; \

  } \

}

#define jpc_mqenc_codelps2(areg, creg, ctreg, curctx, enc) \

{ \

  const jpc_mqstate_t *state = *(curctx); \

  (areg) -= state->qeval; \

  if ((areg) < state->qeval) { \

    (creg) += state->qeval; \

  } else { \

    (areg) = state->qeval; \

  } \

  *(curctx) = state->nlps; \

  jpc_mqenc_renorme((areg), (creg), (ctreg), (enc)); \

}

#define jpc_mqenc_renorme(areg, creg, ctreg, enc) \

{ \

  do { \

    (areg) <<= 1; \

    (creg) <<= 1; \

    if (!--(ctreg)) { \

      jpc_mqenc_byteout((areg), (creg), (ctreg), (enc)); \

    } \

  } while (!((areg) & 0x8000)); \

}

#define jpc_mqenc_byteout(areg, creg, ctreg, enc) \

{ \

  if ((enc)->outbuf != 0xff) { \

    if ((creg) & 0x8000000) { \

      if (++((enc)->outbuf) == 0xff) { \

        (creg) &= 0x7ffffff; \

        jpc_mqenc_byteout2(enc); \

        enc->outbuf = ((creg) >> 20) & 0xff; \

        (creg) &= 0xfffff; \

        (ctreg) = 7; \

      } else { \

        jpc_mqenc_byteout2(enc); \

        enc->outbuf = ((creg) >> 19) & 0xff; \

        (creg) &= 0x7ffff; \

        (ctreg) = 8; \

      } \

    } else { \

      jpc_mqenc_byteout2(enc); \

      (enc)->outbuf = ((creg) >> 19) & 0xff; \

      (creg) &= 0x7ffff; \

      (ctreg) = 8; \

    } \

  } else { \

    jpc_mqenc_byteout2(enc); \

    (enc)->outbuf = ((creg) >> 20) & 0xff; \

    (creg) &= 0xfffff; \

    (ctreg) = 7; \

  } \

}

static void jpc_mqenc_byteout2(jpc_mqenc_t *enc)

{

  if (enc->outbuf >= 0) {

    if (jas_stream_putc(enc->out, (unsigned char)enc->outbuf) == EOF) {

      enc->err = true;

    }

  }

  enc->lastbyte = enc->outbuf;

}

/******************************************************************************\

* Local function protoypes.

\******************************************************************************/

static void jpc_mqenc_setbits(jpc_mqenc_t *mqenc);

/******************************************************************************\

* Code for creation and destruction of encoder.

\******************************************************************************/

/* Create a MQ encoder. */

jpc_mqenc_t *jpc_mqenc_create(unsigned maxctxs, jas_stream_t *out)

{

  jpc_mqenc_t *mqenc;

  /* Allocate memory for the MQ encoder. */

  if (!(mqenc = jas_malloc(sizeof(jpc_mqenc_t)))) {

    goto error;

  }

  mqenc->out = out;

  mqenc->maxctxs = maxctxs;

  /* Allocate memory for the per-context state information. */

  if (!(mqenc->ctxs = jas_alloc2(mqenc->maxctxs, sizeof(jpc_mqstate_t *)))) {

    goto error;

  }

  /* Set the current context to the first one. */

  mqenc->curctx = mqenc->ctxs;

  jpc_mqenc_init(mqenc);

  /* Initialize the per-context state information to something sane. */

  jpc_mqenc_setctxs(mqenc, 0, 0);

  return mqenc;

error:

  if (mqenc) {

    jpc_mqenc_destroy(mqenc);

  }

  return 0;

}

/* Destroy a MQ encoder. */

void jpc_mqenc_destroy(jpc_mqenc_t *mqenc)

{

  jas_free(mqenc->ctxs);

  jas_free(mqenc);

}

/******************************************************************************\

* State initialization code.

\******************************************************************************/

/* Initialize the coding state of a MQ encoder. */

void jpc_mqenc_init(jpc_mqenc_t *mqenc)

{

  mqenc->areg = 0x8000;

  mqenc->outbuf = -1;

  mqenc->creg = 0;

  mqenc->ctreg = 12;

  mqenc->lastbyte = -1;

  mqenc->err = false;

}

/* Initialize one or more contexts. */

void jpc_mqenc_setctxs(jpc_mqenc_t *mqenc, unsigned numctxs, const jpc_mqctx_t *ctxs)

{

  const jpc_mqstate_t **ctx;

  ctx = mqenc->ctxs;

  unsigned n = JAS_MIN(mqenc->maxctxs, numctxs);

  while (n-- > 0) {

    *ctx = &jpc_mqstates[2 * ctxs->ind + ctxs->mps];

    ++ctx;

    ++ctxs;

  }

  n = mqenc->maxctxs - numctxs;

  while (n-- > 0) {

    *ctx = &jpc_mqstates[0];

    ++ctx;

  }

}

/* Get the coding state for a MQ encoder. */

void jpc_mqenc_getstate(const jpc_mqenc_t *mqenc, jpc_mqencstate_t *state)

{

  state->areg = mqenc->areg;

  state->creg = mqenc->creg;

  state->ctreg = mqenc->ctreg;

  state->lastbyte = mqenc->lastbyte;

}

/******************************************************************************\

* Code for coding symbols.

\******************************************************************************/

/* Encode a bit. */

int jpc_mqenc_putbit(jpc_mqenc_t *mqenc, bool bit)

{

  const jpc_mqstate_t *state;

  JAS_LOGDEBUGF(100, "jpc_mqenc_putbit(%p, %d)\n", mqenc, bit);

  JPC_MQENC_CALL(100, jpc_mqenc_dump(mqenc));

  state = *(mqenc->curctx);

  if (state->mps == bit) {

    /* Apply the CODEMPS algorithm as defined in the standard. */

    mqenc->areg -= state->qeval;

    if (!(mqenc->areg & 0x8000)) {

      jpc_mqenc_codemps2(mqenc);

    } else {

      mqenc->creg += state->qeval;

    }

  } else {

    /* Apply the CODELPS algorithm as defined in the standard. */

    jpc_mqenc_codelps2(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc->curctx, mqenc);

  }

  return jpc_mqenc_error(mqenc) ? (-1) : 0;

}

int jpc_mqenc_codemps2(jpc_mqenc_t *mqenc)

{

  /* Note: This function only performs part of the work associated with

  the CODEMPS algorithm from the standard.  Some of the work is also

  performed by the caller. */

  const jpc_mqstate_t *state = *(mqenc->curctx);

  if (mqenc->areg < state->qeval) {

    mqenc->areg = state->qeval;

  } else {

    mqenc->creg += state->qeval;

  }

  *mqenc->curctx = state->nmps;

  jpc_mqenc_renorme(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);

  return jpc_mqenc_error(mqenc) ? (-1) : 0;

}

int jpc_mqenc_codelps(jpc_mqenc_t *mqenc)

{

  jpc_mqenc_codelps2(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc->curctx, mqenc);

  return jpc_mqenc_error(mqenc) ? (-1) : 0;

}

/******************************************************************************\

* Miscellaneous code.

\******************************************************************************/

/* Terminate the code word. */

int jpc_mqenc_flush(jpc_mqenc_t *mqenc, int termmode)

{

  int_fast16_t k;

  switch (termmode) {

  case JPC_MQENC_PTERM:

    k = 11 - mqenc->ctreg + 1;

    while (k > 0) {

      mqenc->creg <<= mqenc->ctreg;

      mqenc->ctreg = 0;

      jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg,

        mqenc);

      k -= mqenc->ctreg;

    }

    if (mqenc->outbuf != 0xff) {

      jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);

    }

    break;

  case JPC_MQENC_DEFTERM:

    jpc_mqenc_setbits(mqenc);

    mqenc->creg <<= mqenc->ctreg;

    jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);

    mqenc->creg <<= mqenc->ctreg;

    jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);

    if (mqenc->outbuf != 0xff) {

      jpc_mqenc_byteout(mqenc->areg, mqenc->creg, mqenc->ctreg, mqenc);

    }

    break;

  default:

    assert(false);

    JAS_UNREACHABLE();

  }

  return 0;

}

static void jpc_mqenc_setbits(jpc_mqenc_t *mqenc)

{

  uint_least32_t tmp = mqenc->creg + mqenc->areg;

  mqenc->creg |= 0xffff;

  if (mqenc->creg >= tmp) {

    mqenc->creg -= 0x8000;

  }

}

/* Dump a MQ encoder to a stream for debugging. */

int jpc_mqenc_dump(const jpc_mqenc_t *mqenc)

{

  jas_logprintf("AREG = %08"PRIxLEAST32", CREG = %08"PRIxLEAST32", CTREG = %"PRIuLEAST32"\n",

    mqenc->areg, mqenc->creg, mqenc->ctreg);

  jas_logprintf("IND = %02"PRIdPTR", MPS = %d, QEVAL = %04"PRIxLEAST16"\n",

    *mqenc->curctx - jpc_mqstates, (*mqenc->curctx)->mps,

    (*mqenc->curctx)->qeval);

  return 0;

}