/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <liboil/liboil.h>

#include <liboil/liboildebug.h>

#include "jpeg_huffman.h"

#include "jpeg_debug.h"

/* misc helper function definitions */

static char *sprintbits (char *str, unsigned int bits, int n);

#define TRUE 1

#define FALSE 0

void

huffman_table_dump (HuffmanTable * table)

{

  unsigned int n_bits;

  unsigned int code;

  char str[33];

  int i;

  HuffmanEntry *entry;

  OIL_DEBUG ("dumping huffman table %p", table);

  for (i = 0; i < table->len; i++) {

    entry = table->entries + i;

    n_bits = entry->n_bits;

    code = entry->symbol >> (16 - n_bits);

    sprintbits (str, code, n_bits);

    OIL_DEBUG ("%s --> %d", str, entry->value);

  }

}

void

huffman_table_init (HuffmanTable *table)

{

  memset (table, 0, sizeof(HuffmanTable));

}

void

huffman_table_add (HuffmanTable * table, uint32_t code, int n_bits, int value)

{

  HuffmanEntry *entry = table->entries + table->len;

  entry->value = value;

  entry->symbol = code << (16 - n_bits);

  entry->mask = 0xffff ^ (0xffff >> n_bits);

  entry->n_bits = n_bits;

  table->len++;

}

unsigned int

huffman_table_decode_jpeg (HuffmanTable * tab, JpegBits * bits)

{

  unsigned int code;

  int i;

  char str[33];

  HuffmanEntry *entry;

  code = peekbits (bits, 16);

  for (i = 0; i < tab->len; i++) {

    entry = tab->entries + i;

    if ((code & entry->mask) == entry->symbol) {

      code = getbits (bits, entry->n_bits);

      sprintbits (str, code, entry->n_bits);

      OIL_DEBUG ("%s --> %d", str, entry->value);

      return entry->value;

    }

  }

  printf ("huffman sync lost");

  return -1;

}

int

huffman_table_decode_macroblock (short *block, HuffmanTable * dc_tab,

    HuffmanTable * ac_tab, JpegBits * bits)

{

  int r, s, x, rs;

  int k;

  char str[33];

  memset (block, 0, sizeof (short) * 64);

  s = huffman_table_decode_jpeg (dc_tab, bits);

  if (s < 0)

    return -1;

  x = getbits (bits, s);

  if ((x >> (s - 1)) == 0) {

    x -= (1 << s) - 1;

  }

  OIL_DEBUG ("s=%d (block[0]=%d)", s, x);

  block[0] = x;

  for (k = 1; k < 64; k++) {

    rs = huffman_table_decode_jpeg (ac_tab, bits);

    if (rs < 0) {

      OIL_DEBUG ("huffman error");

      return -1;

    }

    if (bits->ptr > bits->end) {

      OIL_DEBUG ("overrun");

      return -1;

    }

    s = rs & 0xf;

    r = rs >> 4;

    if (s == 0) {

      if (r == 15) {

        OIL_DEBUG ("r=%d s=%d (skip 16)", r, s);

        k += 15;

      } else {

        OIL_DEBUG ("r=%d s=%d (eob)", r, s);

        break;

      }

    } else {

      k += r;

      if (k >= 64) {

        printf ("macroblock overrun");

        return -1;

      }

      x = getbits (bits, s);

      sprintbits (str, x, s);

      if ((x >> (s - 1)) == 0) {

        x -= (1 << s) - 1;

      }

      block[k] = x;

      OIL_DEBUG ("r=%d s=%d (%s -> block[%d]=%d)", r, s, str, k, x);

    }

  }

  return 0;

}

int

huffman_table_decode (HuffmanTable * dc_tab, HuffmanTable * ac_tab,

    JpegBits * bits)

{

  int16_t zz[64];

  int ret;

  while (bits->ptr < bits->end) {

    ret = huffman_table_decode_macroblock (zz, dc_tab, ac_tab, bits);

    if (ret < 0)

      return -1;

  }

  return 0;

}

/* misc helper functins */

static char *

sprintbits (char *str, unsigned int bits, int n)

{

  int i;

  int bit = 1 << (n - 1);

  for (i = 0; i < n; i++) {

    str[i] = (bits & bit) ? '1' : '0';

    bit >>= 1;

  }

  str[i] = 0;

  return str;

}