src/nas.c

   1 /* nas.c --- XEmacs support for the Network Audio System server.
   2  *
   3  * Author: Richard Caley <R.Caley@ed.ac.uk>
   4  *
   5  * Copyright 1994 Free Software Foundation, Inc.
   6  * Copyright 1993 Network Computing Devices, Inc.
   7  *
   8  * Permission to use, copy, modify, distribute, and sell this software and
   9  * its documentation for any purpose is hereby granted without fee, provided
  10  * that the above copyright notice appear in all copies and that both that
  11  * copyright notice and this permission notice appear in supporting
  12  * documentation, and that the name Network Computing Devices, Inc. not be
  13  * used in advertising or publicity pertaining to distribution of this
  14  * software without specific, written prior permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED 'AS-IS'.  NETWORK COMPUTING DEVICES, INC.,
  17  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT
  18  * LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  19  * PARTICULAR PURPOSE, OR NONINFRINGEMENT.  IN NO EVENT SHALL NETWORK
  20  * COMPUTING DEVICES, INC., BE LIABLE FOR ANY DAMAGES WHATSOEVER, INCLUDING
  21  * SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, INCLUDING LOSS OF USE, DATA,
  22  * OR PROFITS, EVEN IF ADVISED OF THE POSSIBILITY THEREOF, AND REGARDLESS OF
  23  * WHETHER IN AN ACTION IN CONTRACT, TORT OR NEGLIGENCE, ARISING OUT OF OR IN
  24  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  25  */
  26
  27 /* Synched up with: Not in FSF. */
  28
  29 /* There are four compile-time options.
  30  *
  31  * XTOOLKIT     This will be part of an Xt program.
  32  *
  33  * XTEVENTS     The playing will be supervised asynchronously by the Xt event
  34  *              loop.  If not set, playing will be completed within the call
  35  *              to play_file etc.
  36  *
  37  * ROBUST_PLAY  Causes errors in nas to be caught.  This means that the
  38  *              program will attempt not to die if the nas server does.
  39  *
  40  * CACHE_SOUNDS Causes the sounds to be played in buckets in the NAS
  41  *              server.  They are named by their comment field, or if that is
  42  *              empty by the filename, or for play_sound_data by a name made up
  43  *              from the sample itself.
  44  */
  45
  46 /* CHANGES:
  47  *      10/8/94, rjc    Changed names from netaudio to nas
  48  *                      Added back asynchronous play if nas library has
  49  *                      correct error facilities.
  50  *      4/11/94, rjc    Added wait_for_sounds to be called when user wants to
  51  *                      be sure all play has finished.
  52  *      1998-10-01 rlt  Added support for WAVE files.
  53  *      2002-10-16      Jon Trulson modifed this to work with NAS releases
  54  *                      1.5f and higher.  We were using the private variable
  55  *                      SoundFileInfo that doesn't exist anymore.  But preserve
  56  *                      backward compatibility.  This will not work for some
  57  *                      versions of NAS around 1.5b to 1.5f or so.  Known to
  58  *                      work on 1.2p5 and 1.6.
  59  */
  60
  61 #ifdef emacs
  62 #include <config.h>
  63 #include "lisp.h"
  64 #include "sysdep.h"
  65 #include "syssignal.h"
  66 #endif
  67
  68 #include <stdlib.h>
  69 #include <stdarg.h>
  70 #include <string.h>
  71 #include <stdio.h>
  72
  73 #ifdef HAVE_UNISTD_H
  74 #include <unistd.h>
  75 #endif
  76
  77 /* NAS <= 1.2p5 defines {BIG,LITTLE}_ENDIAN in <audio/fileutil.h>,
  78    conflicting with GNU libc (at least); newer versions avoid this
  79    name space pollution.
  80
  81    DO NOT USE THOSE MACROS in this file.  Use NAS_{BIG,LITTLE}_ENDIAN.
  82
  83    It would be slightly more reliable to do this via configure, but that
  84    seems unnecessarily complex.
  85 */
  86 #undef LITTLE_ENDIAN
  87 #undef BIG_ENDIAN
  88
  89 #include <audio/audiolib.h>
  90 #include <audio/soundlib.h>
  91 #include <audio/snd.h>
  92 #include <audio/wave.h>
  93 #include <audio/fileutil.h>
  94
  95 /* NAS <= 1.2p5 <audio/fileutil.h> doesn't define the NAS_ versions */
  96 #ifndef NAS_LITTLE_ENDIAN
  97 #define NAS_LITTLE_ENDIAN LITTLE_ENDIAN
  98 #define NAS_BIG_ENDIAN BIG_ENDIAN
  99 #endif
 100
 101 #ifdef emacs
 102
 103 #    define XTOOLKIT
 104 #    define XTEVENTS
 105 #    define ROBUST_PLAY
 106 #    define CACHE_SOUNDS
 107
 108     /*
 109      * For old NAS libraries, force playing to be synchronous
 110      * and declare the long jump point locally.
 111      */
 112
 113 #    if defined (NAS_NO_ERROR_JUMP)
 114
 115 #       undef XTEVENTS
 116
 117 #       include <setjmp.h>
 118         jmp_buf AuXtErrorJump;
 119 #    endif
 120
 121      /* The GETTEXT is correct. --ben */
 122 #    define warn(str) warn_when_safe (Qnas, Qwarning, "nas: %s ", GETTEXT (str))
 123
 124 #    define play_sound_file nas_play_sound_file
 125 #    define play_sound_data nas_play_sound_data
 126 #    define wait_for_sounds nas_wait_for_sounds
 127 #    define init_play       nas_init_play
 128 #    define close_down_play nas_close_down_play
 129
 130 #else /* !emacs */
 131 #    define warn(str) fprintf (stderr, "%s\n", (str))
 132 #endif /* emacs */
 133
 134 #ifdef XTOOLKIT
 135 #    include <X11/Intrinsic.h>
 136 #    include <audio/Xtutil.h>
 137 #endif
 138
 139 #if defined (ROBUST_PLAY)
 140 static AuBool CatchIoErrorAndJump (AuServer *aud);
 141 static AuBool CatchErrorAndJump (AuServer *aud, AuErrorEvent *event);
 142 SIGTYPE sigpipe_handle (int signo);
 143 #endif
 144
 145 extern Lisp_Object Vsynchronous_sounds;
 146
 147 static Sound SoundOpenDataForReading (unsigned char *data, int length);
 148
 149 static AuServer       *aud;
 150
 151 /* count of sounds currently being played. */
 152 static int sounds_in_play;
 153
 154
 155 #ifdef XTOOLKIT
 156 static Display *aud_server;
 157 static XtInputId input_id;
 158 #else
 159 static char *aud_server;
 160 #endif /* XTOOLKIT */
 161
 162 char *
 163 init_play (
 164 #ifdef XTOOLKIT
 165            Display *display
 166 #else
 167            char *server
 168 #endif
 169            );
 170 char *
 171 init_play (
 172 #ifdef XTOOLKIT
 173            Display *display
 174 #else
 175            char *server
 176 #endif
 177            )
 178 {
 179   char *err_message;
 180   SIGTYPE (*old_sigpipe) (int);
 181
 182 #ifdef XTOOLKIT
 183   char * server = DisplayString (display);
 184   XtAppContext app_context = XtDisplayToApplicationContext (display);
 185
 186   aud_server = display;
 187 #else
 188
 189   aud_server = server;
 190 #endif
 191
 192 #ifdef ROBUST_PLAY
 193   old_sigpipe = signal (SIGPIPE, sigpipe_handle);
 194   if (setjmp (AuXtErrorJump))
 195     {
 196       signal (SIGPIPE, old_sigpipe);
 197 #ifdef emacs
 198       start_interrupts ();
 199 #endif
 200       return "error in NAS";
 201     }
 202 #endif
 203
 204 #if defined (ROBUST_PLAY) && !defined (NAS_NO_ERROR_JUMP)
 205   AuDefaultIOErrorHandler = CatchIoErrorAndJump;
 206   AuDefaultErrorHandler = CatchErrorAndJump;
 207 #endif
 208
 209 #ifdef emacs
 210   stop_interrupts ();
 211 #endif
 212   aud = AuOpenServer (server, 0, NULL, 0, NULL, &err_message);
 213 #ifdef emacs
 214   start_interrupts ();
 215 #endif
 216   if (!aud)
 217     {
 218 #ifdef ROBUST_PLAY
 219       signal (SIGPIPE, old_sigpipe);
 220 #endif
 221       if (err_message == NULL)
 222         return "Can't connect to audio server";
 223       else
 224         return err_message;
 225     }
 226
 227 #if defined (ROBUST_PLAY)
 228 # if defined (NAS_NO_ERROR_JUMP)
 229   aud->funcs.ioerror_handler = CatchIoErrorAndJump;
 230   aud->funcs.error_handler = CatchErrorAndJump;
 231 # else /* !NAS_NO_ERROR_JUMP */
 232   AuDefaultIOErrorHandler = NULL;
 233   AuDefaultErrorHandler = NULL;
 234 # endif
 235 #endif
 236
 237 #ifdef XTEVENTS
 238   input_id = AuXtAppAddAudioHandler (app_context, aud);
 239 #endif
 240
 241 #ifdef CACHE_SOUNDS
 242   AuSetCloseDownMode (aud, AuCloseDownRetainPermanent, NULL);
 243 #endif
 244
 245 #ifdef ROBUST_PLAY
 246   signal (SIGPIPE, old_sigpipe);
 247 #endif
 248
 249   sounds_in_play = 0;
 250
 251   return NULL;
 252 }
 253
 254 static void
 255 close_down_play (void)
 256
 257 {
 258   AuCloseServer (aud);
 259   warn ("disconnected from audio server");
 260 }
 261
 262  /********************************************************************\
 263  *                                                                    *
 264  * Callback which is run when the sound finishes playing.             *
 265  *                                                                    *
 266  \********************************************************************/
 267
 268 static void
 269 doneCB (AuServer       *auserver,
 270         AuEventHandlerRec *handler,
 271         AuEvent        *ev,
 272         AuPointer       data)
 273 {
 274   int         *in_play_p = (int *) data;
 275
 276   (*in_play_p) --;
 277 }
 278
 279 #ifdef CACHE_SOUNDS
 280
 281  /********************************************************************\
 282  *                                                                    *
 283  * Play a sound by playing the relevant bucket, if any or             *
 284  * downloading it if not.                                             *
 285  *                                                                    *
 286  \********************************************************************/
 287
 288 static void
 289 do_caching_play (Sound s,
 290                  int volume,
 291                  unsigned char *buf)
 292
 293 {
 294   AuBucketAttributes *list, b;
 295   AuBucketID      id;
 296   int n;
 297
 298   AuSetString (AuBucketDescription (&b),
 299                AuStringLatin1, strlen (SoundComment (s)), SoundComment (s));
 300
 301   list = AuListBuckets (aud, AuCompCommonDescriptionMask, &b, &n, NULL);
 302
 303   if (list == NULL)
 304     {
 305       AuPointer my_buf;
 306
 307       if (buf==NULL)
 308         {
 309           if ((my_buf= (AuPointer) malloc (SoundNumBytes (s)))==NULL)
 310             {
 311               return;
 312             }
 313
 314           if (SoundReadFile ((char *) my_buf, SoundNumBytes (s), s) != SoundNumBytes (s))
 315             {
 316               free (my_buf);
 317               return;
 318             }
 319         }
 320       else
 321         my_buf = (AuPointer) buf;
 322
 323       id = AuSoundCreateBucketFromData (aud,
 324                                         s,
 325                                         my_buf,
 326                                         AuAccessAllMasks,
 327                                         NULL,
 328                                         NULL);
 329       if (buf == NULL)
 330         free (my_buf);
 331     }
 332   else /* found cached sound */
 333     {
 334       id = AuBucketIdentifier (list);
 335       AuFreeBucketAttributes (aud, n, list);
 336     }
 337
 338   sounds_in_play++;
 339
 340   AuSoundPlayFromBucket (aud,
 341                          id,
 342                          AuNone,
 343                          AuFixedPointFromFraction (volume, 100),
 344                          doneCB, (AuPointer) &sounds_in_play,
 345                          1,
 346                          NULL, NULL,
 347                          NULL, NULL);
 348
 349 }
 350 #endif /* CACHE_SOUNDS */
 351
 352
 353 void wait_for_sounds (void);
 354 void
 355 wait_for_sounds (void)
 356
 357 {
 358   AuEvent         ev;
 359
 360   while (sounds_in_play>0)
 361     {
 362       AuNextEvent (aud, AuTrue, &ev);
 363       AuDispatchEvent (aud, &ev);
 364     }
 365 }
 366
 367 int play_sound_file (char *sound_file, int volume);
 368 int
 369 play_sound_file (char *sound_file,
 370                  int volume)
 371 {
 372   SIGTYPE (*old_sigpipe) (int);
 373
 374 #ifdef ROBUST_PLAY
 375   old_sigpipe=signal (SIGPIPE, sigpipe_handle);
 376   if (setjmp (AuXtErrorJump))
 377     {
 378       signal (SIGPIPE, old_sigpipe);
 379       return 0;
 380     }
 381 #endif
 382
 383   if (aud==NULL) {
 384     if (aud_server != NULL)
 385       {
 386         char *m;
 387         /* attempt to reconect */
 388         if ((m=init_play (aud_server))!= NULL)
 389           {
 390
 391 #ifdef ROBUST_PLAY
 392             signal (SIGPIPE, old_sigpipe);
 393 #endif
 394             return 0;
 395           }
 396       }
 397     else
 398       {
 399         warn ("Attempt to play with no audio init\n");
 400 #ifdef ROBUST_PLAY
 401         signal (SIGPIPE, old_sigpipe);
 402 #endif
 403         return 0;
 404       }
 405   }
 406
 407 #ifndef CACHE_SOUNDS
 408   sounds_in_play++;
 409   AuSoundPlayFromFile (aud,
 410                        sound_file,
 411                        AuNone,
 412                        AuFixedPointFromFraction (volume,100),
 413                        doneCB, (AuPointer) &sounds_in_play,
 414                        NULL,
 415                        NULL,
 416                        NULL,
 417                        NULL);
 418 #else
 419   /* Cache the sounds in buckets on the server */
 420
 421   {
 422     Sound s;
 423
 424     if ((s = SoundOpenFileForReading (sound_file))==NULL)
 425       {
 426 #ifdef ROBUST_PLAY
 427         signal (SIGPIPE, old_sigpipe);
 428 #endif
 429         return 0;
 430       }
 431
 432     if (SoundComment (s) == NULL || SoundComment (s)[0] == '\0')
 433       {
 434         SoundComment (s) = FileCommentFromFilename (sound_file);
 435       }
 436
 437     do_caching_play (s, volume, NULL);
 438
 439     SoundCloseFile (s);
 440
 441   }
 442 #endif /* CACHE_SOUNDS */
 443
 444 #ifndef XTEVENTS
 445   wait_for_sounds ();
 446 #else
 447   if (!NILP (Vsynchronous_sounds))
 448     {
 449       wait_for_sounds ();
 450     }
 451 #endif
 452
 453 #ifdef ROBUST_PLAY
 454   signal (SIGPIPE, old_sigpipe);
 455 #endif
 456
 457   return 1;
 458 }
 459
 460 int play_sound_data (unsigned char *data, int length, int volume);
 461 int
 462 play_sound_data (unsigned char *data,
 463                  int length,
 464                  int volume)
 465 {
 466   Sound s;
 467   int offset;
 468   SIGTYPE (*old_sigpipe) (int);
 469
 470 #if !defined (XTEVENTS)
 471   AuEvent         ev;
 472 #endif
 473
 474 #ifdef ROBUST_PLAY
 475   old_sigpipe = signal (SIGPIPE, sigpipe_handle);
 476   if (setjmp (AuXtErrorJump) !=0)
 477     {
 478       signal (SIGPIPE, old_sigpipe);
 479       return 0;
 480     }
 481 #endif
 482
 483
 484   if (aud == NULL) {
 485     if (aud_server != NULL)
 486       {
 487         char *m;
 488         /* attempt to reconect */
 489         if ((m = init_play (aud_server)) != NULL)
 490           {
 491 #ifdef ROBUST_PLAY
 492             signal (SIGPIPE, old_sigpipe);
 493 #endif
 494             return 0;
 495           }
 496       }
 497     else
 498       {
 499         warn ("Attempt to play with no audio init\n");
 500 #ifdef ROBUST_PLAY
 501         signal (SIGPIPE, old_sigpipe);
 502 #endif
 503         return 0;
 504       }
 505   }
 506
 507   if ((s=SoundOpenDataForReading (data, length))==NULL)
 508     {
 509       warn ("unknown sound type");
 510 #ifdef ROBUST_PLAY
 511       signal (SIGPIPE, old_sigpipe);
 512 #endif
 513       return 0;
 514     }
 515
 516   if (SoundFileFormat (s) == SoundFileFormatSnd)
 517     {
 518       /* hack, hack */
 519       offset = ((SndInfo *) (s->formatInfo))->h.dataOffset;
 520     }
 521   else if (SoundFileFormat (s) == SoundFileFormatWave)
 522     {
 523       offset = ((WaveInfo *) (s->formatInfo))->dataOffset;
 524     }
 525   else
 526     {
 527       warn ("only understand snd and wave files at the moment");
 528       SoundCloseFile (s);
 529 #ifdef ROBUST_PLAY
 530       signal (SIGPIPE, old_sigpipe);
 531 #endif
 532       return 0;
 533     }
 534
 535 #ifndef CACHE_SOUNDS
 536   sounds_in_play++;
 537   AuSoundPlayFromData (aud,
 538                        s,
 539                        data+offset,
 540                        AuNone,
 541                        AuFixedPointFromFraction (volume,100),
 542                        doneCB, (AuPointer) &sounds_in_play,
 543                        NULL,
 544                        NULL,
 545                        NULL,
 546                        NULL);
 547 #else
 548   /* Cache the sounds in buckets on the server */
 549
 550   {
 551     do_caching_play (s, volume, data+offset);
 552   }
 553 #endif /* CACHE_SOUNDS */
 554
 555
 556 #ifndef XTEVENTS
 557   wait_for_sounds ();
 558 #else
 559   if (!NILP (Vsynchronous_sounds))
 560     {
 561       wait_for_sounds ();
 562     }
 563 #endif
 564
 565   SoundCloseFile (s);
 566
 567 #ifdef ROBUST_PLAY
 568   signal (SIGPIPE, old_sigpipe);
 569 #endif
 570
 571   return 1;
 572 }
 573
 574 #if defined (ROBUST_PLAY)
 575
 576  /********************************************************************\
 577  *                                                                    *
 578  * Code to protect the client from server shutdowns.                  *
 579  *                                                                    *
 580  * This is unbelievably horrible.                                     *
 581  *                                                                    *
 582  \********************************************************************/
 583
 584 static AuBool
 585 CatchIoErrorAndJump (AuServer *old_aud)
 586 {
 587   if (old_aud)
 588     warn ("Audio Server connection broken");
 589   else
 590     warn ("Audio Server connection broken because of signal");
 591
 592 #ifdef XTEVENTS
 593 #ifdef XTOOLKIT
 594   {
 595     AuXtAppRemoveAudioHandler (aud, input_id);
 596   }
 597 #endif
 598
 599   if (aud)
 600     AuCloseServer (aud);
 601   aud = NULL;
 602   sounds_in_play = 0;
 603
 604   longjmp (AuXtErrorJump, 1);
 605
 606 #else /* not XTEVENTS */
 607
 608   if (aud)
 609     AuCloseServer (aud);
 610   aud = NULL;
 611   sounds_in_play = 0;
 612   longjmp (AuXtErrorJump, 1);
 613
 614 #endif /* XTEVENTS */
 615   return 0;
 616 }
 617
 618 SIGTYPE
 619 sigpipe_handle (int signo)
 620 {
 621   CatchIoErrorAndJump (NULL);
 622 }
 623
 624 static AuBool
 625 CatchErrorAndJump (AuServer *old_aud,
 626                    AuErrorEvent *event)
 627 {
 628   return CatchIoErrorAndJump (old_aud);
 629 }
 630
 631 #endif /* ROBUST_PLAY */
 632
 633  /********************************************************************\
 634  *                                                                    *
 635  * This code is here because the nas Sound library doesn't            *
 636  * support playing from a file buffered in memory. It's a fairly      *
 637  * direct translation of the file-based equivalent.                   *
 638  *                                                                    *
 639  * Since we don't have a filename, samples with no comment field      *
 640  * are named by a section of their content.                           *
 641  *                                                                    *
 642  \********************************************************************/
 643
 644 /* Create a name from the sound. */
 645
 646 static char *
 647 NameFromData (const char *buf,
 648               int len)
 649
 650 {
 651   char name[9];
 652   int i;
 653   char *s;
 654
 655   buf+=len/2;
 656   len -= len/2;
 657
 658   i=0;
 659   while (i<8 && len >0)
 660     {
 661       while (*buf < 32 && len>0)
 662         {
 663           buf++;
 664           len--;
 665         }
 666       name[i]= *buf;
 667       i++;
 668       buf++;
 669       len--;
 670     }
 671
 672   name[i]='\0';
 673
 674   if (i==8)
 675     {
 676       strcpy (s = (char *) malloc (10), name);
 677     }
 678   else
 679     {
 680       strcpy (s = (char *) malloc (15), "short sound");
 681     }
 682
 683   return s;
 684 }
 685
 686 /* Code to do a pseudo-open on a data buffer. Only for snd files at the
 687    moment.
 688  */
 689
 690 static SndInfo *
 691 SndOpenDataForReading (const char *data,
 692                        int length)
 693
 694 {
 695   SndInfo        *si;
 696   int             size;
 697
 698   if (!(si = (SndInfo *) malloc (sizeof (SndInfo))))
 699     return NULL;
 700
 701   si->comment = NULL;
 702   si->writing = 0;
 703
 704   memcpy (&si->h, data, sizeof (SndHeader));
 705
 706   if (NAS_LITTLE_ENDIAN)
 707     {
 708       char            n;
 709
 710       swapl (&si->h.magic, n);
 711       swapl (&si->h.dataOffset, n);
 712       swapl (&si->h.dataSize, n);
 713       swapl (&si->h.format, n);
 714       swapl (&si->h.sampleRate, n);
 715       swapl (&si->h.tracks, n);
 716     }
 717
 718   if (si->h.magic != SND_MAGIC_NUM)
 719     {
 720       free (si);
 721       return NULL;
 722     }
 723
 724   size = si->h.dataOffset - sizeof (SndHeader);
 725
 726   if (size)
 727     {
 728       if (!(si->comment = (char *) malloc (size + 1)))
 729         {
 730           free (si);
 731           return NULL;
 732         }
 733
 734       memcpy (si->comment,  data+sizeof (SndHeader), size);
 735
 736       *(si->comment + size) = 0;
 737       if (*si->comment == '\0')
 738         si->comment =
 739           NameFromData (data+si->h.dataOffset, length-si->h.dataOffset);
 740     }
 741   else
 742     si->comment = NameFromData (data+si->h.dataOffset, length-si->h.dataOffset);
 743
 744   si->h.dataSize = length-si->h.dataOffset;
 745
 746   si->fp=NULL;
 747
 748   return si;
 749 }
 750
 751 /* Stuff taken from wave.c from NAS.  Just like snd files, NAS can't
 752    read wave data from memory, so these functions do that for us. */
 753
 754 #define Err()           { return NULL; }
 755 #define readFourcc(_f)  dread(_f, sizeof(RIFF_FOURCC), 1)
 756 #define cmpID(_x, _y)                                                         \
 757     strncmp((char *) (_x), (char *) (_y), sizeof(RIFF_FOURCC))
 758 #define PAD2(_x)        (((_x) + 1) & ~1)
 759
 760 /* These functions here are for faking file I/O from buffer. */
 761
 762 /* The "file" position */
 763 static size_t file_posn;
 764 /* The length of the "file" */
 765 static size_t file_len;
 766 /* The actual "file" data. */
 767 static const void* file_data;
 768
 769 /* Like fopen, but for a buffer in memory */
 770 static void
 771 dopen (const void* data, size_t length)
 772 {
 773    file_data = data;
 774    file_len = length;
 775    file_posn = 0;
 776 }
 777
 778 /* Like fread, but for a buffer in memory */
 779 static int
 780 dread (void* buf, size_t size, size_t nitems)
 781 {
 782   size_t nread = size * nitems;
 783
 784   if (file_posn + nread <= file_len)
 785     {
 786       memcpy(buf, (char *) file_data + file_posn, size * nitems);
 787       file_posn += nread;
 788       return nitems;
 789     }
 790   else
 791     {
 792       return EOF;
 793     }
 794 }
 795
 796 /* Like fgetc, but for a buffer in memory */
 797 static int
 798 dgetc (void)
 799 {
 800   if (file_posn < file_len)
 801     return ((char *)file_data)[file_posn++];
 802   else
 803     return -1;
 804 }
 805
 806 /* Like fseek, but for a buffer in memory */
 807 static int
 808 dseek (long offset, int from)
 809 {
 810   if (from == 0)
 811     file_posn = offset;
 812   else if (from == 1)
 813     file_posn += offset;
 814   else if (from == 2)
 815     file_posn = file_len + offset;
 816
 817   return 0;
 818 }
 819
 820 /* Like ftell, but for a buffer in memory */
 821 static long
 822 dtell (void)
 823 {
 824   return file_posn;
 825 }
 826
 827 /* Data buffer analogs for FileReadS and FileReadL in NAS. */
 828
 829 static unsigned short
 830 DataReadS (int swapit)
 831 {
 832     unsigned short us;
 833
 834     dread(&us, 2, 1);
 835     if (swapit)
 836         us = FileSwapS(us);
 837     return us;
 838 }
 839
 840 static AuUint32
 841 DataReadL (int swapit)
 842 {
 843     AuUint32 ul;
 844
 845     dread(&ul, 4, 1);
 846     if (swapit)
 847         ul = FileSwapL(ul);
 848     return ul;
 849 }
 850
 851 static int
 852 readChunk (RiffChunk *c)
 853 {
 854     int             status;
 855     char            n;
 856
 857     if ((status = dread(c, sizeof(RiffChunk), 1)))
 858         if (NAS_BIG_ENDIAN)
 859             swapl(&c->ckSize, n);
 860
 861     return status;
 862 }
 863
 864 /* A very straight-forward translation of WaveOpenFileForReading to
 865    read the wave data from a buffer in memory. */
 866
 867 static WaveInfo *
 868 WaveOpenDataForReading (const char *data,
 869                         int length)
 870 {
 871     RiffChunk       ck;
 872     RIFF_FOURCC     fourcc;
 873     AuInt32            fileSize;
 874     WaveInfo       *wi;
 875
 876
 877     if (!(wi = (WaveInfo *) malloc(sizeof(WaveInfo))))
 878         return NULL;
 879
 880     wi->comment = NULL;
 881     wi->dataOffset = wi->format = wi->writing = 0;
 882
 883     dopen(data, length);
 884
 885     if (!readChunk(&ck) ||
 886         cmpID(&ck.ckID, RIFF_RiffID) ||
 887         !readFourcc(&fourcc) ||
 888         cmpID(&fourcc, RIFF_WaveID))
 889         Err();
 890
 891     fileSize = PAD2(ck.ckSize) - sizeof(RIFF_FOURCC);
 892
 893     while (fileSize >= (AuInt32) sizeof(RiffChunk))
 894     {
 895         if (!readChunk(&ck))
 896             Err();
 897
 898         fileSize -= sizeof(RiffChunk) + PAD2(ck.ckSize);
 899
 900         /* LIST chunk */
 901         if (!cmpID(&ck.ckID, RIFF_ListID))
 902         {
 903             if (!readFourcc(&fourcc))
 904                 Err();
 905
 906             /* INFO chunk */
 907             if (!cmpID(&fourcc, RIFF_ListInfoID))
 908             {
 909                 ck.ckSize -= sizeof(RIFF_FOURCC);
 910
 911                 while (ck.ckSize)
 912                 {
 913                     RiffChunk       c;
 914
 915                     if (!readChunk(&c))
 916                         Err();
 917
 918                     /* ICMT chunk */
 919                     if (!cmpID(&c.ckID, RIFF_InfoIcmtID))
 920                     {
 921                         if (!(wi->comment = (char *) malloc(c.ckSize)) ||
 922                             !dread(wi->comment, c.ckSize, 1))
 923                             Err();
 924
 925                         if (c.ckSize & 1)
 926                             dgetc();    /* eat the pad byte */
 927                     }
 928                     else
 929                         /* skip unknown chunk */
 930                         dseek(PAD2(c.ckSize), 1);
 931
 932                     ck.ckSize -= sizeof(RiffChunk) + PAD2(c.ckSize);
 933                 }
 934             }
 935             else
 936                 /* skip unknown chunk */
 937                 dseek(PAD2(ck.ckSize) - sizeof(RIFF_FOURCC), 1);
 938         }
 939         /* wave format chunk */
 940         else if (!cmpID(&ck.ckID, RIFF_WaveFmtID) && !wi->format)
 941         {
 942             AuInt32            dummy;
 943
 944             wi->format = DataReadS(NAS_BIG_ENDIAN);
 945             wi->channels = DataReadS(NAS_BIG_ENDIAN);
 946             wi->sampleRate = DataReadL(NAS_BIG_ENDIAN);
 947
 948             /* we don't care about the next two fields */
 949             dummy = DataReadL(NAS_BIG_ENDIAN);
 950             dummy = DataReadS(NAS_BIG_ENDIAN);
 951
 952             if (wi->format != RIFF_WAVE_FORMAT_PCM)
 953                 Err();
 954
 955             wi->bitsPerSample = DataReadS(NAS_BIG_ENDIAN);
 956
 957             /* skip any other format specific fields */
 958             dseek(PAD2(ck.ckSize - 16), 1);
 959         }
 960         /* wave data chunk */
 961         else if (!cmpID(&ck.ckID, RIFF_WaveDataID) && !wi->dataOffset)
 962         {
 963             long endOfFile;
 964
 965             wi->dataOffset = dtell();
 966             wi->dataSize = ck.ckSize;
 967             dseek(0, 2);
 968             endOfFile = dtell();
 969
 970             /* seek past the data */
 971             if (dseek(wi->dataOffset + PAD2(ck.ckSize), 0) ||
 972                 dtell() > endOfFile)
 973             {
 974                 /* the seek failed, assume the size is bogus */
 975                 dseek(0, 2);
 976                 wi->dataSize = dtell() - wi->dataOffset;
 977             }
 978
 979             wi->dataOffset -= sizeof(long);
 980         }
 981         else
 982             /* skip unknown chunk */
 983             dseek(PAD2(ck.ckSize), 1);
 984     }
 985
 986     if (!wi->dataOffset)
 987         Err();
 988
 989     wi->numSamples = wi->dataSize / wi->channels / (wi->bitsPerSample >> 3);
 990
 991     if (!wi->comment)
 992        wi->comment = NameFromData (data + wi->dataOffset,
 993                                    length - wi->dataOffset);
 994
 995     wi->fp = NULL;
 996
 997     return wi;
 998 }
 999
