workbench/devs/AHI/Device/database.c

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