src/lib/openjpip/faixbox_manager.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
   5  * Copyright (c) 2002-2014, Professor Benoit Macq
   6  * Copyright (c) 2010-2011, Kaori Hagihara
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include "faixbox_manager.h"
  34 #include "opj_inttypes.h"
  35
  36 #ifdef SERVER
  37 #include "fcgi_stdio.h"
  38 #define logstream FCGI_stdout
  39 #else
  40 #define FCGI_stdout stdout
  41 #define FCGI_stderr stderr
  42 #define logstream stderr
  43 #endif /*SERVER*/
  44
  45 faixbox_param_t * gene_faixbox(box_param_t *box)
  46 {
  47     faixbox_param_t *faix;
  48     size_t numOfelem;
  49     long pos = 0;
  50
  51     faix = (faixbox_param_t *)malloc(sizeof(faixbox_param_t));
  52
  53     faix->version = fetch_DBox1byte(box, (pos += 1) - 1);
  54
  55     if (3 < faix->version) {
  56         fprintf(FCGI_stderr, "Error: version %d in faix box is reserved for ISO use.\n",
  57                 faix->version);
  58         free(faix);
  59         return NULL;
  60     }
  61
  62     if (faix->version % 2) {
  63         subfaixbox8_param_t *subfaixbox;
  64         size_t i;
  65
  66         faix->subfaixbox.byte8_params = (subfaixbox8_param_t *)malloc(sizeof(
  67                                             subfaixbox8_param_t));
  68
  69         subfaixbox = faix->subfaixbox.byte8_params;
  70         subfaixbox->nmax = fetch_DBox8bytebigendian(box, (pos += 8) - 8);
  71         subfaixbox->m    = fetch_DBox8bytebigendian(box, (pos += 8) - 8);
  72
  73         numOfelem = subfaixbox->nmax * subfaixbox->m;
  74
  75         subfaixbox->elem = (faixelem8_param_t *)malloc(numOfelem * sizeof(
  76                                faixelem8_param_t));
  77
  78         if (faix->version == 3) {
  79             subfaixbox->aux = (Byte4_t *)malloc(numOfelem * sizeof(Byte4_t));
  80         }
  81
  82         for (i = 0; i < numOfelem; i++) {
  83             subfaixbox->elem[i].off = fetch_DBox8bytebigendian(box, (pos += 8) - 8);
  84             subfaixbox->elem[i].len = fetch_DBox8bytebigendian(box, (pos += 8) - 8);
  85             if (faix->version == 3) {
  86                 subfaixbox->aux[i] = fetch_DBox4bytebigendian(box, (pos += 4) - 4);
  87             }
  88         }
  89     } else {
  90         subfaixbox4_param_t *subfaixbox;
  91         size_t i;
  92
  93         faix->subfaixbox.byte4_params = (subfaixbox4_param_t *)malloc(sizeof(
  94                                             subfaixbox4_param_t));
  95
  96         subfaixbox = faix->subfaixbox.byte4_params;
  97         subfaixbox->nmax = fetch_DBox4bytebigendian(box, (pos += 4) - 4);
  98         subfaixbox->m    = fetch_DBox4bytebigendian(box, (pos += 4) - 4);
  99
 100         numOfelem = subfaixbox->nmax * subfaixbox->m;
 101
 102         subfaixbox->elem = (faixelem4_param_t *)malloc(numOfelem * sizeof(
 103                                faixelem4_param_t));
 104
 105         if (faix->version == 2) {
 106             subfaixbox->aux = (Byte4_t *)malloc(numOfelem * sizeof(Byte4_t));
 107         }
 108
 109         for (i = 0; i < numOfelem; i++) {
 110             subfaixbox->elem[i].off = fetch_DBox4bytebigendian(box, (pos += 4) - 4);
 111             subfaixbox->elem[i].len = fetch_DBox4bytebigendian(box, (pos += 4) - 4);
 112             if (faix->version == 2) {
 113                 subfaixbox->aux[i] = fetch_DBox4bytebigendian(box, (pos += 4) - 4);
 114             }
 115         }
 116     }
 117     return faix;
 118 }
 119
 120 void print_faixbox(faixbox_param_t *faix)
 121 {
 122     Byte8_t i, j;
 123
 124     fprintf(logstream, "faix box info\n");
 125     fprintf(logstream, "\tversion: %d\n", faix->version);
 126
 127     fprintf(logstream, "\t nmax: %#" PRIx64 " = %" PRId64 "\n", get_nmax(faix),
 128             get_nmax(faix));
 129     fprintf(logstream, "\t m: %#" PRIx64 " = %" PRId64 "\n", get_m(faix),
 130             get_m(faix));
 131
 132     for (i = 0; i < get_m(faix); i++) {
 133         for (j = 0; j < get_nmax(faix); j++) {
 134             fprintf(logstream, "\t off = %#" PRIx64 ", len = %#" PRIx64 "",
 135                     get_elemOff(faix, j, i), get_elemLen(faix, j, i));
 136             if (2 <= faix->version) {
 137                 fprintf(logstream, ", aux = %#x", get_elemAux(faix, j, i));
 138             }
 139             fprintf(logstream, "\n");
 140         }
 141         fprintf(logstream, "\n");
 142     }
 143 }
 144
 145 void delete_faixbox(faixbox_param_t **faix)
 146 {
 147     if ((*faix)->version % 2) {
 148         free((*faix)->subfaixbox.byte8_params->elem);
 149         if ((*faix)->version == 3) {
 150             free((*faix)->subfaixbox.byte8_params->aux);
 151         }
 152         free((*faix)->subfaixbox.byte8_params);
 153     } else {
 154         free((*faix)->subfaixbox.byte4_params->elem);
 155         if ((*faix)->version == 2) {
 156             free((*faix)->subfaixbox.byte4_params->aux);
 157         }
 158         free((*faix)->subfaixbox.byte4_params);
 159     }
 160     free(*faix);
 161 }
 162
 163 Byte8_t get_nmax(faixbox_param_t *faix)
 164 {
 165     if (faix->version % 2) {
 166         return faix->subfaixbox.byte8_params->nmax;
 167     } else {
 168         return (Byte8_t)faix->subfaixbox.byte4_params->nmax;
 169     }
 170 }
 171
 172 Byte8_t get_m(faixbox_param_t *faix)
 173 {
 174     if (faix->version % 2) {
 175         return faix->subfaixbox.byte8_params->m;
 176     } else {
 177         return (Byte8_t)faix->subfaixbox.byte4_params->m;
 178     }
 179 }
 180
 181 Byte8_t get_elemOff(faixbox_param_t *faix, Byte8_t elem_id, Byte8_t row_id)
 182 {
 183     Byte8_t nmax = get_nmax(faix);
 184     if (faix->version % 2) {
 185         return faix->subfaixbox.byte8_params->elem[ row_id * nmax + elem_id].off;
 186     } else {
 187         return (Byte8_t)faix->subfaixbox.byte4_params->elem[ row_id * nmax +
 188                        elem_id].off;
 189     }
 190 }
 191
 192 Byte8_t get_elemLen(faixbox_param_t *faix, Byte8_t elem_id, Byte8_t row_id)
 193 {
 194     Byte8_t nmax = get_nmax(faix);
 195     if (faix->version % 2) {
 196         return faix->subfaixbox.byte8_params->elem[ row_id * nmax + elem_id].len;
 197     } else {
 198         return (Byte8_t)faix->subfaixbox.byte4_params->elem[ row_id * nmax +
 199                        elem_id].len;
 200     }
 201 }
 202
 203 Byte4_t get_elemAux(faixbox_param_t *faix, Byte8_t elem_id, Byte8_t row_id)
 204 {
 205     Byte8_t nmax;
 206     if (faix->version < 2) {
 207         return (Byte4_t) - 1;
 208     }
 209
 210     nmax = get_nmax(faix);
 211     if (faix->version % 2) {
 212         return faix->subfaixbox.byte8_params->aux[ row_id * nmax + elem_id];
 213     } else {
 214         return faix->subfaixbox.byte4_params->aux[ row_id * nmax + elem_id];
 215     }
 216 }