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

*

* This software module was originally contributed by Microsoft

* Corporation in the course of development of the

* ITU-T T.832 | ISO/IEC 29199-2 ("JPEG XR") format standard for

* reference purposes and its performance may not have been optimized.

*

* This software module is an implementation of one or more

* tools as specified by the JPEG XR standard.

*

* ITU/ISO/IEC give You a royalty-free, worldwide, non-exclusive

* copyright license to copy, distribute, and make derivative works

* of this software module or modifications thereof for use in

* products claiming conformance to the JPEG XR standard as

* specified by ITU-T T.832 | ISO/IEC 29199-2.

*

* ITU/ISO/IEC give users the same free license to this software

* module or modifications thereof for research purposes and further

* ITU/ISO/IEC standardization.

*

* Those intending to use this software module in products are advised

* that its use may infringe existing patents. ITU/ISO/IEC have no

* liability for use of this software module or modifications thereof.

*

* Copyright is not released for products that do not conform to

* to the JPEG XR standard as specified by ITU-T T.832 |

* ISO/IEC 29199-2.

*

* Microsoft Corporation retains full right to modify and use the code

* for its own purpose, to assign or donate the code to a third party,

* and to inhibit third parties from using the code for products that

* do not conform to the JPEG XR standard as specified by ITU-T T.832 |

* ISO/IEC 29199-2.

*

* This copyright notice must be included in all copies or derivative

* works.

*

* Copyright (c) ITU-T/ISO/IEC 2008, 2009.

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

#ifdef _MSC_VER

#pragma comment (user,"$Id: io.c,v 1.14 2008/03/05 06:58:10 gus Exp $")

#else

#ident "$Id: io.c,v 1.14 2008/03/05 06:58:10 gus Exp $"

#endif

# include "jxr_priv.h"

# include <assert.h>

void _jxr_rbitstream_initialize(struct rbitstream*str, FILE*fd)

{

    str->bits_avail = 0;

    str->fd = fd;

    str->read_count = 0;

}

size_t _jxr_rbitstream_bitpos(struct rbitstream*str)

{

    return str->read_count*8 - str->bits_avail;

}

void _jxr_rbitstream_mark(struct rbitstream*str)

{

    assert(str->bits_avail == 0);

    str->mark_stream_position = ftell(str->fd);

    assert(str->mark_stream_position >= 0);

    str->read_count = 0;

}

void _jxr_rbitstream_seek(struct rbitstream*str, uint64_t off)

{

    int rc;

    assert(str->bits_avail == 0);

    /* NOTE: Should be using fseek64? */

    rc = fseek(str->fd, str->mark_stream_position + (long)off, SEEK_SET);

    str->read_count = (size_t) off;

    assert(rc >= 0);

}

/*

* Cause the bitstream to consume enough bits that the next bit is on

* a byte boundary. This is for getting alignment, which is sometimes

* needed.

*/

void _jxr_rbitstream_syncbyte(struct rbitstream*str)

{

    str->bits_avail = 0;

}

/*

* Get the next 8 bits from the input file and adjust the bitstream

* pointers so that the bits can be read out.

*/

static int get_byte(struct rbitstream*str)

{

    int tmp;

    assert(str->bits_avail == 0);

    tmp = fgetc(str->fd);

    if (tmp == EOF)

        return EOF;

    str->byte = tmp;

    str->bits_avail = 8;

    str->read_count += 1;

#if 0

    DEBUG(" in byte: 0x%02x (bitpos=%zd)\n",

        str->byte, str->read_count*8-8);

#endif

    return 0;

}

/*

* The following read integers of various width from the data input

* stream. This handles the bit ordering and packing of the bits.

*/

int _jxr_rbitstream_uint1(struct rbitstream*str)

{

    if (str->bits_avail == 0) {

        get_byte(str);

    }

    assert(str->bits_avail > 0);

    str->bits_avail -= 1;

    return (str->byte & (1 << str->bits_avail))? 1 : 0;

}

uint8_t _jxr_rbitstream_uint2(struct rbitstream*str)

{

    uint8_t tmp = 0;

    tmp |= _jxr_rbitstream_uint1(str);

    tmp <<= 1;

    tmp |= _jxr_rbitstream_uint1(str);

    return tmp;

}

