cog/ThirdParty/BASS/sflist.c

/* vim: set et ts=3 sw=3 sts=3 ft=c:
 *
 * Copyright (C) 2016 Christopher Snowhill.  All rights reserved.
 * https://github.com/kode54/sflist
 * https://gist.github.com/kode54/a7bb01a0db3f2e996145b77f0ca510d5
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#include <json-builder.h>

#include "sflist.h"

#ifndef PRId64
#ifdef _MSC_VER
#define PRId64 "I64d"
#else
#define PRId64 "lld"
#endif
#endif

/* Extras needed */

static int json_equal (const json_value * a, const json_value * b);

static int json_equal_array(const json_value * a, const json_value * b)
{
   unsigned int i, j;

   if (a->u.array.length != b->u.array.length) return 0;

   for (i = 0, j = a->u.array.length; i < j; ++i)
   {
      if (!json_equal(a->u.array.values[i], b->u.array.values[i]))
         return 0;
   }

   return 1;
}

static int json_equal_object(const json_value * a, const json_value * b)
{
   unsigned int i, j;

   if (a->u.object.length != b->u.object.length) return 0;

   for (i = 0, j = a->u.object.length; i < j; ++i)
   {
      if (strcmp(a->u.object.values[i].name, b->u.object.values[i].name))
         return 0;
      if (!json_equal(a->u.object.values[i].value, b->u.object.values[i].value))
         return 0;
   }

   return 1;
}

static int json_equal (const json_value * a, const json_value * b)
{
   if (a->type != b->type) return 0;

   switch (a->type)
   {
   case json_none:
   case json_null:
      return 1;

   case json_integer:
      return a->u.integer == b->u.integer;

   case json_double:
      return a->u.dbl == b->u.dbl;

   case json_boolean:
      return !a->u.boolean == !b->u.boolean;

   case json_string:
      return !strcmp(a->u.string.ptr, b->u.string.ptr);

   case json_array:
      return json_equal_array(a, b);

   case json_object:
      return json_equal_object(a, b);
   }

   return 0;
}

static int json_signum (double val)
{
   return (val > 0.0) - (val < 0.0);
}

#define json_compare_invalid -1000

static int json_compare (const json_value * a, const json_value * b)
{
   if (a->type != b->type) return json_compare_invalid;

   switch (a->type)
   {
   case json_none:
   case json_null:
      return 0;

   case json_integer:
      return (int)(a->u.integer - b->u.integer);

   case json_double:
      return json_signum(a->u.dbl - b->u.dbl);

   case json_boolean:
      return !!a->u.boolean - !!b->u.boolean;

   case json_string:
      return strcmp(a->u.string.ptr, b->u.string.ptr);

   case json_array:
   case json_object:
      return json_compare_invalid;
   }

   return json_compare_invalid;
}

static int json_array_contains_value (const json_value * array, const json_value * value)
{
   unsigned int i, j;

   for (i = 0, j = array->u.array.length; i < j; ++i)
   {
      if (json_equal(array->u.array.values[i], value))
         return 1;
   }

   return 0;
}

json_value * json_array_merge (json_value * arrayA, json_value * arrayB)
{
   unsigned int i, j;

   if (arrayA->type != json_array || arrayB->type != json_array)
      return 0;

   for (i = 0, j = arrayB->u.array.length; i < j; ++i)
   {
      if (!json_array_contains_value(arrayA, arrayB->u.array.values[i]))
      {
         json_array_push(arrayA, arrayB->u.array.values[i]);
      }
   }

   json_builder_free(arrayB);

   return arrayA;
}

static int json_compare_callback (const void * a, const void * b)
{
   const json_value * aa = (const json_value *) a;
   const json_value * bb = (const json_value *) b;
   return json_compare(aa, bb);
}

