// *************************************************************************************

//

// decode.c

//

// version 1.0

// 01/23/2016

// Written by Matthias Grün

// m.gruen@theicingonthecode.com

//

// IceJPEG is open source and may be used freely, as long as the original author

// of the code is mentioned.

//

// You may redistribute it freely as long as no fees are charged and this information

// is included.

//

// If modifications are made to the code that alter its behavior and the modified code

// is made available to others or used in other products, the author is to receive

// a copy of the modified code.

//

// This code is provided as is and I do not and cannot guarantee the absence of bugs.

// Use of this code is at your own risk and I cannot be held liable for any

// damage that is caused by its use.

//

// *************************************************************************************

//

// This file constitutes the decoder part of my IceJPEG library, which was

// written mainly because I wanted to understand the inner workings of the

// JPEG format.

//

// Currently, only baseline JPEGs are supported. However, I would like to implement

// progressive decompressiom as well at some point.

//

// Only grayscale and RGB JPEGs can be decoded using this code.

//

// Restart markers are supported also.

//

// The code that performs the IDCT (Inverse Discrete Cosine Transform) was taken from

// libmpeg2, with slight modifications.

//

// *************************************************************************************

#include <stdio.h>

#include <memory.h>

#include <sys/stat.h>

#include <stdlib.h>

#include "common.h"

#include "IDCT.h"

#include "upsample.h"

#include "decode.h"

#include <string.h>

//#define _JPEG_DEBUG

#define USE_LANCZOS_UPSAMPLING

typedef struct jpeg_huffman_code** jpeg_huffman_table; // array of pointers to a huffman code

typedef byte* jpeg_dqttable;

static struct __ice_decode_env

} iceenv;

#pragma pack(push)

#pragma pack(1)

#pragma pack(pop)

void cleanup(void);

int process_segment(void);

void cleanup_dht(void);

int icejpeg_decode_init(const char* filename)

{

memset(&iceenv, 0, sizeof(struct __ice_decode_env));

FILE *file; // Our jpeg file

file = fopen(filename, "rb");

if (!file)

return ERR_OPENFILE_FAILED;

struct stat st; // file stats

fstat(fileno(file), &st);

iceenv.buffer = (byte *)malloc(sizeof(byte) * st.st_size);

fread((void*)iceenv.buffer, sizeof(byte), st.st_size, file);

#ifdef _JPEG_DEBUG

printf("%lld bytes read.\n", st.st_size);

printf("%d\n", ferror(file));

#endif

fclose(file);

if (iceenv.buffer[iceenv.buf_pos++] != 0xFF || iceenv.buffer[iceenv.buf_pos++] != 0xD8)

{

cleanup();

return ERR_NO_JPEG;

}

int i;

for (i = 0; i < MAX_DC_TABLES; i++)

{

iceenv.dc_dht[i] = 0;

iceenv.huff_dc[i] = 0;

}

for (i = 0; i < MAX_AC_TABLES; i++)

{

iceenv.ac_dht[i] = 0;

iceenv.huff_ac[i] = 0;

}

for (i = 0; i < 4; i++)

{

iceenv.qt_tables[i] = 0;

}

iceenv.restart_interval = 0;

iceenv.cur_byte_remaining = 8;

return ERR_OK;

}

int icejpeg_read(unsigned char **buffer, int *width, int *height, int *num_components)

{

int err;

while (!iceenv.eoi)

{

err = process_segment();

if (err != ERR_OK)

return err;

}

*buffer = iceenv.image;

*width = iceenv.sof0.width;

*height = iceenv.sof0.height;

*num_components = iceenv.sof0.num_components;

return ERR_OK;

}

void icejpeg_cleanup(void)

{

cleanup();

}

//////////////////////////////////////////////////////////////////////////

// Helper functions

//////////////////////////////////////////////////////////////////////////

word fetch_word(void)