uint8_t _jxr_rbitstream_uint3(struct rbitstream*str)

{

    uint8_t tmp = 0;

    tmp |= _jxr_rbitstream_uint1(str);

    tmp <<= 1;

    tmp |= _jxr_rbitstream_uint1(str);

    tmp <<= 1;

    tmp |= _jxr_rbitstream_uint1(str);

    return tmp;

}

uint8_t _jxr_rbitstream_uint4(struct rbitstream*str)

{

    uint8_t tmp;

    int idx;

    if (str->bits_avail == 0)

        get_byte(str);

    if (str->bits_avail == 4) {

        str->bits_avail = 0;

        return str->byte & 0x0f;

    }

    tmp = 0;

    for (idx = 0 ; idx < 4 ; idx += 1) {

        tmp <<= 1;

        tmp |= _jxr_rbitstream_uint1(str);

    }

    return tmp;

}

uint8_t _jxr_rbitstream_uint6(struct rbitstream*str)

{

    uint8_t tmp;

    int idx;

    tmp = _jxr_rbitstream_uint4(str);

    for (idx = 4 ; idx < 6 ; idx += 1) {

        tmp <<= 1;

        tmp |= _jxr_rbitstream_uint1(str);

    }

    return tmp;

}

uint8_t _jxr_rbitstream_uint8(struct rbitstream*str)

{

    uint8_t tmp;

    int idx;

    if (str->bits_avail == 0)

        get_byte(str);

    if (str->bits_avail == 8) {

        str->bits_avail = 0;

        return str->byte;

    }

    tmp = 0;

    for (idx = 0 ; idx < 8 ; idx += 1) {

        tmp <<= 1;

        tmp |= _jxr_rbitstream_uint1(str);

    }

    return tmp;

}

uint16_t _jxr_rbitstream_uint12(struct rbitstream*str)

{

    uint16_t tmp = 0;

    tmp = _jxr_rbitstream_uint8(str);

    tmp <<= 4;

    tmp |= _jxr_rbitstream_uint4(str);

    return tmp;

}

uint16_t _jxr_rbitstream_uint15(struct rbitstream*str)

{

    uint16_t tmp = 0;

    tmp = _jxr_rbitstream_uint8(str);

    tmp <<= 4;

    tmp |= _jxr_rbitstream_uint4(str);

    tmp <<= 3;

    tmp |= _jxr_rbitstream_uint3(str);

    return tmp;

}

uint16_t _jxr_rbitstream_uint16(struct rbitstream*str)

{

    uint16_t tmp = 0;

    tmp = _jxr_rbitstream_uint8(str);

    tmp <<= 8;

    tmp |= _jxr_rbitstream_uint8(str);

    return tmp;

}

uint32_t _jxr_rbitstream_uint32(struct rbitstream*str)

{

    uint32_t tmp = 0;

    tmp = _jxr_rbitstream_uint16(str);

    tmp <<= 16;

    tmp |= _jxr_rbitstream_uint16(str);

    return tmp;

}

uint32_t _jxr_rbitstream_uintN(struct rbitstream*str, int N)

{

    uint32_t tmp = 0;

    assert(N <= 32);

    while (N > 0) {

        tmp <<= 1;

        tmp |= _jxr_rbitstream_uint1(str);

        N -= 1;

    }

    return tmp;

}

int _jxr_rbitstream_intE(struct rbitstream*str, int code_size,

                         const unsigned char*codeb, const signed char*codev)

{

    int bits = 0;

    unsigned val = 0;

    while (codeb[val << (code_size-bits)] != bits) {

        val <<= 1;

        val |= _jxr_rbitstream_uint1(str);

        bits += 1;

        assert(bits <= code_size);

    }

    return codev[val << (code_size-bits)];

}

int64_t _jxr_rbitstream_intVLW(struct rbitstream*str)

{

    uint64_t val = _jxr_rbitstream_uint8(str);

    if (val < 0xfb) {

        uint64_t tmp = _jxr_rbitstream_uint8(str);

        val = val*256 + tmp;

    } else if (val == 0xfb) {

        val = _jxr_rbitstream_uint32(str);

    } else if (val == 0xfc) {

        uint64_t tmp;

        val = _jxr_rbitstream_uint32(str);

        tmp = _jxr_rbitstream_uint32(str);

        val = (val << (uint64_t)32) + tmp;

    } else {

        return 0;

    }

    return val;

}

