libaudiofile/aupv.c

   1 /*
   2         Audio File Library
   3         Copyright (C) 1998-2000, Michael Pruett <michael@68k.org>
   4
   5         This library is free software; you can redistribute it and/or
   6         modify it under the terms of the GNU Library General Public
   7         License as published by the Free Software Foundation; either
   8         version 2 of the License, or (at your option) any later version.
   9
  10         This library is distributed in the hope that it will be useful,
  11         but WITHOUT ANY WARRANTY; without even the implied warranty of
  12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13         Library General Public License for more details.
  14
  15         You should have received a copy of the GNU Library General Public
  16         License along with this library; if not, write to the
  17         Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18         Boston, MA  02111-1307  USA.
  19 */
  20
  21 /*
  22         aupv.c
  23
  24         This file contains an implementation of SGI's Audio Library parameter
  25         value list functions.
  26 */
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <assert.h>
  31
  32 #include "aupvinternal.h"
  33 #include "aupvlist.h"
  34
  35 AUpvlist AUpvnew (int maxitems)
  36 {
  37         AUpvlist        aupvlist;
  38         int             i;
  39
  40         if (maxitems <= 0)
  41                 return AU_NULL_PVLIST;
  42
  43         aupvlist = (AUpvlist) malloc(sizeof (struct _AUpvlist));
  44         assert(aupvlist);
  45         if (aupvlist == NULL)
  46                 return AU_NULL_PVLIST;
  47
  48         aupvlist->items = calloc(maxitems, sizeof (struct _AUpvitem));
  49
  50         assert(aupvlist->items);
  51         if (aupvlist->items == NULL)
  52         {
  53                 free(aupvlist);
  54                 return AU_NULL_PVLIST;
  55         }
  56
  57         /* Initialize the items in the list. */
  58         for (i=0; i<maxitems; i++)
  59         {
  60                 aupvlist->items[i].valid = _AU_VALID_PVITEM;
  61                 aupvlist->items[i].type = AU_PVTYPE_LONG;
  62                 aupvlist->items[i].parameter = 0;
  63                 memset(&aupvlist->items[i].value, 0, sizeof (aupvlist->items[i].value));
  64         }
  65
  66         aupvlist->valid = _AU_VALID_PVLIST;
  67         aupvlist->count = maxitems;
  68
  69         return aupvlist;
  70 }
  71
  72 int AUpvgetmaxitems (AUpvlist list)
  73 {
  74         assert(list);
  75
  76         if (list == AU_NULL_PVLIST)
  77                 return AU_BAD_PVLIST;
  78         if (list->valid != _AU_VALID_PVLIST)
  79                 return AU_BAD_PVLIST;
  80
  81         return list->count;
  82 }
  83
  84 int AUpvfree (AUpvlist list)
  85 {
  86         assert(list);
  87         assert(list->items);
  88
  89         if (list == AU_NULL_PVLIST)
  90                 return AU_BAD_PVLIST;
  91         if (list->valid != _AU_VALID_PVLIST)
  92                 return AU_BAD_PVLIST;
  93
  94         if ((list->items != _AU_NULL_PVITEM) &&
  95                 (list->items[0].valid == _AU_VALID_PVITEM))
  96         {
  97                 free(list->items);
  98         }
  99
 100         free(list);
 101
 102         return _AU_SUCCESS;
 103 }
 104
 105 int AUpvsetparam (AUpvlist list, int item, int param)
 106 {
 107         assert(list);
 108         assert(list->items);
 109         assert(item >= 0);
 110         assert(item < list->count);
 111
 112         if (list == AU_NULL_PVLIST)
 113                 return AU_BAD_PVLIST;
 114         if (list->valid != _AU_VALID_PVLIST)
 115                 return AU_BAD_PVLIST;
 116         if ((item < 0) || (item > list->count - 1))
 117                 return AU_BAD_PVITEM;
 118         if (list->items[item].valid != _AU_VALID_PVITEM)
 119                 return AU_BAD_PVLIST;
 120
 121         list->items[item].parameter = param;
 122         return _AU_SUCCESS;
 123 }
 124
 125 int AUpvsetvaltype (AUpvlist list, int item, int type)
 126 {
 127         assert(list);
 128         assert(list->items);
 129         assert(item >= 0);
 130         assert(item < list->count);
 131
 132         if (list == AU_NULL_PVLIST)
 133                 return AU_BAD_PVLIST;
 134         if (list->valid != _AU_VALID_PVLIST)
 135                 return AU_BAD_PVLIST;
 136         if ((item < 0) || (item > list->count - 1))
 137                 return AU_BAD_PVITEM;
 138         if (list->items[item].valid != _AU_VALID_PVITEM)
 139                 return AU_BAD_PVLIST;
 140
 141         list->items[item].type = type;
 142         return _AU_SUCCESS;
 143 }
 144
 145 int AUpvsetval (AUpvlist list, int item, void *val)
 146 {
 147         assert(list);
 148         assert(list->items);
 149         assert(item >= 0);
 150         assert(item < list->count);
 151
 152         if (list == AU_NULL_PVLIST)
 153                 return AU_BAD_PVLIST;
 154         if (list->valid != _AU_VALID_PVLIST)
 155                 return AU_BAD_PVLIST;
 156         if ((item < 0) || (item > list->count - 1))
 157                 return AU_BAD_PVITEM;
 158         if (list->items[item].valid != _AU_VALID_PVITEM)
 159                 return AU_BAD_PVLIST;
 160
 161         switch (list->items[item].type)
 162         {
 163                 case AU_PVTYPE_LONG:
 164                         list->items[item].value.l = *((long *) val);
 165                         break;
 166                 case AU_PVTYPE_DOUBLE:
 167                         list->items[item].value.d = *((double *) val);
 168                         break;
 169                 case AU_PVTYPE_PTR:
 170                         list->items[item].value.v = *((void **) val);
 171                         break;
 172                 default:
 173                         assert(0);
 174                         return AU_BAD_PVLIST;
 175         }
 176
 177         return _AU_SUCCESS;
 178 }
 179
 180 int AUpvgetparam (AUpvlist list, int item, int *param)
 181 {
 182         assert(list);
 183         assert(list->items);
 184         assert(item >= 0);
 185         assert(item < list->count);
 186
 187         if (list == AU_NULL_PVLIST)
 188                 return AU_BAD_PVLIST;
 189         if (list->valid != _AU_VALID_PVLIST)
 190                 return AU_BAD_PVLIST;
 191         if ((item < 0) || (item > list->count - 1))
 192                 return AU_BAD_PVITEM;
 193         if (list->items[item].valid != _AU_VALID_PVITEM)
 194                 return AU_BAD_PVLIST;
 195
 196         *param = list->items[item].parameter;
 197         return _AU_SUCCESS;
 198 }
 199
 200 int AUpvgetvaltype (AUpvlist list, int item, int *type)
 201 {
 202         assert(list);
 203         assert(list->items);
 204         assert(item >= 0);
 205         assert(item < list->count);
 206
 207         if (list == AU_NULL_PVLIST)
 208                 return AU_BAD_PVLIST;
 209         if (list->valid != _AU_VALID_PVLIST)
 210                 return AU_BAD_PVLIST;
 211         if ((item < 0) || (item > list->count - 1))
 212                 return AU_BAD_PVITEM;
 213         if (list->items[item].valid != _AU_VALID_PVITEM)
 214                 return AU_BAD_PVLIST;
 215
 216         *type = list->items[item].type;
 217         return _AU_SUCCESS;
 218 }
 219
 220 int AUpvgetval (AUpvlist list, int item, void *val)
 221 {
 222         assert(list);
 223         assert(list->items);
 224         assert(item >= 0);
 225         assert(item < list->count);
 226
 227         if (list == AU_NULL_PVLIST)
 228                 return AU_BAD_PVLIST;
 229         if (list->valid != _AU_VALID_PVLIST)
 230                 return AU_BAD_PVLIST;
 231         if ((item < 0) || (item > list->count - 1))
 232                 return AU_BAD_PVITEM;
 233         if (list->items[item].valid != _AU_VALID_PVITEM)
 234                 return AU_BAD_PVLIST;
 235
 236         switch (list->items[item].type)
 237         {
 238                 case AU_PVTYPE_LONG:
 239                         *((long *) val) = list->items[item].value.l;
 240                         break;
 241                 case AU_PVTYPE_DOUBLE:
 242                         *((double *) val) = list->items[item].value.d;
 243                         break;
 244                 case AU_PVTYPE_PTR:
 245                         *((void **) val) = list->items[item].value.v;
 246                         break;
 247         }
 248
 249         return _AU_SUCCESS;
 250 }