{

word temp;

temp = iceenv.buffer[iceenv.buf_pos++];

temp <<= 8;

temp |= iceenv.buffer[iceenv.buf_pos++];

return temp;

}

int gen_huffman_tables(void)

{

int i, j, k;

struct jpeg_dht* cur_src_table = 0;

jpeg_huffman_table cur_dst_table = 0;

// Loop over all 2 tables

for (i = 0; i < MAX_DC_TABLES + MAX_AC_TABLES; i++)

{

if (i >= 0 && i < MAX_DC_TABLES)

{

cur_src_table = iceenv.dc_dht[i];

}

else

{

cur_src_table = iceenv.ac_dht[i - MAX_DC_TABLES];

}

if (!cur_src_table)

continue;

word cur_bitstring = 0;

byte cur_length = 0;

byte code_buf_pos = 0;

cur_dst_table = (jpeg_huffman_table)malloc(sizeof(struct jpeg_huffman_code*) * 0xFFFF);

memset((void*)cur_dst_table, 0, sizeof(struct jpeg_huffman_code*) * 0xFFFF);

if (i >= 0 && i < MAX_DC_TABLES)

{

iceenv.huff_dc[i] = cur_dst_table;

}

else

{

iceenv.huff_ac[i - MAX_DC_TABLES] = cur_dst_table;

}

// Loop over all 16 code lengths

for (j = 0; j < 16; j++)

{

cur_length = j+1;

#ifdef _JPEG_DEBUG

printf("Codes of length %d bits:\n", cur_length);

#endif

// Loop over all codes of length j

for (k = 0; k < cur_src_table->num_codes[j]; k++)

{

cur_dst_table[cur_bitstring] = (struct jpeg_huffman_code*)malloc(sizeof(struct jpeg_huffman_code));

cur_dst_table[cur_bitstring]->length = cur_length;

cur_dst_table[cur_bitstring]->code = cur_src_table->codes[code_buf_pos++];

#ifdef _JPEG_DEBUG

printf("\t");

int l;

for (l = cur_length-1; l >= 0; l--)

{

printf("%d", (cur_bitstring & (1 << l)) >> l);

}

printf(" -> %X\n", cur_dst_table[cur_bitstring]->code);

#endif

cur_bitstring++;

}

cur_bitstring <<= 1;

}

#ifdef _JPEG_DEBUG

printf("\n");

getc(stdin);

#endif

}

cleanup_dht();

return ERR_OK;

}

word fetch_bits(int num_bits)

{

word result = 0;

byte bits_from_cur_byte = 0;

while (num_bits > 0)

{

byte mask = 0;

bits_from_cur_byte = min(iceenv.cur_byte_remaining, num_bits);

byte mask_shift = iceenv.cur_byte_remaining - bits_from_cur_byte;

mask = (1 << bits_from_cur_byte) - 1;

//mask <<= mask_shift;

result <<= bits_from_cur_byte;

result |= (iceenv.buffer[iceenv.buf_pos] >> mask_shift) & mask;

iceenv.cur_byte_remaining = max(0, iceenv.cur_byte_remaining - num_bits);

num_bits -= bits_from_cur_byte;

if (!iceenv.cur_byte_remaining && num_bits)

{

if (iceenv.buffer[iceenv.buf_pos] == 0xFF)

{

switch (iceenv.buffer[iceenv.buf_pos + 1])

{

case 0x00:

iceenv.buf_pos++;

break;

default:

printf("ERROR: Marker detected in bit stream!\n");

getc(stdin);

break;

}

}

iceenv.cur_byte_remaining = 8;

iceenv.buf_pos++;

// Skip stuff bytes

// if (skip_stuff_byte)

// {

// iceenv.buf_pos++;

// skip_stuff_byte = 0;

// }

// if (iceenv.scan_buffer[iceenv.buf_pos] == 0xFF)

// {

// switch (iceenv.scan_buffer[iceenv.buf_pos + 1])

// {

// case 0x00:

// skip_stuff_byte = 1;

// break;

// default:

// printf("ERROR: Marker detected in bit stream!\n");

// getc(stdin);

// break;

// }

// }

}

}

return result;

}

