libopenjpeg/function_list.c

   1 /*
   2  * Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  18  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  24  * POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 //#include "function_list.h"
  28 //#include "opj_includes.h"
  29 //#include "opj_malloc.h"
  30
  31 #include "opj_includes.h"
  32
  33 /**
  34  * Default size of the validation list, if not sufficient, data will be reallocated with a double size.
  35  */
  36 #define OPJ_VALIDATION_SIZE 10
  37
  38 /**
  39  * Creates a validation list.
  40  *
  41  * @return      the newly created validation list.
  42  */
  43 opj_procedure_list_t *  opj_procedure_list_create()
  44 {
  45         /* memory allocation */
  46         opj_procedure_list_t * l_validation = (opj_procedure_list_t *) opj_malloc(sizeof(opj_procedure_list_t));
  47         if
  48                 (! l_validation)
  49         {
  50                 return 00;
  51         }
  52         /* initialization */
  53         memset(l_validation,0,sizeof(opj_procedure_list_t));
  54         l_validation->m_nb_max_procedures = OPJ_VALIDATION_SIZE;
  55         l_validation->m_procedures = (void**)opj_malloc(
  56                 OPJ_VALIDATION_SIZE * sizeof(opj_procedure));
  57         if
  58                 (! l_validation->m_procedures)
  59         {
  60                 opj_free(l_validation);
  61                 return 00;
  62         }
  63         memset(l_validation->m_procedures,0,OPJ_VALIDATION_SIZE * sizeof(opj_procedure));
  64         return l_validation;
  65 }
  66
  67
  68
  69 /**
  70  * Destroys a validation list.
  71  *
  72  * @param p_list the list to destroy.
  73  */
  74 void  opj_procedure_list_destroy(opj_procedure_list_t * p_list)
  75 {
  76         if
  77                 (! p_list)
  78         {
  79                 return;
  80         }
  81         /* initialization */
  82         if
  83                 (p_list->m_procedures)
  84         {
  85                 opj_free(p_list->m_procedures);
  86         }
  87         opj_free(p_list);
  88 }
  89
  90 /**
  91  * Adds a new validation procedure.
  92  *
  93  * @param       p_validation_list the list of procedure to modify.
  94  * @param       p_procedure             the procedure to add.
  95  */
  96 opj_bool  opj_procedure_list_add_procedure (opj_procedure_list_t * p_validation_list, opj_procedure p_procedure)
  97 {
  98         if
  99                 (p_validation_list->m_nb_max_procedures == p_validation_list->m_nb_procedures)
 100         {
 101                 p_validation_list->m_nb_max_procedures += OPJ_VALIDATION_SIZE;
 102                 p_validation_list->m_procedures = (void**)opj_realloc(
 103                 p_validation_list->m_procedures,p_validation_list->m_nb_max_procedures * sizeof(opj_procedure));
 104                 if
 105                         (! p_validation_list->m_procedures)
 106                 {
 107                         p_validation_list->m_nb_max_procedures = 0;
 108                         p_validation_list->m_nb_procedures = 0;
 109                         return OPJ_FALSE;
 110                 }
 111         }
 112         p_validation_list->m_procedures[p_validation_list->m_nb_procedures] = p_procedure;
 113         ++p_validation_list->m_nb_procedures;
 114         return OPJ_TRUE;
 115 }
 116
 117 /**
 118  * Gets the number of validation procedures.
 119  *
 120  * @param       p_validation_list the list of procedure to modify.
 121  *
 122  * @return the number of validation procedures.
 123  */
 124 OPJ_UINT32 opj_procedure_list_get_nb_procedures (opj_procedure_list_t * p_validation_list)
 125 {
 126         return p_validation_list->m_nb_procedures;
 127 }
 128
 129 /**
 130  * Gets the pointer on the first validation procedure. This function is similar to the C++
 131  * iterator class to iterate through all the procedures inside the validation list.
 132  * the caller does not take ownership of the pointer.
 133  *
 134  * @param       p_validation_list the list of procedure to get the first procedure from.
 135  *
 136  * @return      a pointer to the first procedure.
 137  */
 138 opj_procedure* opj_procedure_list_get_first_procedure (opj_procedure_list_t * p_validation_list)
 139 {
 140         return p_validation_list->m_procedures;
 141 }
 142
 143 /**
 144  * Clears the list of validation procedures.
 145  *
 146  * @param       p_validation_list the list of procedure to clear.
 147  *
 148  */
 149 void  opj_procedure_list_clear (opj_procedure_list_t * p_validation_list)
 150 {
 151         p_validation_list->m_nb_procedures = 0;
 152 }