1000
1001 static Sound
1002 SoundOpenDataForReading (unsigned char *data,
1003                          int length)
1004
1005 {
1006   Sound s;
1007 #if (AudioLibraryVersionMajor >= 2 ) && (AudioLibraryVersionMinor >= 3)
1008   SoundFileInfoProc toProc;
1009 #endif
1010
1011   if (!(s = (Sound) malloc (sizeof (SoundRec))))
1012     return NULL;
1013
1014   if ((s->formatInfo = SndOpenDataForReading ((char *) data, length)) != NULL)
1015     {
1016 #if (AudioLibraryVersionMajor >= 2 ) && (AudioLibraryVersionMinor >= 3)
1017       if ((toProc = SoundFileGetProc(SoundFileFormatSnd,
1018                                      SoundFileInfoProcTo)) == NULL)
1019         {
1020           SndCloseFile ((SndInfo *) (s->formatInfo));
1021           free (s);
1022
1023           return NULL;
1024         }
1025       if (!((*toProc)(s)))
1026 #else
1027       if (!((int(*)(Sound))(SoundFileInfo[SoundFileFormatSnd].toSound)) (s))
1028 #endif
1029         {
1030           SndCloseFile ((SndInfo *) (s->formatInfo));
1031           free (s);
1032           return NULL;
1033         }
1034     }
1035   else if ((s->formatInfo = WaveOpenDataForReading ((char *) data, length)) != NULL)
1036     {
1037 #if (AudioLibraryVersionMajor >= 2 ) && (AudioLibraryVersionMinor >= 3)
1038       if ((toProc = SoundFileGetProc(SoundFileFormatWave,
1039                                      SoundFileInfoProcTo)) == NULL)
1040         {
1041           WaveCloseFile ((WaveInfo *) (s->formatInfo));
1042           free (s);
1043
1044           return NULL;
1045         }
1046       if (!((*toProc)(s)))
1047 #else
1048       if (!((int(*)(Sound))(SoundFileInfo[SoundFileFormatWave].toSound)) (s))
1049 #endif
1050         {
1051           WaveCloseFile ((WaveInfo *) (s->formatInfo));
1052           free (s);
1053           return NULL;
1054         }
1055     }
1056
1057   return s;
1058 }