libs/timidity/instrum_dls.cpp

   1 /*
   2
   3     TiMidity -- Experimental MIDI to WAVE converter
   4     Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20    instrum.h
  21
  22    */
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "timidity.h"
  28
  29 #define __Sound_SetError(x)
  30
  31 namespace LibTimidity
  32 {
  33
  34 /*-------------------------------------------------------------------------*/
  35 /* * * * * * * * * * * * * * * * * load_riff.h * * * * * * * * * * * * * * */
  36 /*-------------------------------------------------------------------------*/
  37 struct RIFF_Chunk
  38 {
  39         uint32 magic;
  40         uint32 length;
  41         uint32 subtype;
  42         uint8  *data;
  43         RIFF_Chunk *child;
  44         RIFF_Chunk *next;
  45 };
  46
  47 extern RIFF_Chunk* LoadRIFF(FILE *src);
  48 extern void FreeRIFF(RIFF_Chunk *chunk);
  49 extern void PrintRIFF(RIFF_Chunk *chunk, int level);
  50 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  51
  52 /*-------------------------------------------------------------------------*/
  53 /* * * * * * * * * * * * * * * * * load_riff.c * * * * * * * * * * * * * * */
  54 /*-------------------------------------------------------------------------*/
  55 #define RIFF        0x46464952        /* "RIFF" */
  56 #define LIST        0x5453494c        /* "LIST" */
  57
  58 static RIFF_Chunk *AllocRIFFChunk()
  59 {
  60         RIFF_Chunk *chunk = (RIFF_Chunk *)safe_malloc(sizeof(*chunk));
  61
  62         if (!chunk)
  63         {
  64                 __Sound_SetError(ERR_OUT_OF_MEMORY);
  65                 return NULL;
  66         }
  67         memset(chunk, 0, sizeof(*chunk));
  68
  69         return chunk;
  70 }
  71
  72 static void FreeRIFFChunk(RIFF_Chunk *chunk)
  73 {
  74         if (chunk->child)
  75         {
  76                 FreeRIFFChunk(chunk->child);
  77         }
  78
  79         if (chunk->next)
  80         {
  81                 FreeRIFFChunk(chunk->next);
  82         }
  83         free(chunk);
  84         chunk = NULL;
  85 }
  86
  87 static int ChunkHasSubType(uint32 magic)
  88 {
  89         static uint32 chunk_list[] =
  90         {
  91                 RIFF, LIST
  92         };
  93         int i;
  94
  95         for (i = 0; i < sizeof(chunk_list) / sizeof(chunk_list[0]); ++i)
  96         {
  97                 if (magic == chunk_list[i])
  98                 {
  99                         return 1;
 100                 }
 101         }
 102
 103         return 0;
 104 }
 105
 106 static int ChunkHasSubChunks(uint32 magic)
 107 {
 108         static uint32 chunk_list[] =
 109         {
 110                 RIFF, LIST
 111         };
 112         int i;
 113
 114         for (i = 0; i < sizeof(chunk_list) / sizeof(chunk_list[0]); ++i)
 115         {
 116                 if (magic == chunk_list[i])
 117                 {
 118                         return 1;
 119                 }
 120         }
 121
 122         return 0;
 123 }
 124
 125 static void LoadSubChunks(RIFF_Chunk *chunk, uint8 *data, uint32 left)
 126 {
 127         uint8 *subchunkData;
 128         uint32 subchunkDataLen;
 129
 130         while (left > 8)
 131         {
 132                 RIFF_Chunk *child = AllocRIFFChunk();
 133                 RIFF_Chunk *next, *prev = NULL;
 134
 135                 for (next = chunk->child; next; next = next->next)
 136                 {
 137                         prev = next;
 138                 }
 139
 140                 if (prev)
 141                 {
 142                         prev->next = child;
 143                 }
 144                 else
 145                 {
 146                         chunk->child = child;
 147                 }
 148                 child->magic = (data[0] <<  0) | (data[1] <<  8) |
 149                                                 (data[2] << 16) | (data[3] << 24);
 150                 data += 4;
 151                 left -= 4;
 152                 child->length = (data[0] <<  0) | (data[1] <<  8) |
 153                                                 (data[2] << 16) | (data[3] << 24);
 154                 data += 4;
 155                 left -= 4;
 156                 child->data = data;
 157
 158                 if (child->length > left)
 159                 {
 160                         child->length = left;
 161                 }
 162                 subchunkData = child->data;
 163                 subchunkDataLen = child->length;
 164
 165                 if (ChunkHasSubType(child->magic) && subchunkDataLen >= 4)
 166                 {
 167                         child->subtype = (subchunkData[0] <<  0) | (subchunkData[1] <<  8) |
 168                                                 (subchunkData[2] << 16) | (subchunkData[3] << 24);
 169                         subchunkData += 4;
 170                         subchunkDataLen -= 4;
 171                 }
 172
 173                 if (ChunkHasSubChunks(child->magic))
 174                 {
 175                         LoadSubChunks(child, subchunkData, subchunkDataLen);
 176                 }
 177                 data += (child->length + 1) & ~1;
 178                 left -= (child->length + 1) & ~1;
 179         }
 180 }
 181
 182 RIFF_Chunk *LoadRIFF(FILE* src)
 183 {
 184         RIFF_Chunk *chunk;
 185         uint8 *subchunkData;
 186         uint32 subchunkDataLen;
 187
 188         /* Allocate the chunk structure */
 189         chunk = AllocRIFFChunk();
 190
 191         /* Make sure the file is in RIFF format */
 192         fread(&chunk->magic, 4, 1, src);
 193         fread(&chunk->length, 4, 1, src);
 194         chunk->magic = LE_LONG(chunk->magic);
 195         chunk->length = LE_LONG(chunk->length);
 196
 197         if (chunk->magic != RIFF)
 198         {
 199                 __Sound_SetError("Not a RIFF file");
 200                 FreeRIFFChunk(chunk);
 201
 202                 return NULL;
 203         }
 204         chunk->data = (uint8 *)safe_malloc(chunk->length);
 205
 206         if (chunk->data == NULL)
 207         {
 208                 __Sound_SetError(ERR_OUT_OF_MEMORY);
 209                 FreeRIFFChunk(chunk);
 210
 211                 return NULL;
 212         }
 213
 214         if (fread(chunk->data, chunk->length, 1, src) != 1)
 215         {
 216                 __Sound_SetError(ERR_IO_ERROR);
 217                 FreeRIFF(chunk);
 218
 219                 return NULL;
 220         }
 221         subchunkData = chunk->data;
 222         subchunkDataLen = chunk->length;
 223
 224         if (ChunkHasSubType(chunk->magic) && subchunkDataLen >= 4)
 225         {
 226                 chunk->subtype = (subchunkData[0] <<  0) | (subchunkData[1] <<  8) |
 227                                         (subchunkData[2] << 16) | (subchunkData[3] << 24);
 228                 subchunkData += 4;
 229                 subchunkDataLen -= 4;
 230         }
 231
 232         if (ChunkHasSubChunks(chunk->magic))
 233         {
 234                 LoadSubChunks(chunk, subchunkData, subchunkDataLen);
 235         }
 236
 237         return chunk;
 238 }
 239
 240 void FreeRIFF(RIFF_Chunk *chunk)
 241 {
 242         free(chunk->data);
 243         chunk->data = NULL;
 244         FreeRIFFChunk(chunk);
 245 }
 246
 247 /*-------------------------------------------------------------------------*/
 248 /* * * * * * * * * * * * * * * * * load_dls.h  * * * * * * * * * * * * * * */
 249 /*-------------------------------------------------------------------------*/
 250 /* This code is based on the DLS spec version 1.1, available at:
 251     http://www.midi.org/about-midi/dls/dlsspec.shtml
 252 */
 253
 254 /* Some typedefs so the public dls headers don't need to be modified */
 255 #define FAR
 256 typedef uint8   BYTE;
 257 typedef int16   SHORT;
 258 typedef uint16  USHORT;
 259 typedef uint16  WORD;
 260 typedef int32   LONG;
 261 typedef uint32  ULONG;
 262 typedef uint32  DWORD;
 263 #define mmioFOURCC(A, B, C, D)    \
 264     (((A) <<  0) | ((B) <<  8) | ((C) << 16) | ((D) << 24))
 265 #define DEFINE_GUID(A, B, C, E, F, G, H, I, J, K, L, M)
 266
 267 #include "dls1.h"
 268 #include "dls2.h"
 269
 270 struct WaveFMT
 271 {
 272         WORD wFormatTag;
 273         WORD wChannels;
 274         DWORD dwSamplesPerSec;
 275         DWORD dwAvgBytesPerSec;
 276         WORD wBlockAlign;
 277         WORD wBitsPerSample;
 278 };
 279
 280 struct DLS_Wave
 281 {
 282         WaveFMT *format;
 283         uint8 *data;
 284         uint32 length;
 285         WSMPL *wsmp;
 286         WLOOP *wsmp_loop;
 287 };
 288
 289 struct DLS_Region
 290 {
 291         RGNHEADER *header;
 292         WAVELINK *wlnk;
 293         WSMPL *wsmp;
 294         WLOOP *wsmp_loop;
 295         CONNECTIONLIST *art;
 296         CONNECTION *artList;
 297 };
 298
 299 struct DLS_Instrument
 300 {
 301         const char *name;
 302         INSTHEADER *header;
 303         DLS_Region *regions;
 304         CONNECTIONLIST *art;
 305         CONNECTION *artList;
 306 };
 307
 308 struct DLS_Data
 309 {
 310         RIFF_Chunk *chunk;
 311
 312         uint32 cInstruments;
 313         DLS_Instrument *instruments;
 314
 315         POOLTABLE *ptbl;
 316         POOLCUE *ptblList;
 317         DLS_Wave *waveList;
 318
 319         const char *name;
 320         const char *artist;
 321         const char *copyright;
 322         const char *comments;
 323 };
 324
 325 extern DLS_Data* LoadDLS(FILE *src);
 326 extern void FreeDLS(DLS_Data *chunk);
 327 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 328
 329 /*-------------------------------------------------------------------------*/
 330 /* * * * * * * * * * * * * * * * * load_dls.c  * * * * * * * * * * * * * * */
 331 /*-------------------------------------------------------------------------*/
 332
 333 #define FOURCC_LIST    0x5453494c   /* "LIST" */
 334 #define FOURCC_FMT     0x20746D66   /* "fmt " */
 335 #define FOURCC_DATA    0x61746164   /* "data" */
 336 #define FOURCC_INFO    mmioFOURCC('I','N','F','O')
 337 #define FOURCC_IARL    mmioFOURCC('I','A','R','L')
 338 #define FOURCC_IART    mmioFOURCC('I','A','R','T')
 339 #define FOURCC_ICMS    mmioFOURCC('I','C','M','S')
 340 #define FOURCC_ICMT    mmioFOURCC('I','C','M','T')
 341 #define FOURCC_ICOP    mmioFOURCC('I','C','O','P')
 342 #define FOURCC_ICRD    mmioFOURCC('I','C','R','D')
 343 #define FOURCC_IENG    mmioFOURCC('I','E','N','G')
 344 #define FOURCC_IGNR    mmioFOURCC('I','G','N','R')
 345 #define FOURCC_IKEY    mmioFOURCC('I','K','E','Y')
 346 #define FOURCC_IMED    mmioFOURCC('I','M','E','D')
 347 #define FOURCC_INAM    mmioFOURCC('I','N','A','M')
 348 #define FOURCC_IPRD    mmioFOURCC('I','P','R','D')
 349 #define FOURCC_ISBJ    mmioFOURCC('I','S','B','J')
 350 #define FOURCC_ISFT    mmioFOURCC('I','S','F','T')
 351 #define FOURCC_ISRC    mmioFOURCC('I','S','R','C')
 352 #define FOURCC_ISRF    mmioFOURCC('I','S','R','F')
 353 #define FOURCC_ITCH    mmioFOURCC('I','T','C','H')
 354
 355
 356 static void FreeRegions(DLS_Instrument *instrument)
 357 {
 358         if (instrument->regions)
 359         {
 360                 free(instrument->regions);
 361                 instrument->regions = NULL;
 362         }
 363 }
 364
 365 static void AllocRegions(DLS_Instrument *instrument)
 366 {
 367         int datalen = (instrument->header->cRegions * sizeof(DLS_Region));
 368
 369         FreeRegions(instrument);
 370         instrument->regions = (DLS_Region *)safe_malloc(datalen);
 371
 372         if (instrument->regions)
 373         {
 374                 memset(instrument->regions, 0, datalen);
 375         }
 376 }
 377
 378 static void FreeInstruments(DLS_Data *data)
 379 {
 380         if (data->instruments)
 381         {
 382                 uint32 i;
 383
 384                 for (i = 0; i < data->cInstruments; ++i)
 385                 {
 386                         FreeRegions(&data->instruments[i]);
 387                 }
 388                 free(data->instruments);
 389                 data->instruments = NULL;
 390         }
 391 }
 392
 393 static void AllocInstruments(DLS_Data *data)
 394 {
 395         int datalen = (data->cInstruments * sizeof(DLS_Instrument));
 396
 397         FreeInstruments(data);
 398         data->instruments = (DLS_Instrument *)safe_malloc(datalen);
 399         if (data->instruments)
 400         {
 401                 memset(data->instruments, 0, datalen);
 402         }
 403 }
 404
 405 static void FreeWaveList(DLS_Data *data)
 406 {
 407         if (data->waveList)
 408         {
 409                 free(data->waveList);
 410                 data->waveList = NULL;
 411         }
 412 }
 413
 414 static void AllocWaveList(DLS_Data *data)
 415 {
 416         int datalen = (data->ptbl->cCues * sizeof(DLS_Wave));
 417
 418         FreeWaveList(data);
 419         data->waveList = (DLS_Wave *)safe_malloc(datalen);
 420         if (data->waveList)
 421         {
 422                 memset(data->waveList, 0, datalen);
 423         }
 424 }
 425
 426 static void Parse_colh(DLS_Data *data, RIFF_Chunk *chunk)
 427 {
 428         data->cInstruments = LE_LONG(*(uint32 *)chunk->data);
 429         AllocInstruments(data);
 430 }
 431
 432 static void Parse_insh(DLS_Data * /*data*/, RIFF_Chunk *chunk, DLS_Instrument *instrument)
 433 {
 434         INSTHEADER *header = (INSTHEADER *)chunk->data;
 435         header->cRegions = LE_LONG(header->cRegions);
 436         header->Locale.ulBank = LE_LONG(header->Locale.ulBank);
 437         header->Locale.ulInstrument = LE_LONG(header->Locale.ulInstrument);
 438         instrument->header = header;
 439         AllocRegions(instrument);
 440 }
 441
 442 static void Parse_rgnh(DLS_Data * /*data*/, RIFF_Chunk *chunk, DLS_Region *region)
 443 {
 444         RGNHEADER *header = (RGNHEADER *)chunk->data;
 445         header->RangeKey.usLow = LE_SHORT(header->RangeKey.usLow);
 446         header->RangeKey.usHigh = LE_SHORT(header->RangeKey.usHigh);
 447         header->RangeVelocity.usLow = LE_SHORT(header->RangeVelocity.usLow);
 448         header->RangeVelocity.usHigh = LE_SHORT(header->RangeVelocity.usHigh);
 449         header->fusOptions = LE_SHORT(header->fusOptions);
 450         header->usKeyGroup = LE_SHORT(header->usKeyGroup);
 451         region->header = header;
 452 }
 453
 454 static void Parse_wlnk(DLS_Data * /*data*/, RIFF_Chunk *chunk, DLS_Region *region)
 455 {
 456         WAVELINK *wlnk = (WAVELINK *)chunk->data;
 457         wlnk->fusOptions = LE_SHORT(wlnk->fusOptions);
 458         wlnk->usPhaseGroup = LE_SHORT(wlnk->usPhaseGroup);
 459         wlnk->ulChannel = LE_LONG(wlnk->ulChannel);
 460         wlnk->ulTableIndex = LE_LONG(wlnk->ulTableIndex);
 461         region->wlnk = wlnk;
 462 }
 463
 464 static void Parse_wsmp(DLS_Data * /*data*/, RIFF_Chunk *chunk, WSMPL **wsmp_ptr, WLOOP **wsmp_loop_ptr)
 465 {
 466         uint32 i;
 467         WSMPL *wsmp = (WSMPL *)chunk->data;
 468         WLOOP *loop;
 469         wsmp->cbSize = LE_LONG(wsmp->cbSize);
 470         wsmp->usUnityNote = LE_SHORT(wsmp->usUnityNote);
 471         wsmp->sFineTune = LE_SHORT(wsmp->sFineTune);
 472         wsmp->lAttenuation = LE_LONG(wsmp->lAttenuation);
 473         wsmp->fulOptions = LE_LONG(wsmp->fulOptions);
 474         wsmp->cSampleLoops = LE_LONG(wsmp->cSampleLoops);
 475         loop = (WLOOP *)((uint8 *)chunk->data + wsmp->cbSize);
 476         *wsmp_ptr = wsmp;
 477         *wsmp_loop_ptr = loop;
 478
 479         for (i = 0; i < wsmp->cSampleLoops; ++i)
 480         {
 481                 loop->cbSize = LE_LONG(loop->cbSize);
 482                 loop->ulType = LE_LONG(loop->ulType);
 483                 loop->ulStart = LE_LONG(loop->ulStart);
 484                 loop->ulLength = LE_LONG(loop->ulLength);
 485                 ++loop;
 486         }
 487 }
 488
 489 static void Parse_art(DLS_Data * /*data*/, RIFF_Chunk *chunk, CONNECTIONLIST **art_ptr, CONNECTION **artList_ptr)
 490 {
 491         uint32 i;
 492         CONNECTIONLIST *art = (CONNECTIONLIST *)chunk->data;
 493         CONNECTION *artList;
 494         art->cbSize = LE_LONG(art->cbSize);
 495         art->cConnections = LE_LONG(art->cConnections);
 496         artList = (CONNECTION *)((uint8 *)chunk->data + art->cbSize);
 497         *art_ptr = art;
 498         *artList_ptr = artList;
 499
 500         for (i = 0; i < art->cConnections; ++i)
 501         {
 502                 artList->usSource = LE_SHORT(artList->usSource);
 503                 artList->usControl = LE_SHORT(artList->usControl);
 504                 artList->usDestination = LE_SHORT(artList->usDestination);
 505                 artList->usTransform = LE_SHORT(artList->usTransform);
 506                 artList->lScale = LE_LONG(artList->lScale);
 507                 ++artList;
 508         }
 509 }
 510
 511 static void Parse_lart(DLS_Data *data, RIFF_Chunk *chunk, CONNECTIONLIST **conn_ptr, CONNECTION **connList_ptr)
 512 {
 513         /* FIXME: This only supports one set of connections */
 514         for (chunk = chunk->child; chunk; chunk = chunk->next)
 515         {
 516                 uint32 magic = (chunk->magic == FOURCC_LIST) ? chunk->subtype : chunk->magic;
 517
 518                 switch(magic)
 519                 {
 520                         case FOURCC_ART1:
 521                         case FOURCC_ART2:
 522                         {
 523                                 Parse_art(data, chunk, conn_ptr, connList_ptr);
 524                                 return;
 525                         }
 526                 }
 527         }
 528 }
 529
 530 static void Parse_rgn(DLS_Data *data, RIFF_Chunk *chunk, DLS_Region *region)
 531 {
 532         for (chunk = chunk->child; chunk; chunk = chunk->next)
 533         {
 534                 uint32 magic = (chunk->magic == FOURCC_LIST) ? chunk->subtype : chunk->magic;
 535
 536                 switch(magic)
 537                 {
 538                         case FOURCC_RGNH:
 539                                 Parse_rgnh(data, chunk, region);
 540                                 break;
 541                         case FOURCC_WLNK:
 542                                 Parse_wlnk(data, chunk, region);
 543                                 break;
 544                         case FOURCC_WSMP:
 545                                 Parse_wsmp(data, chunk, &region->wsmp, &region->wsmp_loop);
 546                                 break;
 547                         case FOURCC_LART:
 548                         case FOURCC_LAR2:
 549                                 Parse_lart(data, chunk, &region->art, &region->artList);
 550                                 break;
 551                 }
 552         }
 553 }
 554
 555 static void Parse_lrgn(DLS_Data *data, RIFF_Chunk *chunk, DLS_Instrument *instrument)
 556 {
 557         uint32 region = 0;
 558
 559         for (chunk = chunk->child; chunk; chunk = chunk->next)
 560         {
 561                 uint32 magic = (chunk->magic == FOURCC_LIST) ? chunk->subtype : chunk->magic;
 562
 563                 switch(magic)
 564                 {
 565                         case FOURCC_RGN:
 566                         case FOURCC_RGN2:
 567                                 if (region < instrument->header->cRegions)
 568                                 {
 569                                         Parse_rgn(data, chunk, &instrument->regions[region++]);
 570                                 }
 571                                 break;
 572                 }
 573         }
 574 }
 575
 576 static void Parse_INFO_INS(DLS_Data * /*data*/, RIFF_Chunk *chunk, DLS_Instrument *instrument)
 577 {
 578         for (chunk = chunk->child; chunk; chunk = chunk->next)
 579         {
 580                 uint32 magic = (chunk->magic == FOURCC_LIST) ? chunk->subtype : chunk->magic;
 581
 582                 switch(magic)
 583                 {
 584                         case FOURCC_INAM: /* Name */
 585                                 instrument->name = (const char*)chunk->data;
 586                                 break;
 587                 }
 588         }
 589 }
 590
 591 static void Parse_ins(DLS_Data *data, RIFF_Chunk *chunk, DLS_Instrument *instrument)
 592 {
 593         for (chunk = chunk->child; chunk; chunk = chunk->next)
 594         {
 595                 uint32 magic = (chunk->magic == FOURCC_LIST) ? chunk->subtype : chunk->magic;
 596
 597                 switch(magic)
 598                 {
 599                         case FOURCC_INSH:
 600                                 Parse_insh(data, chunk, instrument);
 601                                 break;
 602                         case FOURCC_LRGN:
 603                                 Parse_lrgn(data, chunk, instrument);
 604                                 break;
 605                         case FOURCC_LART:
 606                         case FOURCC_LAR2:
 607                                 Parse_lart(data, chunk, &instrument->art, &instrument->artList);
 608                                 break;
 609                         case FOURCC_INFO:
 610                                 Parse_INFO_INS(data, chunk, instrument);
 611                                 break;
 612                 }
 613         }
 614 }
 615
 616 static void Parse_lins(DLS_Data *data, RIFF_Chunk *chunk)
 617 {
 618         uint32 instrument = 0;
 619
 620         for (chunk = chunk->child; chunk; chunk = chunk->next)
 621         {
 622                 uint32 magic = (chunk->magic == FOURCC_LIST) ? chunk->subtype : chunk->magic;
 623
 624                 switch(magic)
 625                 {
 626                         case FOURCC_INS:
 627                                 if (instrument < data->cInstruments)
 628                                 {
 629                                         Parse_ins(data, chunk, &data->instruments[instrument++]);
 630                                 }
 631                                 break;
 632                 }
 633         }
 634 }
 635
 636 static void Parse_ptbl(DLS_Data *data, RIFF_Chunk *chunk)
 637 {
 638         uint32 i;
 639         POOLTABLE *ptbl = (POOLTABLE *)chunk->data;
 640         ptbl->cbSize = LE_LONG(ptbl->cbSize);
 641         ptbl->cCues = LE_LONG(ptbl->cCues);
 642         data->ptbl = ptbl;
 643         data->ptblList = (POOLCUE *)((uint8 *)chunk->data + ptbl->cbSize);
 644
 645         for (i = 0; i < ptbl->cCues; ++i)
 646         {
 647                 data->ptblList[i].ulOffset = LE_LONG(data->ptblList[i].ulOffset);
 648         }
 649         AllocWaveList(data);
 650 }
 651
 652 static void Parse_fmt(DLS_Data * /*data*/, RIFF_Chunk *chunk, DLS_Wave *wave)
 653 {
 654         WaveFMT *fmt = (WaveFMT *)chunk->data;
 655         fmt->wFormatTag = LE_SHORT(fmt->wFormatTag);
 656         fmt->wChannels = LE_SHORT(fmt->wChannels);
 657         fmt->dwSamplesPerSec = LE_LONG(fmt->dwSamplesPerSec);
 658         fmt->dwAvgBytesPerSec = LE_LONG(fmt->dwAvgBytesPerSec);
 659         fmt->wBlockAlign = LE_SHORT(fmt->wBlockAlign);
 660         fmt->wBitsPerSample = LE_SHORT(fmt->wBitsPerSample);
 661         wave->format = fmt;
 662 }
 663
 664 static void Parse_data(DLS_Data * /*data*/, RIFF_Chunk *chunk, DLS_Wave *wave)
 665 {
 666         wave->data = chunk->data;
 667         wave->length = chunk->length;
 668 }
 669
 670 static void Parse_wave(DLS_Data *data, RIFF_Chunk *chunk, DLS_Wave *wave)
 671 {
 672         for (chunk = chunk->child; chunk; chunk = chunk->next)
 673         {
 674                 uint32 magic = (chunk->magic == FOURCC_LIST) ? chunk->subtype : chunk->magic;
 675
 676                 switch(magic)
 677                 {
 678                         case FOURCC_FMT:
 679                                 Parse_fmt(data, chunk, wave);
 680                                 break;
 681                         case FOURCC_DATA:
 682                                 Parse_data(data, chunk, wave);
 683                                 break;
 684                         case FOURCC_WSMP:
 685                                 Parse_wsmp(data, chunk, &wave->wsmp, &wave->wsmp_loop);
 686                                 break;
 687                 }
 688         }
 689 }
 690
 691 static void Parse_wvpl(DLS_Data *data, RIFF_Chunk *chunk)
 692 {
 693         uint32 wave = 0;
 694
 695         for (chunk = chunk->child; chunk; chunk = chunk->next)
 696         {
 697                 uint32 magic = (chunk->magic == FOURCC_LIST) ? chunk->subtype : chunk->magic;
 698
 699                 switch(magic)
 700                 {
 701                         case FOURCC_wave:
 702                                 if (wave < data->ptbl->cCues)
 703                                 {
 704                                         Parse_wave(data, chunk, &data->waveList[wave++]);
 705                                 }
 706                                 break;
 707                 }
 708         }
 709 }
 710
 711 static void Parse_INFO_DLS(DLS_Data *data, RIFF_Chunk *chunk)
 712 {
 713         for (chunk = chunk->child; chunk; chunk = chunk->next)
 714         {
 715                 uint32 magic = (chunk->magic == FOURCC_LIST) ? chunk->subtype : chunk->magic;
 716
 717                 switch(magic)
 718                 {
 719                         case FOURCC_IARL: /* Archival Location */
 720                                 break;
 721                         case FOURCC_IART: /* Artist */
 722                                 data->artist = (const char*)chunk->data;
 723                                 break;
 724                         case FOURCC_ICMS: /* Commisioned */
 725                                 break;
 726                         case FOURCC_ICMT: /* Comments */
 727                                 data->comments = (const char*)chunk->data;
 728                                 break;
 729                         case FOURCC_ICOP: /* Copyright */
 730                                 data->copyright = (const char*)chunk->data;
 731                                 break;
 732                         case FOURCC_ICRD: /* Creation Date */
 733                                 break;
 734                         case FOURCC_IENG: /* Engineer */
 735                                 break;
 736                         case FOURCC_IGNR: /* Genre */
 737                                 break;
 738                         case FOURCC_IKEY: /* Keywords */
 739                                 break;
 740                         case FOURCC_IMED: /* Medium */
 741                                 break;
 742                         case FOURCC_INAM: /* Name */
 743                                 data->name = (const char*)chunk->data;
 744                                 break;
 745                         case FOURCC_IPRD: /* Product */
 746                                 break;
 747                         case FOURCC_ISBJ: /* Subject */
 748                                 break;
 749                         case FOURCC_ISFT: /* Software */
 750                                 break;
 751                         case FOURCC_ISRC: /* Source */
 752                                 break;
 753                         case FOURCC_ISRF: /* Source Form */
 754                                 break;
 755                         case FOURCC_ITCH: /* Technician */
 756                                 break;
 757                 }
 758         }
 759 }
 760
 761 DLS_Data *LoadDLS(FILE *src)
 762 {
 763         RIFF_Chunk *chunk;
 764         DLS_Data *data = (DLS_Data *)safe_malloc(sizeof(*data));
 765
 766         if (!data)
 767         {
 768                 __Sound_SetError(ERR_OUT_OF_MEMORY);
 769                 return NULL;
 770         }
 771         memset(data, 0, sizeof(*data));
 772         data->chunk = LoadRIFF(src);
 773
 774         if (!data->chunk)
 775         {
 776                 FreeDLS(data);
 777                 return NULL;
 778         }
 779
 780         for (chunk = data->chunk->child; chunk; chunk = chunk->next)
 781         {
 782                 uint32 magic = (chunk->magic == FOURCC_LIST) ? chunk->subtype : chunk->magic;
 783
 784                 switch(magic)
 785                 {
 786                         case FOURCC_COLH:
 787                                 Parse_colh(data, chunk);
 788                                 break;
 789                         case FOURCC_LINS:
 790                                 Parse_lins(data, chunk);
 791                                 break;
 792                         case FOURCC_PTBL:
 793                                 Parse_ptbl(data, chunk);
 794                                 break;
 795                         case FOURCC_WVPL:
 796                                 Parse_wvpl(data, chunk);
 797                                 break;
 798                         case FOURCC_INFO:
 799                                 Parse_INFO_DLS(data, chunk);
 800                                 break;
 801                 }
 802         }
 803
 804         return data;
 805 }
 806
 807 void FreeDLS(DLS_Data *data)
 808 {
 809         if (data->chunk)
 810         {
 811                 FreeRIFF(data->chunk);
 812         }
 813         FreeInstruments(data);
 814         FreeWaveList(data);
 815         free(data);
 816         data = NULL;
 817 }
 818
 819 /*-------------------------------------------------------------------------*/
 820 /* * * * * * * * * * * * * * * * * instrum_dls.c * * * * * * * * * * * * * */
 821 /*-------------------------------------------------------------------------*/
 822
 823 DLS_Data *Timidity_LoadDLS(FILE *src)
 824 {
 825         DLS_Data *patches = LoadDLS(src);
 826         //if (!patches)
 827         //{
 828         //      SNDDBG(("%s", SDL_GetError()));
 829         //}
 830
 831         return patches;
 832 }
 833
 834 void Timidity_FreeDLS(DLS_Data *patches)
 835 {
 836         FreeDLS(patches);
 837 }
 838
 839 /*
 840 static double RelativeGainToLinear(int centibels)
 841 {
 842         // v = 10^(cb/(200*65536)) * V
 843         return 100.0 * pow(10.0, (double)(centibels / 65536) / 200.0);
 844 }
 845 */
 846
 847 /* convert timecents to sec */
 848 static double to_msec(int timecent)
 849 {
 850         if (timecent == 0x80000000)
 851         {
 852                 return 0.0;
 853         }
 854
 855         return 1000.0 * pow(2.0, (double)(timecent / 65536) / 1200.0);
 856 }
 857
 858 /* convert decipercent to {0..1} */
 859 static double to_normalized_percent(int decipercent)
 860 {
 861         return ((double)(decipercent / 65536)) / 1000.0;
 862 }
 863
 864 /* convert from 8bit value to fractional offset (15.15) */
 865 static int32 to_offset(int offset)
 866 {
 867         return (int32)offset << (7+15);
 868 }
 869
 870 /* calculate ramp rate in fractional unit;
 871 * diff = 8bit, time = msec
 872 */
 873 static int32 calc_rate(MidiSong* song, int diff, int /*sample_rate*/, double msec)
 874 {
 875         double rate;
 876
 877         if(msec < 6)
 878         {
 879                 msec = 6;
 880         }
 881
 882         if(diff == 0)
 883         {
 884                 diff = 255;
 885         }
 886         diff <<= (7+15);
 887         rate = ((double)diff / OUTPUT_RATE) * song->control_ratio * 1000.0 / msec;
 888
 889         return (int32)rate;
 890 }
 891
 892 static int load_connection(ULONG cConnections, CONNECTION *artList, USHORT destination)
 893 {
 894         ULONG i;
 895         int value = 0;
 896
 897         for (i = 0; i < cConnections; ++i)
 898         {
 899                 CONNECTION *conn = &artList[i];
 900
 901                 if(conn->usDestination == destination)
 902                 {
 903                         // The formula for the destination is:
 904                         // usDestination = usDestination + usTransform(usSource * (usControl * lScale))
 905                         // Since we are only handling source/control of NONE and identity
 906                         // transform, this simplifies to: usDestination = usDestination + lScale
 907                         if (conn->usSource == CONN_SRC_NONE &&
 908                                 conn->usControl == CONN_SRC_NONE &&
 909                                 conn->usTransform == CONN_TRN_NONE)
 910                         {
 911                                 if (destination == CONN_DST_EG1_ATTACKTIME)
 912                                 {
 913                                         if (conn->lScale > 78743200)
 914                                         {
 915                                                 conn->lScale -= 78743200; // maximum velocity
 916                                         }
 917                                 }
 918
 919                                 if (destination == CONN_DST_EG1_SUSTAINLEVEL)
 920                                 {
 921                                         conn->lScale /= (1000*512);
 922                                 }
 923
 924                                 if (destination == CONN_DST_PAN)
 925                                 {
 926                                         conn->lScale /= (65536000/128);
 927                                 }
 928                                 value += conn->lScale;
 929                         }
 930                 }
 931         }
 932
 933         return value;
 934 }
 935
 936 static void load_region_dls(MidiSong* song, DLS_Data *patches, Sample *sample, DLS_Instrument *ins, uint32 index)
 937 {
 938         DLS_Region *rgn = &ins->regions[index];
 939         DLS_Wave *wave = &patches->waveList[rgn->wlnk->ulTableIndex];
 940
 941         sample->low_freq = freq_table[rgn->header->RangeKey.usLow];
 942         sample->high_freq = freq_table[rgn->header->RangeKey.usHigh];
 943         sample->root_freq = freq_table[rgn->wsmp->usUnityNote];
 944         sample->low_vel = rgn->header->RangeVelocity.usLow;
 945         sample->high_vel = rgn->header->RangeVelocity.usHigh;
 946
 947         sample->modes = MODES_16BIT;
 948         sample->sample_rate = wave->format->dwSamplesPerSec;
 949         sample->data_length = wave->length / 2;
 950         sample->data = (sample_t *)safe_malloc(wave->length);
 951         memcpy(sample->data, wave->data, wave->length);
 952
 953         if (rgn->wsmp->cSampleLoops)
 954         {
 955                 sample->modes |= (MODES_LOOPING|MODES_SUSTAIN);
 956                 sample->loop_start = rgn->wsmp_loop->ulStart / 2;
 957                 sample->loop_end = sample->loop_start + (rgn->wsmp_loop->ulLength / 2);
 958         }
 959         sample->volume = 1.0f;
 960
 961         if (sample->modes & MODES_SUSTAIN)
 962         {
 963                 int value;
 964                 double attack, hold, decay, release;
 965                 int sustain;
 966                 CONNECTIONLIST *art = NULL;
 967                 CONNECTION *artList = NULL;
 968
 969                 if (ins->art && ins->art->cConnections > 0 && ins->artList)
 970                 {
 971                         art = ins->art;
 972                         artList = ins->artList;
 973                 }
 974                 else
 975                 {
 976                         art = rgn->art;
 977                         artList = rgn->artList;
 978                 }
 979
 980                 value = load_connection(art->cConnections, artList, CONN_DST_EG1_ATTACKTIME);
 981                 attack = to_msec(value);
 982                 if (attack < 0)
 983                 {
 984                         attack = 0;
 985                 }
 986                 if (attack >= 20)
 987                 {
 988                         attack = attack / 20;
 989                 }
 990
 991                 value = load_connection(art->cConnections, artList, CONN_DST_EG1_HOLDTIME);
 992                 hold = to_msec(value);
 993                 if (hold >= 20)
 994                 {
 995                         hold = hold / 20;
 996                 }
 997
 998                 value = load_connection(art->cConnections, artList, CONN_DST_EG1_DECAYTIME);
 999                 decay = to_msec(value);
1000                 if (decay >= 20)
1001                 {
1002                         decay = decay / 20;
1003                 }
1004
1005                 value = load_connection(art->cConnections, artList, CONN_DST_EG1_RELEASETIME);
1006                 release = to_msec(value);
1007                 if (release >= 20)
1008                 {
1009                         release = release / 20;
1010                 }
1011
1012                 value = load_connection(art->cConnections, artList, CONN_DST_EG1_SUSTAINLEVEL) * 2;
1013                 sustain = (int)((1.0 - to_normalized_percent(value)) * 250.0);
1014                 if (sustain < 0)
1015                 {
1016                         sustain = 0;
1017                 }
1018                 if (sustain > 255)
1019                 {
1020                         sustain = 250;
1021                 }
1022
1023                 value = load_connection(art->cConnections, artList, CONN_DST_PAN) / 2;
1024                 int panval = (int)((0.5 + to_normalized_percent(value)) * 127.0);
1025                 if (panval < 0) panval = 0; else if (panval > 127) panval = 127;
1026                 sample->panning = panval;
1027
1028                 //ctl->cmsg(CMSG_INFO, VERB_NORMAL,
1029                 //      "%d, Rate=%d LV=%d HV=%d Low=%d Hi=%d Root=%d Pan=%d Attack=%f Hold=%f Sustain=%d Decay=%f Release=%f\n", index, sample->sample_rate, rgn->header->RangeVelocity.usLow, rgn->header->RangeVelocity.usHigh, sample->low_freq, sample->high_freq, sample->root_freq, sample->panning, attack, hold, sustain, decay, release);
1030                 /*
1031                 printf("%d, Rate=%d LV=%d HV=%d Low=%d Hi=%d Root=%d Pan=%d Attack=%f Hold=%f Sustain=%d Decay=%f Release=%f\n", index, sample->sample_rate, rgn->header->RangeVelocity.usLow, rgn->header->RangeVelocity.usHigh, sample->low_freq, sample->high_freq, sample->root_freq, sample->panning, attack, hold, sustain, decay, release);
1032                 */
1033
1034                 sample->envelope_offset[ATTACK] = to_offset(255);
1035                 sample->envelope_rate[ATTACK] = calc_rate(song, 255, sample->sample_rate, attack);
1036
1037                 sample->envelope_offset[HOLD] = to_offset(250);
1038                 sample->envelope_rate[HOLD] = calc_rate(song, 5, sample->sample_rate, hold);
1039
1040                 sample->envelope_offset[DECAY] = to_offset(sustain);
1041                 sample->envelope_rate[DECAY] = calc_rate(song, 255 - sustain, sample->sample_rate, decay);
1042
1043                 sample->envelope_offset[RELEASE] = to_offset(0);
1044                 sample->envelope_rate[RELEASE] = calc_rate(song, 5 + sustain, sample->sample_rate, release);
1045
1046                 sample->envelope_offset[RELEASEB] = to_offset(0);
1047                 sample->envelope_rate[RELEASEB] = to_offset(1);
1048
1049                 sample->envelope_offset[RELEASEC] = to_offset(0);
1050                 sample->envelope_rate[RELEASEC] = to_offset(1);
1051
1052                 sample->modes |= MODES_ENVELOPE;
1053         }
1054
1055         sample->data_length <<= FRACTION_BITS;
1056         sample->loop_start <<= FRACTION_BITS;
1057         sample->loop_end <<= FRACTION_BITS;
1058 }
1059
1060 Instrument* load_instrument_dls(MidiSong *song, int drum, int bank, int instrument)
1061 {
1062         Instrument *inst;
1063         uint32 i;
1064         DLS_Instrument *dls_ins;
1065
1066         if (!song->patches)
1067         {
1068                 return(NULL);
1069         }
1070
1071         if (!drum)
1072         {
1073                 for (i = 0; i < song->patches->cInstruments; ++i)
1074                 {
1075                         dls_ins = &song->patches->instruments[i];
1076
1077                         if (!(dls_ins->header->Locale.ulBank & 0x80000000) &&
1078                                 ((dls_ins->header->Locale.ulBank >> 8) & 0xFF) == bank &&
1079                                 dls_ins->header->Locale.ulInstrument == instrument)
1080                         {
1081                                 break;
1082                         }
1083                 }
1084
1085                 if (i == song->patches->cInstruments && !bank)
1086                 {
1087                         for (i = 0; i < song->patches->cInstruments; ++i)
1088                         {
1089                                 dls_ins = &song->patches->instruments[i];
1090
1091                                 if (!(dls_ins->header->Locale.ulBank & 0x80000000) &&
1092                                         dls_ins->header->Locale.ulInstrument == instrument)
1093                                 {
1094                                         break;
1095                                 }
1096                         }
1097                 }
1098
1099                 if (i == song->patches->cInstruments)
1100                 {
1101                         ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "Couldn't find melodic instrument %d in bank %d\n", instrument, bank);
1102                         return(NULL);
1103                 }
1104                 inst = (Instrument *)safe_malloc(sizeof(*inst));
1105                 inst->type = INST_DLS;
1106                 inst->samples = dls_ins->header->cRegions;
1107                 inst->sample = (Sample *)safe_malloc(inst->samples * sizeof(*inst->sample));
1108                 memset(inst->sample, 0, inst->samples * sizeof(*inst->sample));
1109
1110                 for (i = 0; i < dls_ins->header->cRegions; ++i)
1111                 {
1112                         load_region_dls(song, song->patches, &inst->sample[i], dls_ins, i);
1113                 }
1114         }
1115         else
1116         {
1117                 for (i = 0; i < song->patches->cInstruments; ++i)
1118                 {
1119                         dls_ins = &song->patches->instruments[i];
1120
1121                         if ((dls_ins->header->Locale.ulBank & 0x80000000) &&
1122                                 dls_ins->header->Locale.ulInstrument == bank)
1123                         {
1124                                 break;
1125                         }
1126                 }
1127
1128                 if (i == song->patches->cInstruments && !bank)
1129                 {
1130                         for (i = 0; i < song->patches->cInstruments; ++i)
1131                         {
1132                                 dls_ins = &song->patches->instruments[i];
1133
1134                                 if ((dls_ins->header->Locale.ulBank & 0x80000000) &&
1135                                         dls_ins->header->Locale.ulInstrument == 0)
1136                                 {
1137                                         break;
1138                                 }
1139                         }
1140                 }
1141
1142                 if (i == song->patches->cInstruments)
1143                 {
1144                         ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "Couldn't find drum instrument %d\n", bank);
1145                         return(NULL);
1146                 }
1147                 int drum_reg = -1;
1148
1149                 for (i = 0; i < dls_ins->header->cRegions; i++)
1150                 {
1151                         if (dls_ins->regions[i].header->RangeKey.usLow == instrument)
1152                         {
1153                                 drum_reg = i;
1154                                 break;
1155                         }
1156                 }
1157
1158                 if (drum_reg == -1)
1159                 {
1160                         ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "Couldn't find drum note %d\n", instrument);
1161                         return(NULL);
1162                 }
1163
1164                 inst = (Instrument *)safe_malloc(sizeof(*inst));
1165                 inst->type = INST_DLS;
1166                 inst->samples = 1;
1167                 inst->sample = (Sample *)safe_malloc(inst->samples * sizeof(*inst->sample));
1168                 memset(inst->sample, 0, inst->samples * sizeof(*inst->sample));
1169                 load_region_dls(song, song->patches, &inst->sample[0], dls_ins, drum_reg);
1170         }
1171
1172         return inst;
1173 }
1174
1175 }