X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libopenjpeg%2Fbio.c;h=78fefa794d31ab7741d9cb145dec74783bfd8fbb;hb=b1d8788a464e0de986eabab0fb22c8d857b89c78;hp=b9e32162b0d8c102e109082c1f87eebe18733284;hpb=ec9bd9f6a455a83da8c2c77f5b2628b416cca18f;p=openjpeg.git diff --git a/libopenjpeg/bio.c b/libopenjpeg/bio.c index b9e32162..78fefa79 100644 --- a/libopenjpeg/bio.c +++ b/libopenjpeg/bio.c @@ -1,8 +1,11 @@ /* - * Copyright (c) 2001-2002, David Janssens - * Copyright (c) 2003, Yannick Verschueren - * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium - * + * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium + * Copyright (c) 2002-2007, Professor Benoit Macq + * Copyright (c) 2001-2003, David Janssens + * Copyright (c) 2002-2003, Yannick Verschueren + * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe + * Copyright (c) 2005, Herve Drolon, FreeImage Team + * Copyright (c) 2008, Jerome Fimes, Communications & Systemes * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -28,167 +31,159 @@ */ #include "bio.h" -#include -#include +#include "opj_malloc.h" -static unsigned char *bio_start; /* pointer to the start of the buffer */ -static unsigned char *bio_end; /* pointer to the end of the buffer */ -static unsigned char *bio_bp; /* pointer to the present position in the buffer */ -static unsigned int bio_buf; /* temporary place where each byte is read or written */ -static int bio_ct; /* coder : number of bits free to write // decoder : number of bits read */ +/** @defgroup BIO BIO - Individual bit input-output stream */ +/*@{*/ -extern jmp_buf j2k_error; +/** @name Local static functions */ +/*@{*/ -/* - * Number of bytes written. - */ -int bio_numbytes() -{ - return bio_bp - bio_start; +/** +Write a bit +@param bio BIO handle +@param b Bit to write (0 or 1) +*/ +static void bio_putbit(opj_bio_t *bio, OPJ_UINT32 b); +/** +Read a bit +@param bio BIO handle +@return Returns the read bit +*/ +static OPJ_UINT32 bio_getbit(opj_bio_t *bio); +/** +Write a byte +@param bio BIO handle +@return Returns 0 if successful, returns 1 otherwise +*/ +static bool bio_byteout(opj_bio_t *bio); +/** +Read a byte +@param bio BIO handle +@return Returns 0 if successful, returns 1 otherwise +*/ +static bool bio_bytein(opj_bio_t *bio); + +/*@}*/ + +/*@}*/ + +/* +========================================================== + local functions +========================================================== +*/ + +static bool bio_byteout(opj_bio_t *bio) { + bio->buf = (bio->buf << 8) & 0xffff; + bio->ct = bio->buf == 0xff00 ? 7 : 8; + if (bio->bp >= bio->end) { + return true; + } + *bio->bp++ = bio->buf >> 8; + return false; } -/* - * Init encoder. - * - * bp : Output buffer - * len : Output buffer length - */ -void bio_init_enc(unsigned char *bp, int len) -{ - bio_start = bp; - bio_end = bp + len; - bio_bp = bp; - bio_buf = 0; - bio_ct = 8; +static bool bio_bytein(opj_bio_t *bio) { + bio->buf = (bio->buf << 8) & 0xffff; + bio->ct = bio->buf == 0xff00 ? 7 : 8; + if (bio->bp >= bio->end) { + return true; + } + bio->buf |= *bio->bp++; + return false; } -/* - * Init decoder. - * - * bp : Input buffer - * len : Input buffer length - */ -void bio_init_dec(unsigned char *bp, int len) -{ - bio_start = bp; - bio_end = bp + len; - bio_bp = bp; - bio_buf = 0; - bio_ct = 0; +static void bio_putbit(opj_bio_t *bio, OPJ_UINT32 b) { + if (bio->ct == 0) { + bio_byteout(bio); + } + bio->ct--; + bio->buf |= b << bio->ct; } -/* - * Write byte. --> function modified to eliminate longjmp !!! - * - */ -int bio_byteout() -{ - bio_buf = (bio_buf << 8) & 0xffff; - bio_ct = bio_buf == 0xff00 ? 7 : 8; - if (bio_bp >= bio_end) - return 1; - *bio_bp++ = bio_buf >> 8; - return 0; +static OPJ_UINT32 bio_getbit(opj_bio_t *bio) { + if (bio->ct == 0) { + bio_bytein(bio); + } + bio->ct--; + return (bio->buf >> bio->ct) & 1; } -/* - * Read byte. --> function modified to eliminate longjmp !! - * - */ -int bio_bytein() -{ - bio_buf = (bio_buf << 8) & 0xffff; - bio_ct = bio_buf == 0xff00 ? 7 : 8; - if (bio_bp >= bio_end) - return 1; - bio_buf |= *bio_bp++; - return 0; +/* +========================================================== + Bit Input/Output interface +========================================================== +*/ + +opj_bio_t* bio_create(void) { + opj_bio_t *bio = (opj_bio_t*)opj_malloc(sizeof(opj_bio_t)); + return bio; } -/* - * Write bit. - * - * b : Bit to write (0 or 1) - */ -void bio_putbit(int b) -{ - if (bio_ct == 0) { - bio_byteout(); - } - bio_ct--; - bio_buf |= b << bio_ct; +void bio_destroy(opj_bio_t *bio) { + if(bio) { + opj_free(bio); + } } -/* - * Read bit. - * - */ -int bio_getbit() -{ - if (bio_ct == 0) { - bio_bytein(); - } - bio_ct--; - return (bio_buf >> bio_ct) & 1; +OPJ_UINT32 bio_numbytes(opj_bio_t *bio) { + return (bio->bp - bio->start); } -/* - * Write bits. - * - * v : Value of bits - * n : Number of bits to write - */ -void bio_write(int v, int n) -{ - int i; - for (i = n - 1; i >= 0; i--) { - bio_putbit((v >> i) & 1); - } +void bio_init_enc(opj_bio_t *bio, OPJ_BYTE *bp, OPJ_UINT32 len) { + bio->start = bp; + bio->end = bp + len; + bio->bp = bp; + bio->buf = 0; + bio->ct = 8; } -/* - * Read bits. - * - * n : Number of bits to read - */ -int bio_read(int n) -{ - int i, v; - v = 0; - for (i = n - 1; i >= 0; i--) { - v += bio_getbit() << i; - } - return v; +void bio_init_dec(opj_bio_t *bio, OPJ_BYTE *bp, OPJ_UINT32 len) { + bio->start = bp; + bio->end = bp + len; + bio->bp = bp; + bio->buf = 0; + bio->ct = 0; } -/* - * Flush bits. Modified to eliminate longjmp !! - * - */ -int bio_flush() -{ - bio_ct = 0; - if (bio_byteout()) - return 1; - if (bio_ct == 7) { - bio_ct = 0; - - if (bio_byteout()) - return 1; - } - return 0; +void bio_write(opj_bio_t *bio, OPJ_UINT32 v, OPJ_UINT32 n) { + OPJ_UINT32 i; + for (i = n - 1; i != -1 ; --i) { + bio_putbit(bio, (v >> i) & 1); + } } -/* - * Passes the ending bits (coming from flushing) - */ -int bio_inalign() -{ - bio_ct = 0; - if ((bio_buf & 0xff) == 0xff) { - if (bio_bytein()) - return 1; - bio_ct = 0; - } - return 0; +OPJ_UINT32 bio_read(opj_bio_t *bio, OPJ_UINT32 n) { + OPJ_UINT32 i, v; + v = 0; + for (i = n - 1; i != -1 ; --i) { + v += bio_getbit(bio) << i; + } + return v; +} + +bool bio_flush(opj_bio_t *bio) { + bio->ct = 0; + if (bio_byteout(bio)) { + return true; + } + if (bio->ct == 7) { + bio->ct = 0; + if (bio_byteout(bio)) { + return true; + } + } + return false; +} + +bool bio_inalign(opj_bio_t *bio) { + bio->ct = 0; + if ((bio->buf & 0xff) == 0xff) { + if (bio_bytein(bio)) { + return true; + } + bio->ct = 0; + } + return false; }