json_value * json_array_sort (json_value * array)
{
   unsigned int i, j;

   json_type type;

   if (array->type != json_array) return 0;

   if (array->u.array.length < 2) return array;

   type = array->u.array.values[0]->type;

   for (i = 1, j = array->u.array.length; i < j; ++i)
   {
      if (array->u.array.values[i]->type != type)
         return 0;
   }

   qsort(array->u.array.values, j, sizeof(json_value *), json_compare_callback);

   return array;
}


/* Processing begins */

static size_t sflist_parse_int(const char * in, const char ** end)
{
   size_t rval = 0;
   while (in < *end) {
      if (isdigit(*in)) {
         rval = (rval * 10) + (*in - '0');
      }
      else break;
      ++in;
   }
   *end = in;
   return rval;
}

static double sflist_parse_float(const char * in, const char ** end)
{
   size_t whole = 0;
   size_t decimal = 0;
   size_t decimal_places = 0;
   double sign = 1.0;
   const char * end_orig = *end;
   const char * ptr = in;
   if (*ptr == '-') {
      ++ptr;
      sign = -1.0;
   }
   whole = sflist_parse_int(ptr, end);
   if (*end == ptr || (**end != '.' && *end < end_orig)) {
      *end = in;
      return 0.0;
   }
   if (*end < end_orig) {
      ptr = *end + 1;
      *end = end_orig;
      decimal = sflist_parse_int(ptr, end);
      if (*end == ptr || *end < end_orig) {
         *end = in;
         return 0.0;
      }
      decimal_places = *end - ptr;
   }
   return (((double)whole) + (((double)decimal) / pow(10.0, (double)decimal_places))) * sign;
}