// Determines the value for a given huffman code

int get_huffman_code(word bitstring, byte length, jpeg_huffman_table table)

{

if (table[bitstring] && table[bitstring]->length == length)

{

return table[bitstring]->code;

}

return -1;

}

// Fetches the next huffman code from the bitstream

byte get_next_code(jpeg_huffman_table cur_table)

{

word bit_string = 0;

byte cur_length = 1;

byte cur_code = 0;

int found = 0;

while (cur_length < 17)

{

bit_string <<= 1;

bit_string |= fetch_bits(1);

int code = get_huffman_code(bit_string, cur_length, cur_table);

if (code > -1)

{

cur_code = code;

found = 1;

break;

}

cur_length++;

}

if (!found)

{

printf("No code found!\n");

getc(stdin);

}

return cur_code;

}

short get_signed_short(word bit_string, byte length)

{

return bit_string & (1 << (length - 1)) ? bit_string : (-1 << length) + 1 + bit_string;

}

int process_app0(void)

{

memcpy((void*)&iceenv.app0, (void*) (iceenv.buffer + iceenv.buf_pos), sizeof(struct jpeg_app0));

if (strcmp(iceenv.app0.strjfif, "JFIF"))

return ERR_INVALID_JFIF_STRING;

if (iceenv.app0.maj_revision != 1)

return ERR_INVALID_MAJOR_REV;

iceenv.buf_pos += iceenv.cur_segment_len - 2;

return ERR_OK;

}

int process_dqt(void)

{

int bytes_read = 2;

while (bytes_read < iceenv.cur_segment_len)

{

byte info = iceenv.buffer[iceenv.buf_pos++];

// 16bit?

if (UPR4(info))

return ERR_16BIT_DQT_NOT_SUPPORTED;

iceenv.qt_tables[LWR4(info)] = (byte *)malloc(64);

memcpy((void*)iceenv.qt_tables[LWR4(info)], (void*)(iceenv.buffer + iceenv.buf_pos), 64);

iceenv.buf_pos += 64;

bytes_read += 64 + 1; // including the info byte above

#ifdef _JPEG_DEBUG

int x = 0, y = 0;

for (y = 0; y < 8; y++)

{

for (x = 0; x < 8; x++)

{

printf("%d ", iceenv.qt_tables[info & 0xF][(y * 8) + x]);

}

printf("\n");

}

#endif

}

return ERR_OK;

}

int process_sof0(void)

