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