static json_value * sflist_load_v1(const char * sflist, size_t size, char * error_buf)
{
   json_value * rval = 0;

   json_value * arr = json_array_new(0);

   json_value * channels = 0;
   json_value * patchMappings = 0;
   double gain = 0.0;

   const char * ptr = sflist;
   const char * end = sflist + size;

   unsigned int cur_line = 0;

   while (ptr < end) {
      const char * line_start = ptr;
      json_value * obj = 0;
      const char * path = 0;
      const char * pipe = 0;
      const char * lend = ptr;
      ++cur_line;
      while (lend < end && *lend && *lend != '\r' && *lend != '\n') {
         if (*lend == '|')
            pipe = lend;
         ++lend;
      }
      if (pipe)
         path = pipe + 1;
      else
         path = ptr;
      if (pipe) {
         while (ptr < pipe) {
            char c;
            const char * fend = ptr;
            const char * vend;
            while (fend < pipe && *fend != '&') ++fend;
            vend = fend;
            switch (c = *ptr++) {
               case '&':
                     continue;

               case 'c': {
                     json_value * this_channels;
                     size_t channel_low = sflist_parse_int(ptr, &vend);
                     size_t channel_high = 0;
                     size_t i;
                     if (vend == ptr || (*vend != '-' && *vend != '&' && *vend != '|')) {
                        sprintf(error_buf, "Invalid channel number (%u:%u)", cur_line, (int)(vend - line_start + 1));
                        goto error;
                     }
                     if (*vend != '-')
                        channel_high = channel_low;
                     else {
                        ptr = vend + 1;
                        vend = fend;
                        channel_high = sflist_parse_int(ptr, &vend);
                        if (vend == ptr || (*vend != '&' && *vend != '|')) {
                           sprintf(error_buf, "Invalid channel range end value (%u:%u)", cur_line, (int)(vend - line_start + 1));
                           goto error;
                        }
                     }
                     if (!channels)
                        channels = json_array_new(0);
                     this_channels = json_array_new(0);
                     for (i = channel_low; i <= channel_high; ++i)
                        json_array_push(this_channels, json_integer_new(i));
                     channels = json_array_merge(channels, this_channels);
                     ptr = fend;
                  }
                  break;

               case 'p': {
                     json_value * mapping = 0;
                     json_value * mapping_destination = 0;
                     json_value * mapping_source = 0;

                     long source_bank = -1;
                     long source_program = -1;
                     long dest_bank = -1;
                     long dest_program = -1;

                     size_t val = sflist_parse_int(ptr, &vend);
                     if (vend == ptr || (*vend != '=' && *vend != ',' && *vend != '|')) {
                        sprintf(error_buf, "Invalid preset number (%u:%u)", cur_line, (int)(vend - line_start + 1));
                        goto error;
                     }
                     dest_program = val;
                     if (*vend == ',') {
                        dest_bank = val;
                        ptr = vend + 1;
                        vend = fend;
                        val = sflist_parse_int(ptr, &vend);
                        if (vend == ptr || (*vend != '=' && *vend != '|')) {
                           sprintf(error_buf, "Invalid preset number (%u:%u)", cur_line, (int)(vend - line_start + 1));
                           goto error;
                        }
                        dest_program = val;
                     }
                     if (*vend == '=') {
                        ptr = vend + 1;
                        vend = fend;
                        val = sflist_parse_int(ptr, &vend);
                        if (vend == ptr || (*vend != ',' && *vend != '|')) {
                           sprintf(error_buf, "Invalid preset number (%u:%u)", cur_line, (int)(vend - line_start + 1));
                           goto error;
                        }
                        source_program = val;
                        if (*vend == ',') {
                           source_bank = val;
                           ptr = vend + 1;
                           vend = fend;
                           val = sflist_parse_int(ptr, &vend);
                           if (vend == ptr || (*vend != '&' && *vend != '|')) {
                              sprintf(error_buf, "Invalid preset number (%u:%u)", cur_line, (int)(vend - line_start + 1));
                              goto error;
                           }
                           source_program = val;
                        }
                     }

                     if (!patchMappings)
                        patchMappings = json_array_new(0);
                     mapping = json_object_new(0);
                     mapping_destination = json_object_new(0);
                     if (dest_bank != -1) {
                        json_object_push(mapping_destination, "bank", json_integer_new(dest_bank));
                     }
                     json_object_push(mapping_destination, "program", json_integer_new(dest_program));
                     json_object_push(mapping, "destination", mapping_destination);
                     if (source_program != -1) {
                        mapping_source = json_object_new(0);
                        if (source_bank != -1) {
                           json_object_push(mapping_source, "bank", json_integer_new(source_bank));
                        }
                        json_object_push(mapping_source, "program", json_integer_new(source_program));
                        json_object_push(mapping, "source", mapping_source);
                     }
                     json_array_push(patchMappings, mapping);

                     ptr = fend;
                  }
                  break;

               case 'g': {
                     double val = sflist_parse_float(ptr, &vend);
                     if (vend == ptr || vend < fend) {
                        sprintf(error_buf, "Invalid gain value (%u:%u)", cur_line, (int)(vend - line_start + 1));
                        goto error;
                     }
                     gain = val;
                     ptr = fend;
                  }
                  break;

               default:
                  sprintf(error_buf, "Invalid character in preset '%c' (%u:%u)", c, cur_line, (unsigned int)(ptr - line_start));
                  goto error;
            }
         }
      }
      obj = json_object_new(0);
      json_object_push(obj, "fileName", json_string_new_length((unsigned int)(lend - path), path));
      if (gain != 0.0) {
         json_object_push(obj, "gain", json_double_new(gain));
         gain = 0.0;
      }
      if (channels) {
         channels = json_array_sort(channels);
         json_object_push(obj, "channels", channels);
         channels = 0;
      }
      if (patchMappings) {
         json_object_push(obj, "patchMappings", patchMappings);
         patchMappings = 0;
      }

      json_array_push(arr, obj);

      ptr = lend;

      while (ptr < end && (*ptr == '\n' || *ptr == '\r')) ++ptr;
   }

   rval = json_object_new(1);
   json_object_push(rval, "soundFonts", arr);

   return rval;

error:
   if (channels)       json_builder_free(channels);
   if (patchMappings)  json_builder_free(patchMappings);
   if (arr)            json_builder_free(arr);
   return 0;
}