{

iceenv.max_samp_y = iceenv.max_samp_x = 0;

memcpy((void*)&iceenv.sof0, (void*)(iceenv.buffer + iceenv.buf_pos), sizeof(struct jpeg_sof0));

iceenv.buf_pos += sizeof(struct jpeg_sof0);

if (iceenv.sof0.num_components != 1 && iceenv.sof0.num_components != 3)

return ERR_INVALID_NUMBER_OF_COMP;

iceenv.sof0.width = FLIP(iceenv.sof0.width);

iceenv.sof0.height = FLIP(iceenv.sof0.height);

struct jpeg_sof0_component_info comp_info[3];

//comp_info[0] = comp_info[1] = comp_info[2] = 0;

int i;

// for (i = 0; i < sof0.num_components; i++)

// {

// comp_info[i] = (struct jpeg_sof0_component_info*)malloc(sizeof(struct jpeg_sof0_component_info));

// }

iceenv.components = (struct jpeg_component*) malloc(sizeof(struct jpeg_component) * iceenv.sof0.num_components);

for (i = 0; i < iceenv.sof0.num_components; i++)

{

memcpy((void*)&comp_info[i], (void*)(iceenv.buffer + iceenv.buf_pos), sizeof(struct jpeg_sof0_component_info));

iceenv.buf_pos += sizeof(struct jpeg_sof0_component_info);

iceenv.components[i].qt_table = comp_info[i].qt_table;

iceenv.components[i].sx = UPR4(comp_info[i].sampling_factors);

iceenv.components[i].sy = LWR4(comp_info[i].sampling_factors);

iceenv.components[i].prev_dc = 0;

// Update maximum sampling factors

if (iceenv.components[i].sx > iceenv.max_samp_x)

iceenv.max_samp_x = iceenv.components[i].sx;

if (iceenv.components[i].sy > iceenv.max_samp_y)

iceenv.max_samp_y = iceenv.components[i].sy;

}

iceenv.mcu_width = iceenv.max_samp_x << 3;

iceenv.mcu_height = iceenv.max_samp_y << 3;

iceenv.num_mcu_x = (iceenv.sof0.width + iceenv.mcu_width - 1) / iceenv.mcu_width;

iceenv.num_mcu_y = (iceenv.sof0.height + iceenv.mcu_height - 1) / iceenv.mcu_height;

for (i = 0; i < iceenv.sof0.num_components; i++)

{

iceenv.components[i].width = (iceenv.sof0.width * iceenv.components[i].sx + iceenv.max_samp_x - 1) / iceenv.max_samp_x;

iceenv.components[i].height = (iceenv.sof0.height * iceenv.components[i].sy + iceenv.max_samp_y - 1) / iceenv.max_samp_y;

iceenv.components[i].stride = iceenv.num_mcu_x * (iceenv.components[i].sx << 3);

iceenv.components[i].pixels = (byte*)malloc(iceenv.components[i].stride * (iceenv.num_mcu_y * (iceenv.components[i].sy << 3)) * sizeof(byte));

}

#ifdef _JPEG_DEBUG

printf("Hmax = %d, Vmax = %d\n", iceenv.max_samp_x, iceenv.max_samp_y);

#endif

return ERR_OK;

}

int process_dht(void)

{

int bytes_read = 2;

while (bytes_read < iceenv.cur_segment_len)

{

byte info = iceenv.buffer[iceenv.buf_pos++];

byte type_table = info & 0x10;

struct jpeg_dht *cur_table;

if (!type_table)

//cur_table = iceenv.dc_dht;

{

iceenv.dc_dht[LWR4(info)] = (struct jpeg_dht*)malloc(sizeof(struct jpeg_dht));

cur_table = iceenv.dc_dht[LWR4(info)];

}

else

{

// cur_table = iceenv.ac_dht;

iceenv.ac_dht[LWR4(info)] = (struct jpeg_dht*)malloc(sizeof(struct jpeg_dht));

cur_table = iceenv.ac_dht[LWR4(info)];

}

//cur_table[info & 0xF] = (struct jpeg_dht*)malloc(sizeof(struct jpeg_dht));

memcpy((void*)cur_table->num_codes, (void*)(iceenv.buffer + iceenv.buf_pos), 16);

iceenv.buf_pos += 16;

bytes_read += 16 + 1;

int num_codes = 0;

int i = 0;

for (i = 0; i < 16; i++)

{

num_codes += cur_table->num_codes[i];

}

cur_table->codes = (byte *)malloc(num_codes);

memcpy((void*)cur_table->codes, (void*)(iceenv.buffer + iceenv.buf_pos), num_codes);

#ifdef _JPEG_DEBUG

for (i = 0; i < num_codes; i++)

{

printf("%X ", cur_table->codes[i]);

}

printf("\n");

#endif

iceenv.buf_pos += num_codes;

bytes_read += num_codes;

}

return ERR_OK;

}

int process_sos(void)

{

byte num_components = iceenv.buffer[iceenv.buf_pos++];

if (iceenv.cur_segment_len != 6 + 2 * num_components)

return ERR_INVALID_SEGMENT_SIZE;

if (!iceenv.components)

return ERR_SOF0_MISSING;

int i = 0;

for (i = 0; i < num_components; i++)

{

byte id = iceenv.buffer[iceenv.buf_pos++];

iceenv.components[id-1].id_dht = iceenv.buffer[iceenv.buf_pos++];

}

// Ignore the following 3 bytes

iceenv.buf_pos += 3;

return ERR_OK;

}

