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  * Default size of the validation list, if not sufficient, data will be reallocated with a double size.
  32  */
  33 #define OPJ_VALIDATION_SIZE 10
  34
  35 /**
  36  * Creates a validation list.
  37  *
  38  * @return      the newly created validation list.
  39  */
  40 opj_procedure_list_t *  opj_procedure_list_create()
  41 {
  42         /* memory allocation */
  43         opj_procedure_list_t * l_validation = (opj_procedure_list_t *) opj_malloc(sizeof(opj_procedure_list_t));
  44         if
  45                 (! l_validation)
  46         {
  47                 return 00;
  48         }
  49         /* initialization */
  50         memset(l_validation,0,sizeof(opj_procedure_list_t));
  51         l_validation->m_nb_max_procedures = OPJ_VALIDATION_SIZE;
  52         l_validation->m_procedures = (void**)opj_malloc(
  53                 OPJ_VALIDATION_SIZE * sizeof(opj_procedure));
  54         if
  55                 (! l_validation->m_procedures)
  56         {
  57                 opj_free(l_validation);
  58                 return 00;
  59         }
  60         memset(l_validation->m_procedures,0,OPJ_VALIDATION_SIZE * sizeof(opj_procedure));
  61         return l_validation;
  62 }
  63
  64
  65
  66 /**
  67  * Destroys a validation list.
  68  *
  69  * @param p_list the list to destroy.
  70  */
  71 void  opj_procedure_list_destroy(opj_procedure_list_t * p_list)
  72 {
  73         if
  74                 (! p_list)
  75         {
  76                 return;
  77         }
  78         /* initialization */
  79         if
  80                 (p_list->m_procedures)
  81         {
  82                 opj_free(p_list->m_procedures);
  83         }
  84         opj_free(p_list);
  85 }
  86
  87 /**
  88  * Adds a new validation procedure.
  89  *
  90  * @param       p_validation_list the list of procedure to modify.
  91  * @param       p_procedure             the procedure to add.
  92  */
  93 bool  opj_procedure_list_add_procedure (opj_procedure_list_t * p_validation_list, opj_procedure p_procedure)
  94 {
  95         if
  96                 (p_validation_list->m_nb_max_procedures == p_validation_list->m_nb_procedures)
  97         {
  98                 p_validation_list->m_nb_max_procedures += OPJ_VALIDATION_SIZE;
  99                 p_validation_list->m_procedures = (void**)opj_realloc(
 100                 p_validation_list->m_procedures,p_validation_list->m_nb_max_procedures * sizeof(opj_procedure));
 101                 if
 102                         (! p_validation_list->m_procedures)
 103                 {
 104                         p_validation_list->m_nb_max_procedures = 0;
 105                         p_validation_list->m_nb_procedures = 0;
 106                         return false;
 107                 }
 108         }
 109         p_validation_list->m_procedures[p_validation_list->m_nb_procedures] = p_procedure;
 110         ++p_validation_list->m_nb_procedures;
 111         return true;
 112 }
 113
 114 /**
 115  * Gets the number of validation procedures.
 116  *
 117  * @param       p_validation_list the list of procedure to modify.
 118  *
 119  * @return the number of validation procedures.
 120  */
 121 OPJ_UINT32 opj_procedure_list_get_nb_procedures (opj_procedure_list_t * p_validation_list)
 122 {
 123         return p_validation_list->m_nb_procedures;
 124 }
 125
 126 /**
 127  * Gets the pointer on the first validation procedure. This function is similar to the C++
 128  * iterator class to iterate through all the procedures inside the validation list.
 129  * the caller does not take ownership of the pointer.
 130  *
 131  * @param       p_validation_list the list of procedure to get the first procedure from.
 132  *
 133  * @return      a pointer to the first procedure.
 134  */
 135 opj_procedure* opj_procedure_list_get_first_procedure (opj_procedure_list_t * p_validation_list)
 136 {
 137         return p_validation_list->m_procedures;
 138 }
 139
 140 /**
 141  * Clears the list of validation procedures.
 142  *
 143  * @param       p_validation_list the list of procedure to clear.
 144  *
 145  */
 146 void  opj_procedure_list_clear (opj_procedure_list_t * p_validation_list)
 147 {
 148         p_validation_list->m_nb_procedures = 0;
 149 }