static json_value * sflist_load_v2(const char * sflist, size_t size, char * error)
{
   json_value * rval = 0;

   json_settings settings = { 0 };
   settings.value_extra = json_builder_extra;

   rval = json_parse_ex( &settings, sflist, size, error);

   return rval;
}

static const json_value * json_object_item(const json_value * object, const char * name)
{
   unsigned int i, j;

   if (object->type != json_object) return &json_value_none;

   for (i = 0, j = object->u.object.length; i < j; ++i) {
      if (!strcmp(object->u.object.values[i].name, name))
         return object->u.object.values[i].value;
   }

   return &json_value_none;
}

static void sflist_process_patchmappings(BASS_MIDI_FONTEX * out, BASS_MIDI_FONTEX * fontex, const json_value * patchMappings, unsigned int channel)
{
   unsigned int i, j;
   for (i = 0, j = patchMappings->u.array.length; i < j; ++i) {
      json_value * preset = patchMappings->u.array.values[i];
      const json_value * destination = json_object_item(preset, "destination");
      const json_value * source = json_object_item(preset, "source");
      const json_value * destination_bank = json_object_item(destination, "bank");
      const json_value * destination_program = json_object_item(destination, "program");
      const json_value * source_bank = json_object_item(source, "bank");
      const json_value * source_program = json_object_item(source, "program");
      fontex->spreset = (source_program->type == json_none) ? -1 : (int)source_program->u.integer;
      fontex->sbank = (source_bank->type == json_none) ? -1 : (int)source_bank->u.integer;
      fontex->dpreset = (destination_program->type == json_none) ? -1 : (int)destination_program->u.integer;
      fontex->dbank = (destination_bank->type == json_none) ? 0 : (int)destination_bank->u.integer;
      fontex->dbanklsb = channel;
      *out++ = *fontex;
   }
}