int process_dri(void)

{

if (iceenv.cur_segment_len != 4)

return ERR_INVALID_SEGMENT_SIZE;

iceenv.restart_interval = fetch_word();

iceenv.rstcount = iceenv.restart_interval;

return ERR_OK;

}

// Decode a single DU within an MCU

int decode_du(byte id_component)

{

word bit_string = 0;

byte cur_code = 0;

memset(iceenv.block, 0, sizeof(int) * 64);

jpeg_huffman_table cur_table = iceenv.huff_dc[UPR4(iceenv.components[id_component].id_dht)];

cur_code = get_next_code(cur_table);

#ifdef _JPEG_DEBUG

printf("Code found: %X\n", cur_code);

#endif

bit_string = fetch_bits(cur_code);

#ifdef _JPEG_DEBUG

printf("Bits fetched: %d\n", bit_string);

#endif

short value = get_signed_short(bit_string, cur_code);

iceenv.components[id_component].prev_dc += value;

//mcu->dus[id_component][(y*samp_x) + x][0] = cur_mcu > 0 ? (mcus[cur_mcu - 1].dus[id_component][(y*samp_x) + x][0] + dc_value) : dc_value;

iceenv.block[0] = iceenv.components[id_component].prev_dc;

#ifdef _JPEG_DEBUG

printf("DC value: %d, absolute value: %d\n", block[0], value);

#endif

// Dequantize DC value

iceenv.block[0] *= iceenv.qt_tables[iceenv.components[id_component].qt_table][0];

// Switch to AC table

cur_table = iceenv.huff_ac[LWR4(iceenv.components[id_component].id_dht)];

byte block_index = 1;

int had_eob = 0;

while (block_index < 64)

{

cur_code = get_next_code(cur_table);

if (cur_code == 0)

{

#ifdef _JPEG_DEBUG

printf("\tEOB encountered\n");

#endif

had_eob = 1;

break;

}

#ifdef _JPEG_DEBUG

printf("\tSkipping %d zeros\n", (cur_code & 0xF0) >> 4);

#endif

// Skip zeros

block_index += UPR4(cur_code);

if (block_index > 63)

break;

bit_string = fetch_bits(LWR4(cur_code));

#ifdef _JPEG_DEBUG

printf("Fetched %d bits\n", cur_code & 0xF);

#endif

value = get_signed_short(bit_string, LWR4(cur_code));

#ifdef _JPEG_DEBUG

printf("AC value: %d\n", value);

#endif

byte actual_index = jpeg_zzright[block_index];

// Dequantize and unzigzag at the same time

iceenv.block[actual_index] = value * iceenv.qt_tables[iceenv.components[id_component].qt_table][block_index];

block_index++;

#ifdef _JPEG_DEBUG

printf("Dequantized AC value: %d\n", block[actual_index]);

#endif

}

if (block_index > 64)

{

printf("CAUTION: Too many coefs in MCU [%d,%d]\n", iceenv.cur_mcu_x, iceenv.cur_mcu_y);

getc(stdin);

}

#ifdef _JPEG_DEBUG

printf("\n");

#endif

/****************************************************/

/* Perform IDCT */

/****************************************************/

int rowscols;

for (rowscols = 0; rowscols < 8; rowscols++)

{

idctrow(&iceenv.block[8 * rowscols]);

}

for (rowscols = 0; rowscols < 8; rowscols++)

{

int targetPos = ((iceenv.cur_mcu_y * (iceenv.components[id_component].sy << 3) + (iceenv.cur_du_y << 3)) * iceenv.components[id_component].stride) + (iceenv.cur_mcu_x * (iceenv.components[id_component].sx << 3) + (iceenv.cur_du_x << 3));

idctcol(&iceenv.block[rowscols], &iceenv.components[id_component].pixels[targetPos + rowscols], iceenv.components[id_component].stride);

}

return ERR_OK;

}

