workbench/devs/AHI/Device/database.c

   1 /*
   2      AHI - Hardware independent audio subsystem
   3      Copyright (C) 1996-2005 Martin Blom <martin@blom.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, Cambridge,
  18      MA 02139, USA.
  19 */
  20
  21 #include <config.h>
  22
  23 #include <exec/memory.h>
  24 #include <exec/semaphores.h>
  25 #include <dos/dostags.h>
  26 #include <dos/dos.h>
  27 #include <libraries/iffparse.h>
  28
  29 #include <clib/alib_protos.h>
  30 #include <proto/exec.h>
  31 #include <proto/dos.h>
  32 #include <proto/iffparse.h>
  33 #include <proto/utility.h>
  34 #define __NOLIBBASE__
  35 #define __NOGLOBALIFACE__
  36 #include <proto/ahi.h>
  37 #undef  __NOLIBBASE__
  38 #undef  __NOGLOBALIFACE__
  39 #include <proto/ahi_sub.h>
  40
  41 #include <string.h>
  42
  43 #include "ahi_def.h"
  44 #include "database.h"
  45 #include "debug.h"
  46 #include "header.h"
  47 #include "misc.h"
  48
  49 static ULONG AddModeFile ( UBYTE *filename );
  50
  51 #ifdef __MORPHOS__
  52 #define IS_MORPHOS 1
  53 #else
  54 #define IS_MORPHOS 0
  55 #endif
  56
  57 /******************************************************************************
  58 ** Audio Database *************************************************************
  59 ******************************************************************************/
  60
  61 struct AHI_AudioMode
  62 {
  63   struct MinNode          ahidbn_MinNode;
  64   struct TagItem          ahidbn_Tags[0];
  65
  66   /* Taglist, mode name and driver name follows.
  67      Size variable. Use FreeVec() to free node. */
  68 };
  69
  70 /*
  71 ** Lock the database for read access. Return NULL if database not present.
  72 */
  73
  74 struct AHI_AudioDatabase *
  75 LockDatabase(void)
  76 {
  77   struct AHI_AudioDatabase *audiodb;
  78
  79   Forbid();
  80
  81   audiodb = (struct AHI_AudioDatabase *) FindSemaphore(ADB_NAME);
  82
  83   if(audiodb != NULL)
  84   {
  85     ObtainSemaphoreShared((struct SignalSemaphore *) audiodb);
  86   }
  87
  88   Permit();
  89
  90   return audiodb;
  91 }
  92
  93 /*
  94 ** Lock the database for write access. Create it if not present.
  95 */
  96
  97 struct AHI_AudioDatabase *
  98 LockDatabaseWrite(void)
  99 {
 100   struct AHI_AudioDatabase *audiodb;
 101
 102   Forbid();
 103
 104   audiodb = (struct AHI_AudioDatabase *) FindSemaphore(ADB_NAME);
 105
 106   if(audiodb != NULL)
 107   {
 108     ObtainSemaphore((struct SignalSemaphore *) audiodb);
 109   }
 110   else
 111   {
 112     audiodb = (struct AHI_AudioDatabase *)
 113         AllocVec(sizeof(struct AHI_AudioDatabase), MEMF_PUBLIC|MEMF_CLEAR);
 114
 115     if(audiodb != NULL)
 116     {
 117
 118       NewList( (struct List *) &audiodb->ahidb_AudioModes);
 119
 120       audiodb->ahidb_Semaphore.ss_Link.ln_Name = audiodb->ahidb_Name;
 121       audiodb->ahidb_Semaphore.ss_Link.ln_Pri  = 20;
 122       strcpy(audiodb->ahidb_Semaphore.ss_Link.ln_Name, ADB_NAME);
 123
 124       AddSemaphore((struct SignalSemaphore *) audiodb);
 125       ObtainSemaphore((struct SignalSemaphore *) audiodb);
 126     }
 127   }
 128   Permit();
 129
 130   return audiodb;
 131 }
 132
 133 void
 134 UnlockDatabase ( struct AHI_AudioDatabase *audiodb )
 135 {
 136   if(audiodb)
 137   {
 138     ReleaseSemaphore((struct SignalSemaphore *) audiodb);
 139   }
 140 }
 141
 142 struct TagItem *
 143 GetDBTagList ( struct AHI_AudioDatabase *audiodb,
 144                ULONG id )
 145 {
 146   struct AHI_AudioMode *node;
 147   struct TagItem       *rc = NULL;
 148
 149   if((audiodb != NULL) && (id != AHI_INVALID_ID))
 150   {
 151     for(node=(struct AHI_AudioMode *)audiodb->ahidb_AudioModes.mlh_Head;
 152         node->ahidbn_MinNode.mln_Succ;
 153         node=(struct AHI_AudioMode *)node->ahidbn_MinNode.mln_Succ)
 154     {
 155       if(id == GetTagData(AHIDB_AudioID,AHI_INVALID_ID,node->ahidbn_Tags))
 156       {
 157         rc = node->ahidbn_Tags;
 158         break;
 159       }
 160     }
 161   }
 162
 163   return rc;
 164 }
 165
 166
 167 /******************************************************************************
 168 ** AHI_NextAudioID ************************************************************
 169 ******************************************************************************/
 170
 171 /****** ahi.device/AHI_NextAudioID ******************************************
 172 *
 173 *   NAME
 174 *       AHI_NextAudioID -- iterate current audio mode identifiers
 175 *
 176 *   SYNOPSIS
 177 *       next_ID = AHI_NextAudioID( last_ID );
 178 *       D0                         D0
 179 *
 180 *       ULONG AHI_NextAudioID( ULONG );
 181 *
 182 *   FUNCTION
 183 *       This function is used to iterate through all current AudioIDs in
 184 *       the audio database.
 185 *
 186 *   INPUTS
 187 *       last_ID - previous AudioID or AHI_INVALID_ID if beginning iteration.
 188 *
 189 *   RESULT
 190 *       next_ID - subsequent AudioID or AHI_INVALID_ID if no more IDs.
 191 *
 192 *   EXAMPLE
 193 *
 194 *   NOTES
 195 *
 196 *   BUGS
 197 *
 198 *   SEE ALSO
 199 *      AHI_GetAudioAttrsA(), AHI_BestAudioIDA()
 200 *
 201 ****************************************************************************
 202 *
 203 */
 204
 205 ULONG
 206 _AHI_NextAudioID( ULONG           id,
 207                   struct AHIBase* AHIBase )
 208 {
 209   struct AHI_AudioDatabase *audiodb;
 210   struct AHI_AudioMode *node;
 211   ULONG  nextid=AHI_INVALID_ID;
 212
 213   if(AHIBase->ahib_DebugLevel >= AHI_DEBUG_HIGH)
 214   {
 215     Debug_NextAudioID(id);
 216   }
 217
 218   audiodb = LockDatabase();
 219
 220   if(audiodb != NULL)
 221   {
 222     node = (struct AHI_AudioMode *) audiodb->ahidb_AudioModes.mlh_Head;
 223
 224     if(id != AHI_INVALID_ID)
 225     {
 226       while(node != NULL)
 227       {
 228         ULONG thisid;
 229
 230         thisid = GetTagData(AHIDB_AudioID,AHI_INVALID_ID,node->ahidbn_Tags);
 231         node = (struct AHI_AudioMode *) node->ahidbn_MinNode.mln_Succ;
 232
 233         if(thisid == id)
 234         {
 235           break;
 236         }
 237       }
 238     }
 239
 240     while(node && node->ahidbn_MinNode.mln_Succ)
 241     {
 242       if( GetTagData( AHIDB_MultTable, FALSE, node->ahidbn_Tags ) )
 243       {
 244         // Pretend the "Fast" modes are not here
 245         node = (struct AHI_AudioMode*) node->ahidbn_MinNode.mln_Succ;
 246       }
 247       else
 248       {
 249         nextid = GetTagData(AHIDB_AudioID, AHI_INVALID_ID, node->ahidbn_Tags);
 250         break;
 251       }
 252     }
 253
 254     UnlockDatabase(audiodb);
 255   }
 256
 257   if(AHIBase->ahib_DebugLevel >= AHI_DEBUG_HIGH)
 258   {
 259     KPrintF("=>0x%08lx\n",nextid);
 260   }
 261
 262   return nextid;
 263 }
 264
 265
 266 /******************************************************************************
 267 ** AHI_AddAudioMode ***********************************************************
 268 ******************************************************************************/
 269
 270 /****i* ahi.device/AHI_AddAudioMode *****************************************
 271 *
 272 *   NAME
 273 *       AHI_AddAudioMode -- add an audio mode to the database (V4)
 274 *
 275 *   SYNOPSIS
 276 *       success = AHI_AddAudioMode( DBtags );
 277 *       D0                          A0
 278 *
 279 *       ULONG AHI_AddAudioMode( struct TagItem *, UBYTE *, UBYTE *);
 280 *
 281 *   FUNCTION
 282 *       Adds the audio mode described by a taglist to the audio mode
 283 *       database. If the database does not exists, it will be created.
 284 *
 285 *   INPUTS
 286 *       DBtags - Tags describing the properties of this mode.
 287 *
 288 *   RESULT
 289 *       success - FALSE if the mode could not be added.
 290 *
 291 *   EXAMPLE
 292 *
 293 *   NOTES
 294 *
 295 *   BUGS
 296 *
 297 *   SEE ALSO
 298 *
 299 ****************************************************************************
 300 *
 301 */
 302
 303 ULONG
 304 _AHI_AddAudioMode( struct TagItem* DBtags,
 305                    struct AHIBase* AHIBase )
 306 {
 307   struct AHI_AudioDatabase *audiodb;
 308   struct AHI_AudioMode *node;
 309   ULONG nodesize = sizeof(struct AHI_AudioMode), tagitems = 0;
 310   ULONG datalength = 0, namelength = 0, driverlength = 0, dvrbasenamelength = 0;
 311   struct TagItem *tstate = DBtags, *tp, *tag;
 312   ULONG rc = FALSE;
 313
 314   if(AHIBase->ahib_DebugLevel >= AHI_DEBUG_HIGH)
 315   {
 316     Debug_AddAudioMode(DBtags);
 317   }
 318
 319 // Remove old mode if present in database
 320   AHI_RemoveAudioMode( GetTagData(AHIDB_AudioID, AHI_INVALID_ID, DBtags));
 321
 322 // Now add the new mode
 323
 324   audiodb = LockDatabaseWrite();
 325
 326   if(audiodb != NULL)
 327   {
 328
 329 // Find total size
 330
 331     while( (tag = NextTagItem(&tstate)) != NULL )
 332     {
 333
 334       if(tag->ti_Data) switch(tag->ti_Tag)
 335       {
 336         case AHIDB_Data:
 337           datalength    = ((ULONG *)tag->ti_Data)[0];
 338           nodesize     += datalength;
 339           break;
 340
 341         case AHIDB_Name:
 342           namelength    = strlen((UBYTE *)tag->ti_Data)+1;
 343           nodesize     += namelength;
 344           break;
 345
 346         case AHIDB_Driver:
 347           driverlength  = strlen((UBYTE *)tag->ti_Data)+1;
 348           nodesize     += driverlength;
 349           break;
 350
 351         case AHIDB_DriverBaseName:
 352           dvrbasenamelength    = strlen((UBYTE *)tag->ti_Data)+1;
 353           nodesize     += dvrbasenamelength;
 354           break;
 355       }
 356
 357       nodesize += sizeof(struct TagItem);
 358       tagitems++;
 359     }
 360
 361     nodesize += sizeof(struct TagItem);  // The last TAG_END
 362     tagitems++;
 363
 364     node = AllocVec(nodesize, MEMF_PUBLIC|MEMF_CLEAR);
 365
 366     if(node != NULL)
 367     {
 368       tp      = node->ahidbn_Tags;
 369       tstate  = DBtags;
 370       while( (tag = NextTagItem(&tstate)) != NULL)
 371       {
 372         if(tag->ti_Data) switch(tag->ti_Tag)
 373         {
 374           case AHIDB_Data:
 375             tp->ti_Data = ((IPTR) &node->ahidbn_Tags[tagitems]);
 376             CopyMem((APTR)tag->ti_Data, (APTR)tp->ti_Data, datalength);
 377             break;
 378
 379           case AHIDB_Name:
 380             tp->ti_Data = ((IPTR) &node->ahidbn_Tags[tagitems]) + datalength;
 381             strcpy((UBYTE *)tp->ti_Data, (UBYTE *)tag->ti_Data);
 382             break;
 383
 384           case AHIDB_Driver:
 385             tp->ti_Data= ((IPTR) &node->ahidbn_Tags[tagitems]) + datalength + namelength;
 386             strcpy((UBYTE *)tp->ti_Data, (UBYTE *)tag->ti_Data);
 387             break;
 388
 389           case AHIDB_DriverBaseName:
 390             tp->ti_Data = ((IPTR) &node->ahidbn_Tags[tagitems]) + datalength + namelength + driverlength;
 391             strcpy((UBYTE *)tp->ti_Data, (UBYTE *)tag->ti_Data);
 392             break;
 393
 394           default:
 395             tp->ti_Data = tag->ti_Data;
 396             break;
 397         }
 398         tp->ti_Tag = tag->ti_Tag;
 399         tp++;
 400       }
 401       tp->ti_Tag = TAG_DONE;
 402
 403       AddHead((struct List *) &audiodb->ahidb_AudioModes, (struct Node *) node);
 404       rc = TRUE;
 405     }
 406
 407     UnlockDatabase(audiodb);
 408   }
 409
 410   if(AHIBase->ahib_DebugLevel >= AHI_DEBUG_HIGH)
 411   {
 412     KPrintF("=>%ld\n",rc);
 413   }
 414
 415   return rc;
 416 }
 417
 418
 419 /******************************************************************************
 420 ** AHI_RemoveAudioMode ********************************************************
 421 ******************************************************************************/
 422
 423 /****i* ahi.device/AHI_RemoveAudioMode **************************************
 424 *
 425 *   NAME
 426 *       AHI_RemoveAudioMode -- remove a audio mode to the database (V4)
 427 *
 428 *   SYNOPSIS
 429 *       success = AHI_RemoveAudioMode( ID );
 430 *       D0                             D0
 431 *
 432 *       ULONG AHI_RemoveAudioMode( ULONG );
 433 *
 434 *   FUNCTION
 435 *       Removes the audio mode from the audio mode database.
 436 *
 437 *   INPUTS
 438 *       ID - The audio ID of the mode to be removed, or AHI_INVALID_ID.
 439 *
 440 *   RESULT
 441 *       success - FALSE if the mode could not be removed.
 442 *
 443 *   EXAMPLE
 444 *
 445 *   NOTES
 446 *
 447 *   BUGS
 448 *
 449 *   SEE ALSO
 450 *
 451 ****************************************************************************
 452 *
 453 */
 454
 455 ULONG
 456 _AHI_RemoveAudioMode( ULONG           id,
 457                       struct AHIBase* AHIBase )
 458 {
 459   struct AHI_AudioMode *node;
 460   struct AHI_AudioDatabase *audiodb;
 461   ULONG rc=FALSE;
 462
 463   if(AHIBase->ahib_DebugLevel >= AHI_DEBUG_HIGH)
 464   {
 465     Debug_RemoveAudioMode(id);
 466   }
 467
 468
 469   /* Why ?? */
 470
 471   audiodb = LockDatabaseWrite();
 472
 473   if(audiodb != NULL)
 474   {
 475     UnlockDatabase(audiodb);
 476   }
 477
 478   audiodb = LockDatabaseWrite();
 479
 480   if(audiodb != NULL)
 481   {
 482     if(id != AHI_INVALID_ID)
 483     {
 484       for(node=(struct AHI_AudioMode *)audiodb->ahidb_AudioModes.mlh_Head;
 485           node->ahidbn_MinNode.mln_Succ;
 486           node=(struct AHI_AudioMode *)node->ahidbn_MinNode.mln_Succ)
 487       {
 488         if(id == GetTagData(AHIDB_AudioID, AHI_INVALID_ID, node->ahidbn_Tags))
 489         {
 490           Remove((struct Node *) node);
 491           FreeVec(node);
 492           rc = TRUE;
 493           break;
 494         }
 495       }
 496
 497       // Remove the entire database if it's empty
 498
 499       Forbid();
 500
 501       if(audiodb->ahidb_AudioModes.mlh_Head->mln_Succ == NULL)
 502       {
 503         UnlockDatabase(audiodb);
 504
 505         audiodb = (struct AHI_AudioDatabase *) FindSemaphore(ADB_NAME);
 506
 507         if(audiodb != NULL)
 508         {
 509           RemSemaphore((struct SignalSemaphore *) audiodb);
 510           FreeVec(audiodb);
 511         }
 512
 513         audiodb = NULL;
 514
 515       }
 516
 517       Permit();
 518
 519     }
 520     UnlockDatabase(audiodb);
 521   }
 522
 523   if(AHIBase->ahib_DebugLevel >= AHI_DEBUG_HIGH)
 524   {
 525     KPrintF("=>%ld\n",rc);
 526   }
 527
 528   return rc;
 529 }
 530
 531
 532 /******************************************************************************
 533 ** AHI_LoadModeFile ***********************************************************
 534 ******************************************************************************/
 535
 536 /****i* ahi.device/AHI_LoadModeFile *****************************************
 537 *
 538 *   NAME
 539 *       AHI_LoadModeFile -- Add all modes in a mode file to the database (V4)
 540 *
 541 *   SYNOPSIS
 542 *       success = AHI_LoadModeFile( name );
 543 *       D0                          A0
 544 *
 545 *       ULONG AHI_LoadModeFile( STRPTR );
 546 *
 547 *   FUNCTION
 548 *       This function takes the name of a file or a directory and either
 549 *       adds all modes in the file or the modes of all files in the
 550 *       directory to the audio mode database. Directories inside the
 551 *       given directory will not be recursed. The file format is IFF-AHIM.
 552 *
 553 *   INPUTS
 554 *       name - A pointer to the name of a file or directory.
 555 *
 556 *   RESULT
 557 *       success - FALSE on error. Check dos.library/IOErr() for more
 558 *           information.
 559 *
 560 *   EXAMPLE
 561 *
 562 *   NOTES
 563 *
 564 *   BUGS
 565 *
 566 *   SEE ALSO
 567 *
 568 ****************************************************************************
 569 *
 570 */
 571
 572 ULONG
 573 _AHI_LoadModeFile( UBYTE*          name,
 574                    struct AHIBase* AHIBase )
 575 {
 576   ULONG rc=FALSE;
 577   struct FileInfoBlock  *fib;
 578   BPTR  lock,thisdir;
 579
 580   if(AHIBase->ahib_DebugLevel >= AHI_DEBUG_HIGH)
 581   {
 582     Debug_LoadModeFile(name);
 583   }
 584
 585   SetIoErr(0);
 586
 587   fib = AllocDosObject(DOS_FIB, TAG_DONE);
 588
 589   if(fib != NULL)
 590   {
 591     lock = Lock(name, ACCESS_READ);
 592
 593     if(lock != 0)
 594     {
 595       if(Examine(lock,fib))
 596       {
 597         if(fib->fib_DirEntryType>0) // Directory?
 598         {
 599           thisdir = CurrentDir(lock);
 600
 601           while(ExNext(lock, fib))
 602           {
 603             if(fib->fib_DirEntryType>0)
 604             {
 605               continue;     // AHI_LoadModeFile(fib->fib_FileName); for recursion
 606             }
 607             else
 608             {
 609 #if 0
 610               rc = AddModeFile(fib->fib_FileName);
 611
 612               if(!rc)
 613               {
 614                 break;
 615               }
 616 #else
 617               // Try to load. Just continue if failing.
 618               AddModeFile(fib->fib_FileName);
 619               rc = TRUE;
 620 #endif
 621             }
 622           }
 623           if(IoErr() == ERROR_NO_MORE_ENTRIES)
 624           {
 625             SetIoErr(0);
 626           }
 627
 628           CurrentDir(thisdir);
 629         }
 630         else  // Plain file
 631         {
 632           rc = AddModeFile(name);
 633         }
 634       }
 635
 636       UnLock(lock);
 637     }
 638
 639     FreeDosObject(DOS_FIB,fib);
 640   }
 641
 642   if(AHIBase->ahib_DebugLevel >= AHI_DEBUG_HIGH)
 643   {
 644     KPrintF("=>%ld\n",rc);
 645   }
 646
 647   return rc;
 648 }
 649
 650 /* AddModeFile **********************************************************/
 651
 652 static ULONG
 653 AddModeFile ( UBYTE *filename )
 654 {
 655   struct IFFHandle *iff;
 656   struct StoredProperty *name,*data;
 657   struct CollectionItem *ci;
 658   struct TagItem *tag,*tstate;
 659   struct TagItem extratags[]=
 660   {
 661     { AHIDB_Driver,         0 },
 662     { AHIDB_Data,           0 },
 663     { AHIDB_DriverBaseName, (IPTR)(IS_MORPHOS ? "MOSSYS:DEVS/AHI" : "DEVS:AHI") },
 664     { TAG_MORE,             0 }
 665   };
 666   ULONG rc=FALSE;
 667
 668   iff = AllocIFF();
 669
 670   if(iff != NULL)
 671   {
 672
 673     iff->iff_Stream = (IPTR)Open(filename, MODE_OLDFILE);
 674
 675     if(iff->iff_Stream != 0)
 676     {
 677       InitIFFasDOS(iff);
 678
 679       if(!OpenIFF(iff, IFFF_READ))
 680       {
 681
 682         if(!(PropChunk(iff,       ID_AHIM, ID_AUDN)
 683           || PropChunk(iff,       ID_AHIM, ID_AUDD)
 684           || CollectionChunk(iff, ID_AHIM, ID_AUDM)
 685           || StopOnExit(iff,      ID_AHIM, ID_FORM)))
 686         {
 687           if(ParseIFF(iff, IFFPARSE_SCAN) == IFFERR_EOC)
 688           {
 689             name = FindProp(iff,       ID_AHIM, ID_AUDN);
 690             data = FindProp(iff,       ID_AHIM, ID_AUDD);
 691             ci   = FindCollection(iff, ID_AHIM, ID_AUDM);
 692
 693             rc = TRUE;
 694
 695             if(name != NULL)
 696             {
 697               char            driver_name[ 128 ];
 698               struct Library* driver_base;
 699
 700               rc = FALSE;
 701
 702               if( name->sp_Size <= 0 )
 703               {
 704                 Req( "%s:\nAUDN chunk has illegal size: %ld.",
 705                      (IPTR)filename, name->sp_Size );
 706               }
 707               else
 708               {
 709                 STRPTR s;
 710
 711                 // Make sure string is NUL-terminated
 712
 713                 for( s = (STRPTR) name->sp_Data;
 714                      (APTR) s < name->sp_Data + name->sp_Size;
 715                      ++s )
 716                 {
 717                   if( *s == 0 )
 718                   {
 719                     rc = TRUE;
 720                     break;
 721                   }
 722                 }
 723
 724                 if( !rc )
 725                 {
 726                   Req( "%s:\nAUDN chunk is not NUL-terminated.",
 727                        (IPTR)filename );
 728                 }
 729               }
 730
 731               extratags[0].ti_Data = (IPTR) name->sp_Data;
 732
 733               // Now verify that the driver can really be opened
 734
 735               strcpy( driver_name, IS_MORPHOS ? "MOSSYS:DEVS/AHI/" : "DEVS:AHI/" );
 736               strncat( driver_name, name->sp_Data, 100 );
 737               strcat( driver_name, ".audio" );
 738
 739               driver_base = OpenLibrary( driver_name, DriverVersion );
 740               if( driver_base == NULL )
 741               {
 742                 if (IS_MORPHOS == 0)
 743                 {
 744                   rc = FALSE;
 745                 }
 746                 else
 747                 {
 748                   // Make it MOSSYS:DEVS:AHI/...
 749                   //                    ^
 750                   driver_name[7 + 4] = ':';
 751
 752                                 // Try "DEVS:AHI/...."
 753                                 //
 754                   driver_base = OpenLibrary( driver_name + 7, DriverVersion );
 755                   if( driver_base == NULL )
 756                   {
 757                     rc = FALSE;
 758                   }
 759                   else
 760                   {
 761                     // It is a DEVS:AHI driver!
 762                     extratags[2].ti_Data = (IPTR) "DEVS:AHI";
 763
 764                     CloseLibrary( driver_base );
 765                   }
 766                 }
 767               }
 768               else
 769               {
 770                 CloseLibrary( driver_base );
 771               }
 772             }
 773
 774             if(data != NULL)
 775             {
 776               if( name->sp_Size <= 0 )
 777               {
 778                 Req( "%s:\nAUDD chunk has illegal size: %ld.",
 779                      (IPTR)filename, name->sp_Size );
 780
 781                 rc = FALSE;
 782               }
 783
 784               extratags[1].ti_Data = (IPTR) data->sp_Data;
 785             }
 786
 787             while(rc && ci != NULL)
 788             {
 789               // Relocate loaded taglist
 790
 791               tstate = (struct TagItem *) ci->ci_Data;
 792
 793               while( rc && ( tag = NextTagItem( &tstate ) ) != NULL )
 794               {
 795                 EndianSwap( sizeof tag->ti_Tag, &tag->ti_Tag );
 796                 EndianSwap( sizeof tag->ti_Data, &tag->ti_Data );
 797
 798                 if(tag->ti_Tag & (AHI_TagBaseR ^ AHI_TagBase))
 799                 {
 800                   tag->ti_Data += (IPTR)ci->ci_Data;
 801                 }
 802
 803                 rc = FALSE;
 804
 805                 switch( tag->ti_Tag )
 806                 {
 807                   case AHIDB_Name:
 808                   {
 809                     // Make sure the string is within the chunk and NUL-term.
 810
 811                     if( tag->ti_Data <  (IPTR) ci->ci_Data ||
 812                         tag->ti_Data >= (IPTR) ci->ci_Data + ci->ci_Size )
 813                     {
 814                       Req( "%s:\nAUDM chunk contains an invalid string.",
 815                            (IPTR)filename );
 816                     }
 817                     else
 818                     {
 819                       STRPTR s;
 820
 821                       // Make sure string is NUL-terminated
 822
 823                       for( s = (STRPTR) tag->ti_Data;
 824                            (APTR) s < ci->ci_Data + ci->ci_Size;
 825                            ++s )
 826                       {
 827                         if( *s == 0 )
 828                         {
 829                           rc = TRUE;
 830                           break;
 831                         }
 832                       }
 833                     }
 834
 835                     break;
 836                   }
 837
 838                   default:
 839                     rc = TRUE;
 840                     break;
 841                 }
 842
 843                 if( !rc )
 844                 {
 845                   Req( "%s:\nAUDM chunk contains a string that is not "
 846                        "NUL-terminated.", (IPTR)filename );
 847                 }
 848               }
 849
 850               if( rc )
 851               {
 852                 // Link taglists
 853
 854                 extratags[3].ti_Data = (IPTR) ci->ci_Data;
 855
 856                 rc = AHI_AddAudioMode(extratags);
 857
 858                 ci = ci->ci_Next;
 859               }
 860             }
 861           }
 862         }
 863         CloseIFF(iff);
 864       }
 865       Close((BPTR) iff->iff_Stream);
 866     }
 867     FreeIFF(iff);
 868   }
 869
 870   return rc;
 871 }