static sflist_presets * sflist_process(const json_value * sflist, const char * base_path, char * error_buf)
{
#ifdef _WIN32
   wchar_t path16[32768];
#endif
   char path_temp[32768];
   const char * base_path_end = base_path + strlen(base_path) - 1;
   unsigned int presets_to_allocate = 0;
   sflist_presets * rval = calloc(1, sizeof(sflist_presets));
   json_value * arr;
   unsigned int i, j, k, l, preset_number;
   HSOUNDFONT hfont = 0;
   BASS_MIDI_FONTEX fontex;

   if (!rval)
   {
      strcpy(error_buf, "Out of memory");
      goto error;
   }

   if (sflist->type != json_object || sflist->u.object.length != 1 ||
       strcmp(sflist->u.object.values[0].name, "soundFonts"))
   {
      if (sflist->type != json_object)
         strcpy(error_buf, "Base JSON item is not an object");
      else if (sflist->u.object.length != 1)
         sprintf(error_buf, "Base JSON object contains unexpected number of items (wanted 1, got %u)", sflist->u.object.length);
      else
         sprintf(error_buf, "Base JSON object contains '%s' object instead of 'soundFonts'", sflist->u.object.values[0].name);
      goto error;
   }

   arr = sflist->u.object.values[0].value;

   if (arr->type != json_array)
   {
      strcpy(error_buf, "JSON 'soundFonts' object is not an array");
      goto error;
   }

   for (i = 0, j = arr->u.array.length; i < j; ++i) {
      const json_value * obj = arr->u.array.values[i];
      const json_value * path = 0;
      const json_value * gain = 0;
      const json_value * channels = 0;
      const json_value * patchMappings = 0;
      unsigned int patches_needed = 1;
      if (obj->type != json_object) {
         sprintf(error_buf, "soundFont item #%u is not an object", i + 1);
         goto error;
      }
      path = json_object_item(obj, "fileName");
      gain = json_object_item(obj, "gain");
      channels = json_object_item(obj, "channels");
      patchMappings = json_object_item(obj, "patchMappings");
      if (path->type == json_none) {
         sprintf(error_buf, "soundFont item #%u has no 'fileName'", i + 1);
         goto error;
      }
      if (path->type != json_string) {
         sprintf(error_buf, "soundFont item #%u 'fileName' is not a string", i + 1);
         goto error;
      }
      if (gain->type != json_none && gain->type != json_integer && gain->type != json_double) {
         sprintf(error_buf, "soundFont item #%u has an invalid gain value", i + 1);
         goto error;
      }
      if (channels->type != json_none) {
         if (channels->type != json_array) {
            sprintf(error_buf, "soundFont item #%u 'channels' is not an array", i + 1);
            goto error;
         }
         for (k = 0, l = channels->u.array.length; k < l; ++k) {
            json_value * channel = channels->u.array.values[k];
            if (channel->type != json_integer) {
               sprintf(error_buf, "soundFont item #%u 'channels' #%u is not an integer", i + 1, k + 1);
               goto error;
            }
            if (channel->u.integer < 1 || channel->u.integer > 48) {
               sprintf(error_buf, "soundFont item #%u 'channels' #%u is out of range (wanted 1-48, got %" PRId64 ")", i + 1, k + 1, channel->u.integer);
               goto error;
            }
         }
         patches_needed = l;
      }
      if (patchMappings->type != json_none) {
         if (patchMappings->type != json_array) {
            sprintf(error_buf, "soundFont item #%u 'patchMappings' is not an array", i + 1);
            goto error;
         }
         for (k = 0, l = patchMappings->u.array.length; k < l; ++k) {
            unsigned int m, n;
            unsigned int source_found = 0;
            unsigned int destination_found = 0;
            json_value * mapping = patchMappings->u.array.values[k];
            if (mapping->type != json_object) {
               sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u is not an object", i + 1, k + 1);
               goto error;
            }
            for (m = 0, n = mapping->u.object.length; m < n; ++m) {
               unsigned int o, p;
               json_value * item = mapping->u.object.values[m].value;
               const char * name = mapping->u.object.values[m].name;
               unsigned int bank_found = 0;
               unsigned int program_found = 0;
               if (strcmp(name, "source") && strcmp(name, "destination")) {
                  sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u contains an invalid '%s' field", i + 1, k + 1, name);
                  goto error;
               }
               if (item->type != json_object) {
                  sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u '%s' is not an object", i + 1, k + 1, name);
                  goto error;
               }
               if (!strcmp(name, "source"))
                  ++source_found;
               else
                  ++destination_found;
               for (o = 0, p = item->u.object.length; o < p; ++o) {
                  int range_min = 0;
                  int range_max = 128;
                  json_value * item2 = item->u.object.values[o].value;
                  const char * name2 = item->u.object.values[o].name;
                  if (strcmp(name2, "bank") && strcmp(name2, "program")) {
                     sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u '%s' contains an invalid '%s' field", i + 1, k + 1, name, name2);
                     goto error;
                  }
                  if (item2->type != json_integer) {
                     sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u '%s' '%s' is not an integer", i + 1, k + 1, name, name2);
                  }
                  if (!strcmp(name2, "program")) {
                     if (!strcmp(name, "destination"))
                        range_max = 65535;
                     else
                        range_max = 127;
                  }
                  if (item2->u.integer < range_min || item2->u.integer > range_max) {
                     sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u '%s' '%s' is out of range (expected %d-%d, got %" PRId64 ")", i + 1, k + 1, name, name2, range_min, range_max, item->u.integer);
                     goto error;
                  }
                  if (!strcmp(name2, "bank"))
                     ++bank_found;
                  else
                     ++program_found;
               }
               if (!bank_found && !program_found) {
                  sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u '%s' contains no 'bank' or 'program'", i + 1, k + 1, name);
                  goto error;
               }
               if (bank_found > 1) {
                  sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u '%s' contains more than one 'bank'", i + 1, k + 1, name);
                  goto error;
               }
               if (program_found > 1) {
                  sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u '%s' contains more than one 'program'", i + 1, k + 1, name);
                  goto error;
               }
            }
            if (!destination_found) {
               sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u is missing 'destination'", i + 1, k + 1);
               goto error;
            }
            if (destination_found > 1) {
               sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u contains more than one 'destination'", i + 1, k + 1);
               goto error;
            }
            if (source_found > 1) {
               sprintf(error_buf, "soundFont item #%u 'patchMappings' #%u contains more than one 'source'", i + 1, k + 1);
            }
         }
         patches_needed *= l;
      }
      presets_to_allocate += patches_needed;
   }

   rval->count = presets_to_allocate;
   rval->presets = calloc(sizeof(BASS_MIDI_FONTEX), rval->count);

   if (!rval->presets) {
      strcpy(error_buf, "Out of memory");
      goto error;
   }

   preset_number = 0;

   for (i = arr->u.array.length, j = 0; i--; ++j) {
      const json_value * obj = arr->u.array.values[i];
      const json_value * path = json_object_item(obj, "fileName");
      const json_value * gain = json_object_item(obj, "gain");
      const json_value * channels = json_object_item(obj, "channels");
      const json_value * patchMappings = json_object_item(obj, "patchMappings");
      const void * bass_path;
      const char * path_ptr = path->u.string.ptr;
      unsigned int bass_flags = 0;
#ifdef _WIN32
      if (!(isalpha(*path_ptr) && path_ptr[1] == ':')) {
         if (strlen(path_ptr) + (base_path_end - base_path + 2) > 32767) {
            strcpy(error_buf, "Base path plus SoundFont relative path is longer than 32767 characters");
            goto error;
         }
         strcpy(path_temp, base_path);
         if (*base_path_end != '\\' && *base_path_end != '/')
            strcat(path_temp, "\\");
         strcat(path_temp, path_ptr);
         path_ptr = path_temp;
      }
      MultiByteToWideChar(CP_UTF8, 0, path_ptr, -1, path16, 32767);
      path16[32767] = '\0';
      bass_path = (void *) path16;
      bass_flags = BASS_UNICODE;
#else
      if (*path_ptr != '/') {
         if (strlen(path_ptr) + (base_path_end - base_path + 2) > 32767) {
            strcpy(error_buf, "Base path plus SoundFont relative path is longer than 32767 characters");
            goto error;
         }
         strcpy(path_temp, base_path);
         if (*base_path_end != '/')
            strcat(path_temp, "/");
         strcat(path_temp, path_ptr);
         path_ptr = path_temp;
      }
      bass_path = (void *) path_ptr;
#endif
      hfont = BASS_MIDI_FontInit(bass_path, bass_flags);
      if (!hfont) {
         int error_code = BASS_ErrorGetCode();
         if (error_code == BASS_ERROR_FILEOPEN) {
            sprintf(error_buf, "Could not open SoundFont bank '%s'", path->u.string.ptr);
            goto error;
         }
         else if (error_code == BASS_ERROR_FILEFORM) {
            sprintf(error_buf, "SoundFont bank '%s' is not a supported format", path->u.string.ptr);
            goto error;
         }
         else {
            sprintf(error_buf, "SoundFont bank '%s' failed to load with error #%u", path->u.string.ptr, error_code);
            goto error;
         }
      }
      if (gain->type != json_none) {
         double gain_value = 0.0;
         if (gain->type == json_integer) {
            gain_value = (double)gain->u.integer;
         }
         else if (gain->type == json_double) {
            gain_value = gain->u.dbl;
         }
         gain_value = pow(10.0, gain_value / 20.0);
         BASS_MIDI_FontSetVolume(hfont, gain_value);
      }
      fontex.font = hfont;
      fontex.spreset = -1;
      fontex.sbank = -1;
      fontex.dpreset = -1;
      fontex.dbank = 0;
      fontex.dbanklsb = 0;
      /* Simplest case, whole bank loading */
      if (channels->type == json_none && patchMappings->type == json_none) {
         rval->presets[preset_number++] = fontex;
      }
      else if (patchMappings->type == json_none) {
         for (k = 0, l = channels->u.array.length; k < l; ++k) {
            fontex.dbanklsb = (int)channels->u.array.values[k]->u.integer;
            rval->presets[preset_number++] = fontex;
         }
      }
      else if (channels->type == json_none) {
         sflist_process_patchmappings(rval->presets + preset_number, &fontex, patchMappings, 0);
         preset_number += patchMappings->u.array.length;
      }
      else {
         for (k = 0, l = channels->u.array.length; k < l; ++k) {
            sflist_process_patchmappings(rval->presets + preset_number, &fontex, patchMappings, (int)channels->u.array.values[k]->u.integer);
            preset_number += patchMappings->u.array.length;
         }
      }
   }

   return rval;

error:
   if (hfont) {
      BASS_MIDI_FontFree(hfont);
   }
   if (rval) {
      sflist_free(rval);
   }
   return 0;
}