int decode_mcu(void)

{

int comp;

// Iterate over components (Y, Cb, Cr)

for (comp = 0; comp < iceenv.sof0.num_components; comp++)

{

// Iterate over sampling factors

for (iceenv.cur_du_y = 0; iceenv.cur_du_y < iceenv.components[comp].sy; iceenv.cur_du_y++)

{

for (iceenv.cur_du_x = 0; iceenv.cur_du_x < iceenv.components[comp].sx; iceenv.cur_du_x++)

{

decode_du(comp);

}

}

}

return ERR_OK;

}

int process_rst(void)

{

iceenv.buf_pos++;

iceenv.cur_byte_remaining = 8;

if (iceenv.buffer[iceenv.buf_pos++] != 0xFF || (LWR4(iceenv.buffer[iceenv.buf_pos++])) != iceenv.next_rst_marker)

{

return ERR_INVALID_RST_MARKER;

}

iceenv.next_rst_marker = (iceenv.next_rst_marker + 1) & 7;

iceenv.rstcount = iceenv.restart_interval;

int i = 0;

for (;i<iceenv.sof0.num_components;i++)

iceenv.components[i].prev_dc = 0;

return ERR_OK;

}

int decode_scan(void)

{

#ifdef _JPEG_DEBUG

printf("%d MCUs in total.\n", iceenv.num_mcu_x * iceenv.num_mcu_y);

printf("MCU dimension: %dx%d\n", iceenv.max_samp_x << 3, iceenv.max_samp_y << 3);

#endif

// if (iceenv.scan_buffer[iceenv.buf_pos] == 0xFF && iceenv.scan_buffer[iceenv.buf_pos + 1] == 0x00)

// skip_stuff_byte = 1;

init_idct();

for (iceenv.cur_mcu_x = iceenv.cur_mcu_y = 0;;)

{

//printf("Decoding MCU [%d,%d]\n", iceenv.cur_mcu_x, iceenv.cur_mcu_y);

decode_mcu();

iceenv.cur_mcu_x++;

if (iceenv.cur_mcu_x == iceenv.num_mcu_x)

{

iceenv.cur_mcu_x = 0;

iceenv.cur_mcu_y++;

if (iceenv.cur_mcu_y == iceenv.num_mcu_y)

break;

}

if (!iceenv.restart_interval)

continue;

iceenv.rstcount--;

if (!iceenv.rstcount)

{

int err = process_rst();

if (err != ERR_OK)

return err;

}

}

//if (iceenv.cur_byte_remaining > 0)

iceenv.buf_pos++;

return ERR_OK;

}

int upsample(void)

{

int comp;

for (comp = 0; comp < iceenv.sof0.num_components; comp++)

{

while (iceenv.components[comp].width < iceenv.sof0.width)

#ifndef USE_LANCZOS_UPSAMPLING

upsampleBicubicH(&components[comp]);

#else

upsampleLanczosH(&iceenv.components[comp]);

#endif

while (iceenv.components[comp].height < iceenv.sof0.height)

#ifndef USE_LANCZOS_UPSAMPLING

upsampleBicubicV(&components[comp]);

#else

upsampleLanczosV(&iceenv.components[comp]);

#endif

}

return ERR_OK;

}

int create_image(void)