void _jxr_wbitstream_initialize(struct wbitstream*str, FILE*fd)

{

    str->byte = 0;

    str->bits_ready = 0;

    str->fd = fd;

    str->write_count = 0;

}

size_t _jxr_wbitstream_bitpos(struct wbitstream*str)

{

    return str->write_count*8 + str->bits_ready;

}

static void put_byte(struct wbitstream*str)

{

    assert(str->bits_ready == 8);

    fputc(str->byte, str->fd);

    str->byte = 0;

    str->bits_ready = 0;

    str->write_count += 1;

}

void _jxr_wbitstream_syncbyte(struct wbitstream*str)

{

    if (str->bits_ready > 0)

        str->bits_ready = 8;

}

void _jxr_wbitstream_flush(struct wbitstream*str)

{

    _jxr_wbitstream_syncbyte(str);

    if (str->bits_ready > 0)

        put_byte(str);

}

void _jxr_wbitstream_uint1(struct wbitstream*str, int val)

{

    if (str->bits_ready == 8)

        put_byte(str);

    if (val)

        str->byte |= 0x80 >> str->bits_ready;

    str->bits_ready += 1;

}

void _jxr_wbitstream_uint2(struct wbitstream*str, uint8_t val)

{

    int idx;

    for (idx = 0 ; idx < 2 ; idx += 1) {

        _jxr_wbitstream_uint1(str, val & (0x02 >> idx));

    }

}

void _jxr_wbitstream_uint3(struct wbitstream*str, uint8_t val)

{

    int idx;

    for (idx = 0 ; idx < 3 ; idx += 1) {

        _jxr_wbitstream_uint1(str, val & (0x04 >> idx));

    }

}

void _jxr_wbitstream_uint4(struct wbitstream*str, uint8_t val)

{

    int idx;

    for (idx = 0 ; idx < 4 ; idx += 1) {

        _jxr_wbitstream_uint1(str, val & (0x08 >> idx));

    }

}

void _jxr_wbitstream_uint6(struct wbitstream*str, uint8_t val)

{

    int idx;

    for (idx = 0 ; idx < 6 ; idx += 1) {

        _jxr_wbitstream_uint1(str, val & (0x20 >> idx));

    }

}

void _jxr_wbitstream_uint8(struct wbitstream*str, uint8_t val)

{

    int idx;

    if (str->bits_ready == 8)

        put_byte(str);

    if (str->bits_ready == 0) {

        str->bits_ready = 8;

        str->byte = val;

        return;

    }

    for (idx = 0 ; idx < 8 ; idx += 1) {

        _jxr_wbitstream_uint1(str, val & (0x80 >> idx));

    }

}

void _jxr_wbitstream_uint12(struct wbitstream*str, uint16_t val)

{

    int idx;

    for (idx = 0 ; idx < 12 ; idx += 1) {

        _jxr_wbitstream_uint1(str, val & (0x800 >> idx));

    }

}

void _jxr_wbitstream_uint15(struct wbitstream*str, uint16_t val)

{

    int idx;

    for (idx = 0 ; idx < 15 ; idx += 1) {

        _jxr_wbitstream_uint1(str, val & (0x4000 >> idx));

    }

}

void _jxr_wbitstream_uint16(struct wbitstream*str, uint16_t val)

{

    _jxr_wbitstream_uint8(str, val >> 8);

    _jxr_wbitstream_uint8(str, val >> 0);

}

void _jxr_wbitstream_uint32(struct wbitstream*str, uint32_t val)

{

    _jxr_wbitstream_uint8(str, val >> 24);

    _jxr_wbitstream_uint8(str, val >> 16);

    _jxr_wbitstream_uint8(str, val >> 8);

    _jxr_wbitstream_uint8(str, val >> 0);

}

void _jxr_wbitstream_uintN(struct wbitstream*str, uint32_t val, int N)

{

    assert(N <= 32);

    while (N > 0) {

        _jxr_wbitstream_uint1(str, 1 & (val >> (N-1)));

        N -= 1;

    }

}