static int strpbrkn_all(const char * str, size_t size, const char * chrs)
{
   const char * end = str + size;

   while (str < end && *chrs) {
      while (str < end && *str != *chrs) ++str;
      ++str, ++chrs;
   }

   return str < end;
}

sflist_presets * sflist_load(const char * sflist, size_t size, const char * base_path, char * error)
{
   sflist_presets * rval;

   json_value * list = 0;
   
   /* Handle Unicode byte order markers */
   if (size >= 2) {
      if ((sflist[0] == 0xFF && sflist[1] == 0xFE) ||
          (sflist[0] == 0xFE && sflist[1] == 0xFF)) {
         strcpy(error, "UTF-16 encoding is not supported at this time");
         return 0;
      }
      if (size >= 3 && sflist[0] == 0xEF &&
          sflist[1] == 0xBB && sflist[2] == 0xBF) {
         sflist += 3;
         size -= 3;
      }
   }

   list = sflist_load_v2(sflist, size, error);

   if (!list) {
      if (!strpbrkn_all(sflist, size, "{[]}"))
         list = sflist_load_v1(sflist, size, error);
   }

   if (!list) {
      return 0;
   }

   rval = sflist_process(list, base_path, error);

   json_builder_free(list);

   return rval;
}

void sflist_free(sflist_presets *presetlist)
{
   if (presetlist) {
      if (presetlist->presets) {
         unsigned int i, j;
         for (i = 0, j = presetlist->count; i < j; ++i) {
            HSOUNDFONT hfont = presetlist->presets[i].font;
            if (hfont) {
               BASS_MIDI_FontFree(hfont);
            }
         }
         free(presetlist->presets);
      }
      free(presetlist);
   }
}

const char * sflist_upgrade(const char * sflist, size_t size, char * error_buf)
{
   char * rval = 0;

   json_value * list = 0;

   size_t length = 0;

   const json_serialize_opts opts =
   {
      json_serialize_mode_multiline,
      0,
      3  /* indent_size */
   };

   list = sflist_load_v2(sflist, size, error_buf);

   if (!list) {
      if (!strpbrkn_all(sflist, size, "{[]}"))
         list = sflist_load_v1(sflist, size, error_buf);
   }

   if (!list) {
      return 0;
   }

   length = json_measure_ex( list, opts );

   rval = (char *) malloc( length + 1 );

   if (!rval) {
      strcpy(error_buf, "Out of memory");
      goto error;
   }

   json_serialize_ex( rval, list, opts );

   json_builder_free( list );

   rval[ length ] = '\0';

   return (const char *) rval;

error:
   if ( list ) {
      json_builder_free( list );
   }
   return 0;
}

void sflist_upgrade_free(const char *ptr)
{
   free( (void *) ptr );
}