{

// put image together

iceenv.image = (byte*) malloc((iceenv.sof0.width * iceenv.sof0.height) * iceenv.sof0.num_components);

if (iceenv.sof0.num_components == 3)

{

int x, y;

byte *curImage = iceenv.image;

byte *py = iceenv.components[0].pixels;

byte *pcb = iceenv.components[1].pixels;

byte *pcr = iceenv.components[2].pixels;

for (y = 0; y <iceenv.sof0.height; y++)

{

for (x = 0; x < iceenv.sof0.width; x++)

{

register int cr = pcr[x] - 128;

register int cb = pcb[x] - 128;

// y must be multiplied by 128 because it DOES NOT receive a factor

// during the conversion to RGB

// since the other factors have been multiplied by 128,

// y's factor (which is 1) must be multiplied by 128 as well

register int y = py[x] << 7;

// all conversion constants have been multiplied by 128

*curImage++ = DESCALE8(y + 179 * cr);

*curImage++ = DESCALE8(y - 44 * cb - 91 * cr);

*curImage++ = DESCALE8(y + 227 * cb);

}

py += iceenv.components[0].stride;

pcb += iceenv.components[1].stride;

pcr += iceenv.components[2].stride;

}

}

else

if (iceenv.sof0.num_components == 1)

{

int y = 0;

for (; y < iceenv.sof0.height; y++)

{

memcpy(iceenv.image + (y * iceenv.sof0.width), iceenv.components[0].pixels + (y * iceenv.components[0].stride), iceenv.sof0.width);

}

}

return ERR_OK;

}

int process_segment(void)

{

word marker;

int err;

marker = fetch_word();

if (marker == 0xFFD9)

{

iceenv.eoi = 1;

#ifdef _JPEG_DEBUG

printf("EOI detected! Done.\n");

#endif

return ERR_OK;

}

iceenv.cur_segment_len = fetch_word();

switch (marker)

{

case 0xFFE0:

err = process_app0();

break;

case 0xFFDB:

err = process_dqt();

break;

case 0xFFC0:

err = process_sof0();

break;

case 0xFFC4:

err = process_dht();

break;

case 0xFFDD:

err = process_dri();

break;

case 0xFFDA:

err = gen_huffman_tables();

err = process_sos();

err = decode_scan();

err = upsample();

err = create_image();

break;

case 0xFFC1:

case 0xFFC2:

case 0xFFC3:

case 0xFFC5:

case 0xFFC6:

case 0xFFC7:

case 0xFFC9:

case 0xFFCA:

case 0xFFCB:

case 0xFFCD:

case 0xFFCE:

case 0xFFCF:

err = ERR_NOT_BASELINE;

break;

default:

#ifdef _JPEG_DEBUG

printf("Skipping unknown segment %X\n", marker & 0xFF);

#endif

iceenv.buf_pos += iceenv.cur_segment_len - 2;

err = ERR_OK;

break;

}

return err;

}

void cleanup_dht(void)

{

int i;

for (i = 0; i < 2; i++)

{

if (iceenv.dc_dht[i])

{

free((void*)iceenv.dc_dht[i]->codes);

free((void*)iceenv.dc_dht[i]);

}

if (iceenv.ac_dht[i])

{

free((void*)iceenv.ac_dht[i]->codes);

free((void*)iceenv.ac_dht[i]);

}

}

}

void cleanup_huffman_tables(void)

{

int i, j;

for (i = 0; i < 2; i++)

{

if (iceenv.huff_dc[i])

{

for (j = 0; j < 0xFFFF; j++)

{

if (iceenv.huff_dc[i][j])

free((void*)iceenv.huff_dc[i][j]);

}

free((void*)iceenv.huff_dc[i]);

}

if (iceenv.huff_ac[i])

{

for (j = 0; j < 0xFFFF; j++)

{

if (iceenv.huff_ac[i][j])

free((void*)iceenv.huff_ac[i][j]);

}

free((void*)iceenv.huff_ac[i]);

}

}

}

void cleanup_qt_tables(void)

{

int i;

for (i = 0; i < 4; i++)

{

if (iceenv.qt_tables[i])

free((void*)iceenv.qt_tables[i]);

}

}

void cleanup(void)

{

cleanup_qt_tables();

cleanup_huffman_tables();

free((void*)iceenv.components);

free((void*)iceenv.buffer);

}