void _jxr_wbitstream_intVLW(struct wbitstream*str, uint64_t val)

{

    if (val == 0) {

        _jxr_wbitstream_uint8(str, 0xfe);

    } else if (val < 0xfb00) {

        _jxr_wbitstream_uint16(str, (uint16_t)val);

    } else if (val < 0x100000000ULL) {

        _jxr_wbitstream_uint8(str, 0xfb);

        _jxr_wbitstream_uint32(str, (uint32_t)val);

    } else {

        _jxr_wbitstream_uint8(str, 0xfc);

        _jxr_wbitstream_uint32(str, val >> 32ULL);

        _jxr_wbitstream_uint32(str, val >> 0ULL);

    }

}

void _jxr_wbitstream_mark(struct wbitstream*str)

{

    if (str->bits_ready == 8)

        _jxr_wbitstream_flush(str);

    assert(str->bits_ready == 0);

    /* str->mark_stream_position = ftell(str->fd); */

    str->write_count = 0;

}

const char* _jxr_vlc_index_name(int vlc)

{

    switch (vlc) {

        case AbsLevelIndDCLum: return "AbsLevelIndDCLum";

        case AbsLevelIndDCChr: return "AbsLevelIndDCChr";

        case DecFirstIndLPLum: return "DecFirstIndLPLum";

        case AbsLevelIndLP0: return "AbsLevelIndLP0";

        case AbsLevelIndLP1: return "AbsLevelIndLP1";

        case AbsLevelIndHP0: return "AbsLevelIndHP0";

        case AbsLevelIndHP1: return "AbsLevelIndHP1";

        case DecIndLPLum0: return "DecIndLPLum0";

        case DecIndLPLum1: return "DecIndLPLum1";

        case DecFirstIndLPChr: return "DecFirstIndLPChr";

        case DecIndLPChr0: return "DecIndLPChr0";

        case DecIndLPChr1: return "DecIndLPChr1";

        case DecNumCBP: return "DecNumCBP";

        case DecNumBlkCBP: return "DecNumBlkCBP";

        case DecIndHPLum0: return "DecIndHPLum0";

        case DecIndHPLum1: return "DecIndHPLum1";

        case DecFirstIndHPLum: return "DecFirstIndHPLum";

        case DecFirstIndHPChr: return "DecFirstIndHPChr";

        case DecIndHPChr0: return "DecIndHPChr0";

        case DecIndHPChr1: return "DecIndHPChr1";

        default: return "?????";

    }

}

/*

* $Log: io.c,v $

* Revision 1.16 2009/05/29 12:00:00 microsoft

* Reference Software v1.6 updates.

*

* Revision 1.15 2009/04/13 12:00:00 microsoft

* Reference Software v1.5 updates.

*

* Revision 1.14 2008/03/05 06:58:10 gus

* *** empty log message ***

*

* Revision 1.13 2008/02/28 18:50:31 steve

* Portability fixes.

*

* Revision 1.12 2008/02/26 23:52:44 steve

* Remove ident for MS compilers.

*

* Revision 1.11 2007/12/07 01:20:34 steve

* Fix adapt not adapting on line ends.

*

* Revision 1.10 2007/12/06 17:53:35 steve

* No longer need bitval dump.

*

* Revision 1.9 2007/11/30 01:50:58 steve

* Compression of DCONLY GRAY.

*

* Revision 1.8 2007/11/26 01:47:15 steve

* Add copyright notices per MS request.

*

* Revision 1.7 2007/11/19 18:22:34 steve

* Skip ESCaped FLEXBITS tiles.

*

* Revision 1.6 2007/11/14 23:56:17 steve

* Fix TILE ordering, using seeks, for FREQUENCY mode.

*

* Revision 1.5 2007/11/08 19:38:38 steve

* Get stub DCONLY compression to work.

*

* Revision 1.4 2007/11/08 02:52:32 steve

* Some progress in some encoding infrastructure.

*

* Revision 1.3 2007/08/15 01:54:11 steve

* Add level2 filter to decoder.

*

* Revision 1.2 2007/06/21 17:31:22 steve

* Successfully parse LP components.

*

* Revision 1.1 2007/06/06 17:19:12 steve

* Introduce to CVS.

*

*/