Revert "OpenJPEG: update to 2.1 from 1.5"
[blender.git] / extern / libopenjpeg / bio.c
index 5d49580178bbec81e7368f93e83d9ad9834240aa..f04f3e503fb38effb81f9d94a313837a1b0195e9 100644 (file)
@@ -1,15 +1,9 @@
 /*
- * The copyright in this software is being made available under the 2-clauses 
- * BSD License, included below. This software may be subject to other third 
- * party and contributor rights, including patent rights, and no such rights
- * are granted under this license.
- *
- * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
- * Copyright (c) 2002-2014, Professor Benoit Macq
+ * 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 
- * Copyright (c) 2003-2014, Antonin Descampe
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  * All rights reserved.
  *
@@ -48,25 +42,25 @@ Write a bit
 @param bio BIO handle
 @param b Bit to write (0 or 1)
 */
-static void opj_bio_putbit(opj_bio_t *bio, OPJ_UINT32 b);
+static void bio_putbit(opj_bio_t *bio, unsigned int b);
 /**
 Read a bit
 @param bio BIO handle
 @return Returns the read bit
 */
-static OPJ_UINT32 opj_bio_getbit(opj_bio_t *bio);
+static int bio_getbit(opj_bio_t *bio);
 /**
 Write a byte
 @param bio BIO handle
-@return Returns OPJ_TRUE if successful, returns OPJ_FALSE otherwise
+@return Returns 0 if successful, returns 1 otherwise
 */
-static OPJ_BOOL opj_bio_byteout(opj_bio_t *bio);
+static int bio_byteout(opj_bio_t *bio);
 /**
 Read a byte
 @param bio BIO handle
-@return Returns OPJ_TRUE if successful, returns OPJ_FALSE otherwise
+@return Returns 0 if successful, returns 1 otherwise
 */
-static OPJ_BOOL opj_bio_bytein(opj_bio_t *bio);
+static int bio_bytein(opj_bio_t *bio);
 
 /*@}*/
 
@@ -78,37 +72,37 @@ static OPJ_BOOL opj_bio_bytein(opj_bio_t *bio);
 ==========================================================
 */
 
-OPJ_BOOL opj_bio_byteout(opj_bio_t *bio) {
+static int 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 OPJ_FALSE;
+               return 1;
        }
-       *bio->bp++ = (OPJ_BYTE)(bio->buf >> 8);
-       return OPJ_TRUE;
+       *bio->bp++ = (unsigned char)(bio->buf >> 8);
+       return 0;
 }
 
-OPJ_BOOL opj_bio_bytein(opj_bio_t *bio) {
+static int 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 OPJ_FALSE;
+               return 1;
        }
        bio->buf |= *bio->bp++;
-       return OPJ_TRUE;
+       return 0;
 }
 
-void opj_bio_putbit(opj_bio_t *bio, OPJ_UINT32 b) {
+static void bio_putbit(opj_bio_t *bio, unsigned int b) {
        if (bio->ct == 0) {
-               opj_bio_byteout(bio); /* MSD: why not check the return value of this function ? */
+               bio_byteout(bio);
        }
        bio->ct--;
        bio->buf |= b << bio->ct;
 }
 
-OPJ_UINT32 opj_bio_getbit(opj_bio_t *bio) {
+static int bio_getbit(opj_bio_t *bio) {
        if (bio->ct == 0) {
-               opj_bio_bytein(bio); /* MSD: why not check the return value of this function ? */
+               bio_bytein(bio);
        }
        bio->ct--;
        return (bio->buf >> bio->ct) & 1;
@@ -120,22 +114,22 @@ OPJ_UINT32 opj_bio_getbit(opj_bio_t *bio) {
 ==========================================================
 */
 
-opj_bio_t* opj_bio_create(void) {
+opj_bio_t* bio_create(void) {
        opj_bio_t *bio = (opj_bio_t*)opj_malloc(sizeof(opj_bio_t));
        return bio;
 }
 
-void opj_bio_destroy(opj_bio_t *bio) {
+void bio_destroy(opj_bio_t *bio) {
        if(bio) {
                opj_free(bio);
        }
 }
 
-ptrdiff_t opj_bio_numbytes(opj_bio_t *bio) {
-       return (bio->bp - bio->start);
+int bio_numbytes(opj_bio_t *bio) {
+       return (int)(bio->bp - bio->start);
 }
 
-void opj_bio_init_enc(opj_bio_t *bio, OPJ_BYTE *bp, OPJ_UINT32 len) {
+void bio_init_enc(opj_bio_t *bio, unsigned char *bp, int len) {
        bio->start = bp;
        bio->end = bp + len;
        bio->bp = bp;
@@ -143,7 +137,7 @@ void opj_bio_init_enc(opj_bio_t *bio, OPJ_BYTE *bp, OPJ_UINT32 len) {
        bio->ct = 8;
 }
 
-void opj_bio_init_dec(opj_bio_t *bio, OPJ_BYTE *bp, OPJ_UINT32 len) {
+void bio_init_dec(opj_bio_t *bio, unsigned char *bp, int len) {
        bio->start = bp;
        bio->end = bp + len;
        bio->bp = bp;
@@ -151,44 +145,43 @@ void opj_bio_init_dec(opj_bio_t *bio, OPJ_BYTE *bp, OPJ_UINT32 len) {
        bio->ct = 0;
 }
 
-void opj_bio_write(opj_bio_t *bio, OPJ_UINT32 v, OPJ_UINT32 n) {
-       OPJ_UINT32 i;
-       for (i = n - 1; i < n; i--) {
-               opj_bio_putbit(bio, (v >> i) & 1);
+void bio_write(opj_bio_t *bio, int v, int n) {
+       int i;
+       for (i = n - 1; i >= 0; i--) {
+               bio_putbit(bio, (v >> i) & 1);
        }
 }
 
-OPJ_UINT32 opj_bio_read(opj_bio_t *bio, OPJ_UINT32 n) {
-       OPJ_UINT32 i;
-    OPJ_UINT32 v;
+int bio_read(opj_bio_t *bio, int n) {
+       int i, v;
        v = 0;
-       for (i = n - 1; i < n; i--) {
-               v += opj_bio_getbit(bio) << i;
+       for (i = n - 1; i >= 0; i--) {
+               v += bio_getbit(bio) << i;
        }
        return v;
 }
 
-OPJ_BOOL opj_bio_flush(opj_bio_t *bio) {
+int bio_flush(opj_bio_t *bio) {
        bio->ct = 0;
-       if (! opj_bio_byteout(bio)) {
-               return OPJ_FALSE;
+       if (bio_byteout(bio)) {
+               return 1;
        }
        if (bio->ct == 7) {
                bio->ct = 0;
-               if (! opj_bio_byteout(bio)) {
-                       return OPJ_FALSE;
+               if (bio_byteout(bio)) {
+                       return 1;
                }
        }
-       return OPJ_TRUE;
+       return 0;
 }
 
-OPJ_BOOL opj_bio_inalign(opj_bio_t *bio) {
+int bio_inalign(opj_bio_t *bio) {
        bio->ct = 0;
        if ((bio->buf & 0xff) == 0xff) {
-               if (! opj_bio_bytein(bio)) {
-                       return OPJ_FALSE;
+               if (bio_bytein(bio)) {
+                       return 1;
                }
                bio->ct = 0;
        }
-       return OPJ_TRUE;
+       return 0;
 }