home *** CD-ROM | disk | FTP | other *** search
/ Dream 44 / Amiga_Dream_44.iso / Linux / Apps / xanim.tgz / xanim / xanim27064 / xa_audio.c < prev    next >
Text File  |  1997-01-26  |  151KB  |  5,202 lines
  1.  
  2. /*
  3.  * xa_audio.c
  4.  *
  5.  * Copyright (C) 1994,1995,1996,1997 by Mark Podlipec.
  6.  * All rights reserved.
  7.  *
  8.  * This software may be freely copied, modified and redistributed without
  9.  * fee for non-commerical purposes provided that this copyright notice is
  10.  * preserved intact on all copies and modified copies.
  11.  *
  12.  * There is no warranty or other guarantee of fitness of this software.
  13.  * It is provided solely "as is". The author(s) disclaim(s) all
  14.  * responsibility and liability with respect to this software's usage
  15.  * or its effect upon hardware or computer systems.
  16.  *
  17.  */
  18.  
  19. /***************************************************************************
  20.  * Fixes (Most are sent in by beta testers for which I'm grateful)
  21.  *
  22.  *       - Linux: jixer should be mixer.
  23.  *       - Linux: Added 8 bit converison routines.
  24.  *       - Solaris audioio.h in include/sys not include/sun.
  25.  * 3Aug94  - Signals Suck. Use XtAppAddTimeOut instead.
  26.  * 4Aug94  - Linux 8 bit init incorrectly returning XA_AUDIO_SIGNED_1M.
  27.  *           Now it's XA_AUDIO_LINEAR_1M.
  28.  * 4Aug94  - Solaris opening ioctl using devtype instead of type and
  29.  *         type should be audio_device_t (missing _t before).
  30.  * 4Aug94  - Linux: ioctl call to set volume was be reference only. It's
  31.  *         now properly #ifdef'd depending on XA_LINUX_NEWER_SND.
  32.  * 5Aug94  - Linux: volume ioctl uses SOUND_MIXER_VOLUME now. Did try
  33.  *         SOUND_MIXER_PCM, but some machines didn't like that.
  34.  * 8Aug94  - All: added XA_Audio_Pause routine for those devices that
  35.  *         support pause/resume. Much better that having to flush it.
  36.  *       - Solaris: XA_SOLARIS should've been SOLARIS. was causing
  37.  *         core dumps etc.
  38.  *       - ALL(but only affects Solaris): Solaris doesn't like writes to
  39.  *         the audio buffer that aren't multiples of it's size. Is this
  40.  *         the problem with SGI's? Anyways UpdateRing now enforces this.
  41.  *       - Sparc: Detects if audio device is already in use and continues
  42.  *         on without it. Before it used to hang until audio was freed.
  43.  *       - Sparc: Volume turned off when flushing and then back on after.
  44.  *         Gets rid of clicks/pops when exiting.
  45.  * 10Aug94 - Fixed problem with SGI machines. Samples not bytes and 
  46.  *        - SIGNED_2MB not LINEAR_2MB.
  47.  * 10Aug94 - Change volume to 0-100%. May have broken them all. :^)
  48.  * 11Aug94 - Added code for HP9000/700 series. Have no clue if it works.
  49.  * 31Aug94 - Linux: Finally got the linux docs. I'm not querying the device
  50.  *         to see what volume channel to use.
  51.  * 12Sep94 - SPARC 5: now look for CS4231 Audio devices. Should be treated
  52.  *         the same as  Sparc 10's DBRI device.
  53.  * 21Sep94 - ALL: Closest_Freq() must have ifreq be signed in order for the
  54.  *           comparison's to be done correctly.
  55.  * 22Sep94 - Screw Pausing for now. Will put back later if deemed necessary.
  56.  * 27Sep94 - HP: found serious typo bug that caused the Audio Ring buffers
  57.  *         to be overwritten by a large amount, trashing all sorts of
  58.  *         memory and causing much grief. Thanks to John Atwood for
  59.  *         helping find this one.
  60.  * 13Oct94 - SGI: really change LINEAR_2MB to be SIGNED_2MB this time. Arrgh.
  61.  * 26Oct94 - Added code to support NAS 1.2 p1 
  62.  *                    - Bob Phillips (bobp@syl.nj.nec.com)
  63.  * 28Oct94 - Added code to support NEC EWS 4800/330 - NEC
  64.  *                    - Bob Phillips (bobp@syl.nj.nec.com)
  65.  * 02Nov94 - AF hardware type was set to 16 bit little endian, yet the AF
  66.  *         library was told to expect native endian. This didn't work
  67.  *         on Suns(nor would it on other big endian machines).
  68.  *                            - Andrzej Filinski <andrzej+@POP.CS.CMU.EDU>
  69.  * 13Nov94 - NAS: fine tuned code for less drop out. Fixed up stop/start
  70.  *         problems(echos).
  71.  * 13Jan95 - SGI: sgi volume is exponentional, not linear - Paul Close
  72.  * 19Jan95 - Sparc: Older Sparc can only have 1 audio output at a time
  73.  *           and not 0. This made it impossible to enable the headphones
  74.  *         because the code would first try turning off the speaker and
  75.  *         take an error.
  76.  * 30Jan95 - SONY: added support for Sony NEWS-5000 workstations - code
  77.  *         written by Kazushi Yoshida.
  78.  * 16Mar95 - Finished remodified audio/vidoe sync code to handle more
  79.  *           compute intensive video(large frame or jpeg/mpeg)
  80.  * 17Mar95 - Merged Audio_Outputs into one routine so I didn't have to
  81.  *           keep modifying all of them(95% of the code was the same).
  82.  * 17Mar95 - Fixed bug in NAS audio that caused memory corruption after
  83.  *           an "unable to Toggle" error.
  84.  * 17Mar95 - Added Audio support for IBM AIX S6000 machines - 
  85.  *        Code written by jeffk@watson.ibm.com (Jeff Kusnitz)
  86.  * 06Apr95 - Added Audio support for directly using HP's Audio Device
  87.  *        rather than going through all the upper audio library
  88.  *        layers. (HPDEV) Code written by Tobias Bading.
  89.  * 10Apr95 - Fixed bug where when Audio finished before Video, it wasn't
  90.  *         being turned off before being turned on during the next loop
  91.  *         or for the next animation.
  92.  * 10Apr95 - Fixed where hard_buff size was being set larger than the
  93.  *         allocated buffer size for the following machines(Linux/AIX.
  94.  *           (All sorts of bad behavior - core's dumps etc).
  95.  * 10Apr95 - Fixed MS ADPCM bug when 11Khx and 22Khz ADPCM freq were scaled
  96.  *         to 8Khz.
  97.  * 30Apr95 - Added audio support for Digital Alpha workstations
  98.  *           running MMS (morris@zko.dec.com)
  99.  * 11May95 - Added Audio support for NetBSD - written by Roland C Dowdeswell.
  100.  * 13Jun95 - SONY: modified for SVR4/NEWS-OS 6.x machines 
  101.  *         by Takashi Hagiwara, Sony Corporation (hagiwara@sm.sony.co.jp)
  102.  * 04Sep95 - SOLARIS: replaced SOLARIS define with SVR4. see what happens.
  103.  * 12Apr96 - HPDEV: occasionally audio device reports busy when trying to
  104.  *           set the sample rate. Now loop on this condition.
  105.  * 25Nov96 - HP AServer. Code fixed up by Steve Waterworth.
  106.  *
  107.  ****************************************************************************/
  108.  
  109.  
  110. /****************************************************************************/
  111. /**************** AUDIO DOCUMENTATION ***************************************/
  112. /****************************************************************************/
  113. /*
  114.  In order to support other machines type - XXX, the following routines must
  115.  be created and should be inside an #ifdef XA_XXX_AUDIO.
  116.  
  117.  Currently Needed Routines:
  118.  -----------------------------------
  119.    void  XA_Audio_Setup()
  120.    void  XXX_Audio_Init()
  121.    void  XXX_Audio_Kill()
  122.    void  XXX_Audio_Off()
  123.    void  XXX_Audio_On()
  124.    xaULONG XXX_Closest_Freq(target_freq)
  125.    void  XXX_Set_Audio_Out(flag)   slowly replacing toggles 
  126.    void  XXX_Speaker_Tog(flag)
  127.    void  XXX_Headphone_Tog(flag)
  128.    void  XXX_LineOut_Tog(flag)
  129.    void  XXX_Audio_Output()
  130.  
  131.  Currently Optional Routines:
  132.  -----------------------------------
  133.    XXX_Adjust_Volume(volume)
  134.  
  135.  NOTES: Currently stereo isn't supported. It could/can/will be added
  136.  later.
  137.  
  138.  The routine XA_Audio_Setup is responsible for mapping these routines
  139.  to the same routines(with XXX replaced by XA). See the XA_Audio_Setup
  140.  in the Sun section.
  141.  
  142.  Also the Hardware Audio Type should be defined in xanim.h. See the
  143.  AUDIO SECTION of xanim.h. This is then used in XA_Add_Sound routine
  144.  to determine the correct audio codec routine to convert the anim's
  145.  audio format to the hardware's audio format.
  146. (NOTE: moving toward asking hardware what it can support for each
  147.        type of audio. )
  148.  
  149.  Brief description of how XAnim does the sound(may not be correct or finished
  150.  at the time you read this :^)
  151.  
  152.  As XAnim intially parses through the animations, a link list of SND_HDR's
  153.  is created(with the XA_Add_Sound routine) and attached to that animation
  154.  (in it's ANIM_HDR). These SND_HDR's contain audio information/data as it
  155.  existed in the animation file(it may just have a file postion and length so
  156.  the audio data can be read into memory or it may have a buffer already 
  157.  containing the audio data).
  158.  
  159.  XA_Add_Sound determines if the audio format is support and what routine
  160.  should be used to decompress the audio. It also determines the closest
  161.  hardware frequency(with XA_Closest_Freq) and calculates how much time
  162.  (ms and fractional ms) it will take to play a converted sample that
  163.  is xa_audio_hard_buf(set by XA_Closest_Freq) samples in size along
  164.  with other information.
  165.  
  166.  A Ring of Audio buffers is created at init time(by XA_Audio_Init).
  167.  The XA_Update_Ring routine fills these buffers with identical sized
  168.  chunks of converted audio. The fact they're the same size simplifies
  169.  the keeping of audio time(since each audio chunk takes exactly the
  170.  same amount of time-which has been pre-calculated). audio time is
  171.  used to keep the video in sync with the audio.
  172.  
  173.  XA_Update_Ring is called in XA_Audio_On() just before audio is
  174.  started up and is called in XA_Audio_Output() after a Audio Ring
  175.  buffer has been sent to the audio device.
  176.  
  177.  XA_Update_Ring fills empty ring positions by walking along the list
  178.  of SND_HDRs, converting the anim's audio to the proper audio format
  179.  a chunk at a time. It does this by calling the audio codec function
  180.  for that SND_HDR. The audio codec function converts and moves a set
  181.  number of audio samples into the given ring buffer and then returns
  182.  how many bytes in size that is.
  183.  
  184.  XA_Audio_Output just has to look at the current audio ring pointer,
  185.  send that many bytes to the audio device, update the audio time,
  186.  move along the ring and then call XA_Update_Ring.
  187.  
  188.  I might make XA/XXX_Audio_Output generic and then make machine
  189.  specific sub portions of it. As more machine types are added this
  190.  might make more sense.
  191.  
  192.  ----
  193.  
  194.  NOTE: I'm moving toward a separate audio process, this allows
  195.        blocking when writing to the audio device.  However, the
  196.        audio device should be opened non-blocking so that
  197.        XAnim may continue on without audio if the audio device
  198.        is in use by another program.
  199.  
  200.  XA_Audio_On() should enable and startup the audio. 
  201.  
  202.  XA_Audio_Off() should stop the audio. Ideally this routine should
  203.  immediate stop audio and flush what ever information has piled
  204.  up. Unfortunately, many audio drivers are (deficient?) lacking
  205.  this support.
  206.  
  207.  XA_Audio_Init() opens the audio device and initializes the variables.
  208.  XA_Audio_Kill() closes the device and frees up any hardware specific
  209.  memory structures.
  210.  
  211.  ----
  212.  Mark Podlipec - podlipec@Baynetworks.com  or  podlipec@@shell.portal.com
  213. */
  214.  
  215. /* TOP */
  216.  
  217. #include "xa_audio.h"
  218.  
  219. /* POD note:  For opening audio device non-blocking. Should probably set it
  220.  * back to blocking after successful open, but ONLY if compiling with
  221.  * the audio child.
  222.  */
  223.  
  224. #ifndef O_NDELAY
  225. #ifdef O_NONBLOCK
  226. #define O_NDELAY  O_NONBLOCK
  227. #else
  228. #define O_NDELAY 0
  229. #endif
  230. #endif
  231.  
  232. extern XA_AUD_FLAGS *vaudiof;
  233. extern xaULONG xa_vaudio_present;
  234. extern XtAppContext  theAudContext;
  235.  
  236.  
  237. /***************** ITIMER EXPERIMENTATION ********************************/
  238. /* number of ms we let audio buffer get ahead of actual audio. */
  239. xaLONG xa_out_time = 250; /* PODNOTE: this is actually reset later on */
  240. xaULONG xa_out_init = 0;  /* number of initial audio ring bufs to write ahead*/
  241.  
  242. /* 1000/XA_OUT_FREQADJ is number of extra itimer calls  */
  243. #define XA_OUT_FREQADJ 1000
  244.  
  245. /***************** XtAppAddTimeOut EXPERIMENTATION *************************/
  246. XtIntervalId xa_interval_id = 0;
  247. xaULONG        xa_interval_time = 1;
  248.  
  249. extern Display    *theDisp;
  250. extern xaULONG    xa_kludge900_aud;
  251.  
  252.  
  253. /**** Non Hardware Specific Functions ************/
  254. void XA_Audio_Init_Snd();
  255. void Init_Audio_Ring();
  256. void Kill_Audio_Ring();
  257. void XA_Update_Ring();
  258. void XA_Flush_Ring();
  259. XA_SND *XA_Audio_Next_Snd();
  260. void XA_Read_Audio_Delta();
  261. xaLONG XA_Read_AV_Time();
  262. extern xaLONG xa_time_now;
  263. extern xaUBYTE *xa_audcodec_buf;
  264. extern xaULONG xa_audcodec_maxsize;
  265. extern int xa_aud_fd;
  266.  
  267.  
  268. extern xaULONG XA_ADecode_PCMXM_PCM1M();
  269. extern xaULONG XA_ADecode_PCM1M_PCM2M();
  270. extern xaULONG XA_ADecode_DVIM_PCMxM();
  271. extern xaULONG XA_ADecode_DVIS_PCMxM();
  272. extern xaULONG XA_ADecode_IMA4M_PCMxM();
  273. extern xaULONG XA_ADecode_IMA4S_PCMxM();
  274.  
  275.  
  276. typedef struct AUDIO_RING_STRUCT
  277. {
  278.   xaULONG time;
  279.   xaULONG timelo;
  280.   xaULONG len;
  281.   xaUBYTE *buf;
  282.   struct AUDIO_RING_STRUCT *next;
  283. } XA_AUDIO_RING_HDR;
  284.  
  285. XA_AUDIO_RING_HDR *xa_audio_ring = 0;
  286. XA_AUDIO_RING_HDR *xa_audio_ring_t = 0;
  287.  
  288. #define XA_AUDIO_MAX_RING_BUFF 2048
  289.  
  290. /* NOTE: These must NOT be larger than XA_AUDIO_MAX_RING_BUFF above */
  291. #define XA_HARD_BUFF_2K 2048
  292. #define XA_HARD_BUFF_1K 1024
  293.  
  294.  
  295. void Gen_Ulaw_2_Signed();
  296. void Gen_Signed_2_Ulaw();
  297. void Gen_Arm_2_Signed();
  298.  
  299. xaLONG  XA_Ulaw_to_Signed();
  300. xaUBYTE XA_Signed_To_Ulaw();
  301. xaULONG XA_Audio_Linear_To_AU();
  302.  
  303. /*POD NOTE: Make these tables dynamically allocated */
  304. /* Sun ULAW CONVERSION TABLES/ROUTINES */
  305. xaUBYTE xa_sign_2_ulaw[256];
  306. xaULONG xa_ulaw_2_sign[256];
  307.  
  308. /* ARM VIDC MULAW CONVERSION TABLES/ROUTINES */
  309. xaULONG xa_arm_2_signed[256];
  310.  
  311. /* AUDIO CODEC DELTA ROUTINES */ 
  312. xaULONG XA_Audio_1M_1M();
  313. xaULONG XA_Audio_PCM1M_PCM2M();
  314. xaULONG XA_Audio_PCM1S_PCM2M();
  315. xaULONG XA_Audio_PCMXM_PCM1M();
  316. xaULONG XA_Audio_PCMXS_PCM1M();
  317. xaULONG XA_Audio_PCM2X_PCM2M();
  318.  
  319.  
  320. /* AUDIO CODEC BUFFERING ROUTINES */
  321.  
  322. extern xaULONG xa_audio_present;
  323. extern xaULONG xa_audio_status;
  324.  
  325. extern XA_SND *xa_snd_cur;
  326. extern xaLONG  xa_time_audio;
  327. extern xaLONG  xa_timelo_audio;
  328.  
  329. extern XA_AUD_FLAGS *XAAUD;
  330. /*
  331. extern xaULONG xa_audio_mute;
  332. extern xaLONG  xa_audio_volume;
  333. extern xaULONG xa_audio_newvol;
  334. extern double xa_audio_scale;
  335. extern xaULONG xa_audio_buffer;
  336. extern xaULONG xa_audio_playrate;
  337. extern xaULONG xa_audio_divtest;  Z* testing only *Z
  338. extern xaULONG xa_audio_port;
  339. */
  340.  
  341. xaULONG xa_vaudio_hard_buff = 0;        /* VID Domain snd chunk size */
  342.  
  343. xaULONG xa_audio_hard_freq;        /* hardware frequency */
  344. xaULONG xa_audio_hard_buff;        /* preferred snd chunk size */
  345. xaULONG xa_audio_ring_size;        /* preferred num of ring entries */
  346. xaULONG xa_audio_hard_type;        /* hardware sound encoding type */
  347. xaULONG xa_audio_hard_bps;        /* hardware bytes per sample */
  348. xaULONG xa_audio_hard_chans;        /* hardware number of chan. not yet */
  349. xaULONG xa_audio_flushed = 0;
  350.  
  351. void  XA_Audio_Setup();
  352. void (*XA_Audio_Init)();
  353. void (*XA_Audio_Kill)();
  354. void (*XA_Audio_Off)();
  355. void (*XA_Audio_On)();
  356. void (*XA_Adjust_Volume)();
  357. xaULONG (*XA_Closest_Freq)();
  358. void  (*XA_Set_Output_Port)(); /* POD slowly replacing _Tog's */
  359. void  (*XA_Speaker_Tog)();
  360. void  (*XA_Headphone_Tog)();
  361. void  (*XA_LineOut_Tog)();
  362.  
  363. void New_Merged_Audio_Output();
  364.  
  365.  
  366. /****************************************************************************/
  367. /**************** NULL AUDIO DEFINED ROUTINES********************************/
  368. /****************************************************************************/
  369. /* useful for backing out audio when device opens fails, etc */
  370.  
  371. void  XA_NoAudio_Nop();
  372. xaULONG XA_NoAudio_Nop1();
  373. void  XA_NoAudio_Nop2();
  374. void  XA_Null_Audio_Setup();
  375.  
  376. void XA_Null_Audio_Setup()
  377. {
  378.   XA_Audio_Init        = XA_NoAudio_Nop;
  379.   XA_Audio_Kill        = XA_NoAudio_Nop;
  380.   XA_Audio_Off        = XA_NoAudio_Nop2;
  381.   XA_Audio_On        = XA_NoAudio_Nop;
  382.   XA_Closest_Freq    = XA_NoAudio_Nop1;
  383.   XA_Set_Output_Port    = XA_NoAudio_Nop2;
  384.   XA_Speaker_Tog    = XA_NoAudio_Nop;
  385.   XA_Headphone_Tog    = XA_NoAudio_Nop;
  386.   XA_LineOut_Tog    = XA_NoAudio_Nop;
  387.  
  388.   xa_snd_cur = 0;
  389.   xa_audio_present = XA_AUDIO_UNK;
  390.   xa_audio_status  = XA_AUDIO_STOPPED;
  391.   xa_audio_ring_size  = 8;
  392. }
  393. void XA_NoAudio_Nop()                { return; }
  394. void XA_NoAudio_Nop2(flag)    xaULONG flag;    { return; }
  395. xaULONG XA_NoAudio_Nop1(num)    xaULONG num;    { return(0); }
  396.  
  397. /****************************************************************************/
  398. /**************** NO AUDIO DEFINED ROUTINES *********************************/
  399. /****************************************************************************/
  400. #ifndef XA_AUDIO
  401.  
  402. void XA_No_Audio_Support();
  403.  
  404. void XA_Audio_Setup()
  405. { 
  406.   XA_Null_Audio_Setup();
  407.   XA_Audio_Init    = XA_No_Audio_Support;
  408. }
  409.  
  410. void XA_No_Audio_Support()
  411. {
  412.   fprintf(stderr,"AUDIO SUPPORT NOT COMPILED IN THIS EXECUTABLE.\n");
  413.   return;
  414. }
  415. #endif
  416. /****************************************************************************/
  417. /******************* END OF NO AUDIO SPECIFIC ROUTINES **********************/
  418. /****************************************************************************/
  419.  
  420.  
  421. /****************************************************************************/
  422. /**************** SPARC SPECIFIC ROUTINES ***********************************/
  423. /****************************************************************************/
  424. #ifdef XA_SPARC_AUDIO
  425.  
  426. /******** START OF FIX SUN **********************************/
  427. /* SINCE CC, GCC and SUN can't get their act together, let's do it
  428.  * for them. This is to fix some SERIOUS Bugs with Sun's include files.
  429.  *
  430.  * CC works fine with /usr/include/sys/ioccom.h, but not gnu's
  431.  * GCC works fine with it's version of Sun's ioccom.h, but not sun's
  432.  * You mix them up and your code doesn't run. ARGH!!!
  433.  */
  434.  
  435. /* POD NOTE: We'll NOW HAVE TO RELY ON XA_???_AUDIO defines to determine
  436.  * SUN IO compatiblities. Wadda pain.
  437.  */
  438. #ifndef SVR4    /* was SOLARIS */
  439.  
  440. /* from sys/ioccom.h */
  441. #undef _IO
  442. #define _IO(x,y)        (_IOC_VOID|((x)<<8)|y)
  443. #undef _IOR
  444. #define _IOR(x,y,t)     (_IOC_OUT|((sizeof(t)&_IOCPARM_MASK)<<16)|((x)<<8)|y)
  445. #undef _IOWR
  446. #define _IOWR(x,y,t)    (_IOC_INOUT|((sizeof(t)&_IOCPARM_MASK)<<16)|((x)<<8)|y)
  447.  
  448. /* from audioio.h  A = 0x41 */
  449. #undef AUDIO_GETINFO
  450. #define AUDIO_GETINFO   _IOR(0x41, 1, audio_info_t)
  451. #undef AUDIO_SETINFO
  452. #define AUDIO_SETINFO   _IOWR(0x41, 2, audio_info_t)
  453. #undef AUDIO_DRAIN
  454. #define AUDIO_DRAIN     _IO(0x41, 3)
  455. #undef AUDIO_GETDEV
  456. #define AUDIO_GETDEV    _IOR(0x41, 4, int)
  457.  
  458. /* from stropts.h S = 0x53*/
  459. #undef I_FLUSH
  460. #define I_FLUSH         _IO(0x53,05)
  461. /******** END OF FIX SUN **********************************/
  462. #endif
  463.  
  464. #ifndef AUDIO_ENCODING_LINEAR
  465. #define AUDIO_ENCODING_LINEAR (3)
  466. #endif
  467. #ifndef AUDIO_ENCODING_ULAW
  468. #define AUDIO_ENCODING_ULAW (3)
  469. #endif
  470. #ifndef AUDIO_DEV_UNKNOWN
  471. #define AUDIO_DEV_UNKNOWN (0)
  472. #endif
  473. #ifndef AUDIO_DEV_AMD
  474. #define AUDIO_DEV_AMD (1)
  475. #endif
  476. #ifndef AUDIO_SPEAKER
  477. #define AUDIO_SPEAKER 0x01
  478. #endif
  479. #ifndef AUDIO_HEADPHONE
  480. #define AUDIO_HEADPHONE 0x02
  481. #endif
  482. #ifndef AUDIO_LINE_OUT
  483. #define AUDIO_LINE_OUT 0x04
  484. #endif
  485. #ifndef AUDIO_MIN_GAIN
  486. #define AUDIO_MIN_GAIN (0)
  487. #endif
  488. #ifndef AUDIO_MAX_GAIN
  489. #define AUDIO_MAX_GAIN (255)
  490. #endif
  491.  
  492.  
  493. void  Sparc_Audio_Init();
  494. void  Sparc_Audio_Kill();
  495. void  Sparc_Audio_Off();
  496. void  Sparc_Audio_On();
  497. void  Sparc_Adjust_Volume();
  498. xaULONG Sparc_Closest_Freq();
  499. void Sparc_Set_Output_Port();
  500. void Sparc_Speaker_Toggle();
  501. void Sparc_Headphone_Toggle();
  502.  
  503. #define SPARC_MAX_VOL AUDIO_MAX_GAIN
  504. #define SPARC_MIN_VOL AUDIO_MIN_GAIN
  505.  
  506. static int devAudio;
  507. static audio_info_t audio_info;
  508.  
  509.  
  510. /********** XA_Audio_Setup **********************
  511.  * 
  512.  * Also defines Sparc Specific variables.
  513.  *
  514.  *****/
  515. void XA_Audio_Setup()
  516. {
  517.  
  518.   XA_Audio_Init        = Sparc_Audio_Init;
  519.   XA_Audio_Kill        = Sparc_Audio_Kill;
  520.   XA_Audio_Off        = Sparc_Audio_Off;
  521.   XA_Audio_On        = Sparc_Audio_On;
  522.   XA_Closest_Freq    = Sparc_Closest_Freq;
  523.   XA_Set_Output_Port    = Sparc_Set_Output_Port;
  524.   XA_Speaker_Tog    = Sparc_Speaker_Toggle;
  525.   XA_Headphone_Tog    = Sparc_Headphone_Toggle;
  526.   XA_LineOut_Tog    = Sparc_Headphone_Toggle;
  527.   XA_Adjust_Volume    = Sparc_Adjust_Volume;
  528.  
  529.   xa_snd_cur = 0;
  530.   xa_audio_present = XA_AUDIO_UNK;
  531.   xa_audio_status  = XA_AUDIO_STOPPED;
  532.   xa_audio_ring_size  = 8;
  533. }
  534.  
  535.  
  536. /********** Sparc_Audio_Init **********************
  537.  * Open /dev/audio and /dev/audioctl for Sparc's.
  538.  *
  539.  *****/
  540. void Sparc_Audio_Init()
  541. { int ret;
  542. #ifdef SVR4    /* was SOLARIS */
  543.   audio_device_t type;
  544. #else
  545.   int type;
  546. #endif
  547.   DEBUG_LEVEL2 fprintf(stderr,"Sparc_Audio_Init\n");
  548.   if (xa_audio_present != XA_AUDIO_UNK) return;
  549.   devAudio = open("/dev/audio", O_WRONLY | O_NDELAY);
  550.   if (devAudio == -1)
  551.   {
  552.     if (errno == EBUSY) fprintf(stderr,"Audio_Init: Audio device is busy. - ");
  553.     else fprintf(stderr,"Audio_Init: Error %x opening audio device. - ",errno);
  554.     fprintf(stderr,"Will continue without audio\n");
  555.     xa_audio_present = XA_AUDIO_ERR;
  556.     return;
  557.   }
  558.   ret = ioctl(devAudio, AUDIO_GETDEV, &type);
  559.   /* POD NOTE: Sparc 5 has new audio device (CS4231) */
  560. #ifdef SVR4    /* was SOLARIS */
  561.   if ( (   (strcmp(type.name, "SUNW,dbri"))   /* Not DBRI (SS10's) */
  562.         && (strcmp(type.name, "SUNW,CS4231")) /* and not CS4231 (SS5's) */
  563.         && (strcmp(type.name, "SUNW,sb16")))  /* and SoundBlaster 16 */
  564.       || ret) /* or ioctrl failed */
  565. #else
  566.   if (ret || (type==AUDIO_DEV_UNKNOWN) || (type==AUDIO_DEV_AMD) )
  567. #endif
  568.   { /* SPARC AU AUDIO */
  569.     DEBUG_LEVEL1 fprintf(stderr,"SPARC AMD AUDIO\n");
  570.     xa_audio_hard_type  = XA_AUDIO_SUN_AU;
  571.     xa_audio_hard_freq  = 8000;
  572.     xa_audio_hard_buff  = XA_HARD_BUFF_1K;             /* default buffer size */
  573.     xa_audio_hard_bps   = 1;
  574.     xa_audio_hard_chans = 1;
  575.     Gen_Signed_2_Ulaw();
  576.   }
  577.   else /* DBRI or CS4231 or SB16 */
  578.   {
  579.     DEBUG_LEVEL1 fprintf(stderr,"SPARC DBRI or CS4231 or SB16 AUDIO\n");
  580. #ifdef SVR4
  581. #ifdef _LITTLE_ENDIAN
  582.     xa_audio_hard_type  = XA_AUDIO_SIGNED_2ML;
  583. #else
  584.     xa_audio_hard_type  = XA_AUDIO_SIGNED_2MB; /* default to this */
  585. #endif
  586. #else
  587.     xa_audio_hard_type  = XA_AUDIO_SIGNED_2MB;
  588. #endif
  589.     xa_audio_hard_freq  = 11025;
  590.     xa_audio_hard_buff  = XA_HARD_BUFF_1K;             /* default buffer size */
  591.     xa_audio_hard_bps   = 2;
  592.     xa_audio_hard_chans = 1;
  593.     AUDIO_INITINFO(&audio_info);
  594. #ifdef SVR4    /* was SOLARIS */
  595. /* POD-NOTE: Does this necessarily have to be 1024 (what the upper/lower
  596.  * limits???)
  597.  */
  598.     audio_info.play.buffer_size = XA_HARD_BUFF_1K;
  599.     xa_audio_hard_buff  = XA_HARD_BUFF_1K;   /* default buffer size */
  600. #endif
  601.  
  602.     /* POD NOTE: this is currently used for testing purposes */
  603.     switch(xa_kludge900_aud)
  604.     {
  605.       case 900:
  606. fprintf(stderr,"Sun Audio: uLAW\n");
  607.     xa_audio_hard_type  = XA_AUDIO_SUN_AU;
  608.     xa_audio_hard_freq  = 8000;
  609.     xa_audio_hard_bps   = 1;
  610.     audio_info.play.sample_rate = 8000;
  611.     audio_info.play.channels = 1;
  612.     xa_audio_hard_bps   = 1;
  613.     audio_info.play.encoding = AUDIO_ENCODING_ULAW;
  614.     Gen_Signed_2_Ulaw();
  615.     break;
  616.       case 901:
  617. fprintf(stderr,"Sun Audio: 8 bit PCM\n");
  618.     audio_info.play.sample_rate = 11025;
  619.     audio_info.play.precision = 8;
  620.     audio_info.play.channels = 1;
  621.     audio_info.play.encoding = AUDIO_ENCODING_LINEAR;
  622.     break;
  623.       case 0:
  624.       default:
  625.     audio_info.play.sample_rate = 11025;
  626.     audio_info.play.precision = 16;
  627.     audio_info.play.channels = 1;
  628.     audio_info.play.encoding = AUDIO_ENCODING_LINEAR;
  629.     break;
  630.     }
  631.  
  632.     ret = ioctl(devAudio, AUDIO_SETINFO, &audio_info);
  633.     if (ret)
  634.     {
  635.       fprintf(stderr,"AUDIO BRI FATAL ERROR %d\n",errno);
  636.       xa_audio_present = XA_AUDIO_ERR;
  637.       return;
  638.     }
  639.   }
  640.   xa_interval_id = 0;
  641.   xa_audio_present = XA_AUDIO_OK;
  642.   DEBUG_LEVEL2 fprintf(stderr,"   success \n");
  643.   Init_Audio_Ring(xa_audio_ring_size,
  644.             (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps) );
  645. }
  646.  
  647. /********** Sparc_Audio_Kill **********************
  648.  * Close /dev/audio and /dev/audioctl.
  649.  *
  650.  *****/
  651. void Sparc_Audio_Kill()
  652. { 
  653.   /* TURN AUDIO OFF */
  654.   Sparc_Audio_Off(0);
  655.   xa_audio_present = XA_AUDIO_UNK;
  656.   /* SHUT THINGS DOWN  */
  657.   close(devAudio);
  658.   Kill_Audio_Ring();
  659. }
  660.  
  661. /********** Sparc_Audio_Off **********************
  662.  * Stop Audio Stream
  663.  *
  664.  *****/
  665. void Sparc_Audio_Off(flag)
  666. xaULONG flag;
  667. { long ret;
  668.  
  669.   if (xa_audio_status != XA_AUDIO_STARTED) return;
  670.  
  671.   /* SET FLAG TO STOP OUTPUT ROUTINE */
  672.   xa_audio_status = XA_AUDIO_STOPPED;
  673.  
  674.   /* TURN OFF SOUND ??? */
  675.   Sparc_Adjust_Volume(XA_AUDIO_MINVOL);
  676.  
  677.   /* FLUSH AUDIO DEVICE */
  678.   ret = ioctl(devAudio, I_FLUSH, FLUSHW);
  679.   if (ret == -1) fprintf(stderr,"Sparc Audio: off flush err %d\n",errno);
  680.  
  681.   xa_time_audio = -1;
  682.   xa_audio_flushed = 0;
  683.  
  684.   /* FLUSH AUDIO DEVICE AGAIN */
  685.   ret = ioctl(devAudio, I_FLUSH, FLUSHW);
  686.   if (ret == -1) fprintf(stderr,"Sparc Audio: off flush err %d\n",errno);
  687.  
  688.   /* RESTORE ORIGINAL VOLUME */
  689.   if (XAAUD->mute != xaTRUE) Sparc_Adjust_Volume(XAAUD->volume);
  690. }
  691.  
  692. /********** Sparc_Audio_On **********************
  693.  * Turn On Audio Stream.
  694.  *
  695.  *****/
  696. void Sparc_Audio_On()
  697. { 
  698.   DEBUG_LEVEL2 
  699.   {
  700.     fprintf(stderr,"Sparc_Audio_On \n");
  701.   }
  702.   if (xa_audio_status == XA_AUDIO_STARTED) return;
  703.   else if (xa_audio_present != XA_AUDIO_OK) return;
  704.   else if (xa_snd_cur)
  705.   { int ret;
  706.  
  707.     /* CHANGE FREQUENCY IF NEEDED */
  708.     if (xa_audio_hard_freq != xa_snd_cur->hfreq)
  709.     { audio_info_t a_info;
  710.       AUDIO_INITINFO(&a_info);
  711.       a_info.play.sample_rate = xa_snd_cur->hfreq;
  712.       ret = ioctl(devAudio, AUDIO_SETINFO, &a_info);
  713.       if (ret == -1) fprintf(stderr,"audio setfreq: freq %x errno %d\n",
  714.                         xa_snd_cur->hfreq, errno);
  715.       xa_audio_hard_freq = xa_snd_cur->hfreq;
  716.     }
  717.  
  718.     /* xa_snd_cur gets changes in Update_Ring() */
  719.     xa_out_time = 500;  /* keep audio fed 500ms ahead of video */
  720.     xa_out_init = xa_audio_ring_size - 1;
  721.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  722.  
  723. DEBUG_LEVEL1 fprintf(stderr,"ch_time %d out_time %d int time %d \n",xa_snd_cur->ch_time,xa_out_time,xa_interval_time);
  724.  
  725.     xa_audio_status = XA_AUDIO_STARTED;
  726.     XA_Flush_Ring();
  727.     XA_Update_Ring(1000);
  728.  
  729.     if (xa_interval_time == 0) xa_interval_time = 1;
  730.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  731.     New_Merged_Audio_Output();
  732.   }
  733. }
  734.  
  735.  
  736. /********** Sparc_Closest_Freq **********************************************
  737.  *
  738.  * Global Variable Affect:
  739.  *   xaULONG xa_audio_hard_buff        must set but not larger than
  740.  *                    XA_AUDIO_MAX_RING_BUF size
  741.  ****************************************************************************/
  742. xaULONG Sparc_Closest_Freq(ifreq)
  743. xaLONG ifreq;
  744. {
  745.  
  746. /* POD
  747. fprintf(stderr,"Sparc_Closest_Freq: hardtype %x freq %d\n",
  748.             xa_audio_hard_type,ifreq);
  749. */
  750.  
  751.   if (xa_audio_hard_type==XA_AUDIO_SIGNED_2MB)
  752.   { static int valid[] = { 8000, 9600, 11025, 16000, 18900, 22050, 32000,
  753.                   37800, 44100, 48000, 0};
  754.     xaLONG i = 0;
  755.     xaLONG best = 8000;
  756.  
  757.     xa_audio_hard_buff = XA_HARD_BUFF_1K;
  758.     while(valid[i])
  759.     { 
  760.       if (xaABS(valid[i] - ifreq) < xaABS(best - ifreq)) best = valid[i];
  761.       i++;
  762.     }
  763.     return(best);
  764.   }
  765.   else return(8000);
  766. }
  767.  
  768.  
  769. /* Eventually merge everything to one */
  770. void Sparc_Set_Output_Port(aud_ports)
  771. xaULONG aud_ports;
  772. { audio_info_t a_info;
  773.   xaLONG ret;
  774.   xaULONG sparc_ports = 0;
  775.   if (aud_ports & XA_AUDIO_PORT_INT)  sparc_ports |= AUDIO_SPEAKER;
  776.   if (aud_ports & XA_AUDIO_PORT_HEAD) sparc_ports |= AUDIO_HEADPHONE;
  777.   if (aud_ports & XA_AUDIO_PORT_EXT)  sparc_ports |= AUDIO_LINE_OUT;
  778.   AUDIO_INITINFO(&a_info);
  779.   a_info.play.port = sparc_ports;
  780.   ret = ioctl(devAudio, AUDIO_SETINFO, &a_info);
  781.   if (ret < 0) fprintf(stderr,"Audio: couldn't set speaker port %d\n",errno);
  782. }
  783.  
  784. /************* Sparc_Speaker_Toggle *****************************************
  785.  *
  786.  * flag = 0  turn speaker off
  787.  * flag = 1  turn speaker on
  788.  * flag = 2  toggle speaker
  789.  ****************************************************************************/
  790. void Sparc_Speaker_Toggle(flag)
  791. xaULONG flag;
  792. { 
  793.   switch(flag)
  794.   {
  795.     case  0: XAAUD->port &= ~XA_AUDIO_PORT_INT; break;
  796.     case  1: XAAUD->port |=  XA_AUDIO_PORT_INT; break;
  797.     default:  /* mutually exclusive set for now - never turn off */
  798.     { if ( !(XAAUD->port & XA_AUDIO_PORT_INT)) 
  799.         XAAUD->port = XA_AUDIO_PORT_INT;
  800.     }
  801.   }
  802.   Sparc_Set_Output_Port(XAAUD->port);
  803. }
  804.  
  805. /************* Sparc_Headphone_Toggle *****************************************
  806.  *
  807.  * flag = 0  turn headphones off
  808.  * flag = 1  turn headphones on
  809.  * flag = 2  toggle headphones
  810.  ****************************************************************************/
  811. void Sparc_Headphone_Toggle(flag)
  812. xaULONG flag;
  813. { 
  814.   switch(flag)
  815.   {
  816.     case  0: XAAUD->port &= ~XA_AUDIO_PORT_HEAD; break;
  817.     case  1: XAAUD->port |=  XA_AUDIO_PORT_HEAD; break;
  818.     default:  /* mutually exclusive set for now - never turn off */
  819.     { if ( !(XAAUD->port & XA_AUDIO_PORT_HEAD)) 
  820.         XAAUD->port = XA_AUDIO_PORT_HEAD;
  821.     }
  822.   }
  823.   Sparc_Set_Output_Port(XAAUD->port);
  824. }
  825.  
  826.  
  827. /********** Sparc_Adjust_Volume **********************
  828.  * Routine for Adjusting Volume on a Sparc
  829.  *
  830.  * Volume is in the range [0,XA_AUDIO_MAXVOL]
  831.  ****************************************************************************/
  832. void Sparc_Adjust_Volume(volume)
  833. xaULONG volume;
  834. { audio_info_t a_info;
  835.  
  836.   AUDIO_INITINFO(&a_info);
  837.   a_info.play.gain = SPARC_MIN_VOL +
  838.     ((volume * (SPARC_MAX_VOL - SPARC_MIN_VOL)) / XA_AUDIO_MAXVOL);
  839.   if (a_info.play.gain > SPARC_MAX_VOL) a_info.play.gain = SPARC_MAX_VOL;
  840.   ioctl(devAudio, AUDIO_SETINFO, &a_info);
  841. }
  842. #endif
  843. /****************************************************************************/
  844. /******************* END OF SPARC SPECIFIC ROUTINES *********************/
  845. /****************************************************************************/
  846.  
  847. /****************************************************************************/
  848. /**************** S/6000  SPECIFIC ROUTINES *********************************/
  849. /****************************************************************************/
  850. #ifdef XA_AIX_AUDIO
  851.  
  852. void  AIX_Audio_Init();
  853. void  AIX_Audio_Kill();
  854. void  AIX_Audio_Off();
  855. void  AIX_Audio_On();
  856.  
  857. xaULONG AIX_Closest_Freq();
  858. void  AIX_Speaker_Tog();
  859. void  AIX_Headphone_Tog();
  860. void  AIX_LineOut_Tog();
  861. void  AIX_Adjust_Volume();
  862.  
  863.  
  864. static int     devAudio;
  865. static xaULONG   aix_audio_ports;
  866. extern char  * xa_audio_device;
  867.  
  868. /*----------------------------------------------------------------------------*/
  869. /*                                                                            */
  870. /*----------------------------------------------------------------------------*/
  871. void XA_Audio_Setup ( )
  872. {
  873.   XA_Audio_Init =     AIX_Audio_Init;
  874.   XA_Audio_Kill =     AIX_Audio_Kill;
  875.   XA_Audio_Off =      AIX_Audio_Off;
  876.   XA_Audio_On =       AIX_Audio_On;
  877.   XA_Closest_Freq =   AIX_Closest_Freq;
  878.   XA_Speaker_Tog =    AIX_Speaker_Tog;
  879.   XA_Headphone_Tog =  AIX_Headphone_Tog;
  880.   XA_LineOut_Tog =    AIX_LineOut_Tog;
  881.   XA_Adjust_Volume    = AIX_Adjust_Volume;
  882.  
  883.   xa_snd_cur = 0;
  884.   xa_audio_present = XA_AUDIO_UNK;
  885.   xa_audio_status = XA_AUDIO_STOPPED;
  886.   xa_audio_ring_size = 8;
  887. }
  888.  
  889.  
  890. /*----------------------------------------------------------------------------*/
  891. /*                                                                            */
  892. /*----------------------------------------------------------------------------*/
  893. void AIX_Audio_Init ( )
  894. {
  895.   char         * devname;
  896.   audio_init     init;
  897.   audio_control  control;
  898.   audio_change   change;
  899.   int            rc;
  900.  
  901.   if ( xa_audio_present != XA_AUDIO_UNK )
  902.   {
  903.     return;
  904.   }
  905.  
  906.   devname = xa_audio_device;
  907.   if ( ( devAudio = open ( devname, O_WRONLY | O_NDELAY ) ) < 0 )
  908.   {
  909.     fprintf ( stderr, "AIX_Audio_Init: Open failed for '%s', errno = %d\n",
  910.               devname, errno );
  911.     xa_audio_present = XA_AUDIO_ERR;
  912.     return;
  913.   }
  914.  
  915.   /* Set the codec to some default values (the same ones the sun has   */
  916.   /* seem as good as any)                                              */
  917.  
  918.   xa_audio_hard_type  = XA_AUDIO_SIGNED_2MB;
  919.   xa_audio_hard_freq  = 11025;
  920.   xa_audio_hard_buff  = XA_HARD_BUFF_1K;
  921.   xa_audio_hard_bps   = 2;
  922.   xa_audio_hard_chans = 1;
  923.  
  924.   memset ( & init, '\0', sizeof ( init ) );
  925.  
  926.   init.srate =           11025;
  927.   init.mode =            PCM;
  928.   init.operation =       PLAY;
  929.   init.channels =        1;
  930.   init.flags =           BIG_ENDIAN | TWOS_COMPLEMENT;
  931.   init.bits_per_sample = 16;
  932.   init.bsize =           AUDIO_IGNORE;
  933.  
  934.   if ( ( rc = ioctl ( devAudio, AUDIO_INIT, & init ) ) < 0 )
  935.   {
  936.     fprintf ( stderr, "AIX_Audio_Init: AUDIO_INIT failed, errno = %d\n",
  937.               errno );
  938.   }
  939.  
  940.  
  941.   memset ( & control, '\0', sizeof ( control ) );
  942.   memset ( & change, '\0', sizeof ( change ) );
  943.  
  944.   aix_audio_ports = EXTERNAL_SPEAKER | INTERNAL_SPEAKER | OUTPUT_1;
  945.   aix_audio_ports = OUTPUT_1;
  946.  
  947.   change.balance       = 0x3fff0000;
  948.   change.balance_delay = 0;
  949.  
  950.   change.volume        = ( long ) ( 0x7fff << 16 );
  951.   change.volume_delay  = 0;
  952.  
  953.   change.input         = AUDIO_IGNORE;
  954.   change.output        = aix_audio_ports;
  955.   change.monitor       = AUDIO_IGNORE;
  956.   change.dev_info      = ( char * ) NULL;
  957.  
  958.   control.ioctl_request = AUDIO_CHANGE;
  959.   control.position =      0;
  960.   control.request_info =  ( char * ) & change;
  961.  
  962.   if ( ( rc = ioctl ( devAudio, AUDIO_CONTROL, & control ) ) < 0 )
  963.   {
  964.     fprintf ( stderr, "AIX_Audio_Init: AUDIO_CONTROL failed, errno = %d\n",
  965.               errno );
  966.   }
  967.  
  968.   xa_interval_id = 0;
  969.   xa_audio_present = XA_AUDIO_OK;
  970.   Init_Audio_Ring ( xa_audio_ring_size,
  971.                     ( XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps ) );
  972. }
  973.  
  974.  
  975. /*----------------------------------------------------------------------------*/
  976. /*                                                                            */
  977. /*----------------------------------------------------------------------------*/
  978. void AIX_Audio_Kill ( )
  979. {
  980.   AIX_Audio_Off ( 0 );
  981.   xa_audio_present = XA_AUDIO_UNK;
  982.   close ( devAudio );
  983.   Kill_Audio_Ring ( );
  984. }
  985.  
  986.  
  987. /*----------------------------------------------------------------------------*/
  988. /*                                                                            */
  989. /*----------------------------------------------------------------------------*/
  990. void AIX_Audio_Off ( )
  991. {
  992.   audio_control control;
  993.   int           rc;
  994.  
  995.   if ( xa_audio_status != XA_AUDIO_STARTED )
  996.   {
  997.     return;
  998.   }
  999.  
  1000.   xa_audio_status = XA_AUDIO_STOPPED;
  1001.  
  1002.   memset ( & control, '\0', sizeof ( control ) );
  1003.  
  1004.   control.ioctl_request = AUDIO_STOP;
  1005.   control.request_info  = NULL;
  1006.   control.position      = 0;
  1007.  
  1008.   if ( ( rc = ioctl ( devAudio, AUDIO_CONTROL, & control ) ) < 0 )
  1009.   {
  1010.     fprintf ( stderr, "AIX_Audio_Off: AUDIO_STOP failed, errno = %d\n", errno );
  1011.   }
  1012.  
  1013. #ifdef SOME_DAY
  1014.   if ( ( rc = ioctl ( devAudio, AUDIO_WAIT, NULL ) ) != 0 )
  1015.   {
  1016.     fprintf ( stderr, "AIX_Audio_Off: AUDIO_WAIT failed, errno = %d\n", errno );
  1017.   }
  1018. #endif
  1019.  
  1020.   xa_time_audio = -1;
  1021.   xa_audio_flushed = 0;
  1022. }
  1023.  
  1024.  
  1025. /*----------------------------------------------------------------------------*/
  1026. /*                                                                            */
  1027. /*----------------------------------------------------------------------------*/
  1028. void AIX_Audio_On ( )
  1029. {
  1030.   audio_control control;
  1031.   int           rc;
  1032.  
  1033.   if ( xa_audio_status == XA_AUDIO_STARTED )
  1034.   {
  1035.     return;
  1036.   }
  1037.  
  1038.   if ( xa_audio_present != XA_AUDIO_OK )
  1039.   {
  1040.     return;
  1041.   }
  1042.  
  1043.   if ( xa_snd_cur )
  1044.   {
  1045.     /* Change the frequency if needed */
  1046.     if ( xa_audio_hard_freq != xa_snd_cur->hfreq )
  1047.     {
  1048.       audio_init init;
  1049.  
  1050.       printf ( "AIX_Audio_On: setting frequency to %d\n", xa_snd_cur->hfreq );
  1051.  
  1052.       memset ( & init, '\0', sizeof ( init ) );
  1053.  
  1054.       init.srate           = xa_snd_cur->hfreq;
  1055.       init.mode            = PCM;
  1056.       init.operation       = PLAY;
  1057.       init.channels        = 1;
  1058.       init.flags           = BIG_ENDIAN | TWOS_COMPLEMENT;
  1059.       init.bits_per_sample = 16;
  1060.       init.bsize           = AUDIO_IGNORE;
  1061.  
  1062.       if ( ( rc = ioctl ( devAudio, AUDIO_INIT, & init ) ) < 0 )
  1063.       {
  1064.         fprintf ( stderr,
  1065.                   "AIX_Audio_On: AUDIO_INIT failed, rate = %d, errno = %d\n",
  1066.                   init.srate, errno );
  1067.       }
  1068.  
  1069.       xa_audio_hard_freq = xa_snd_cur->hfreq;
  1070.     }
  1071.  
  1072.     /* OLD xa_out_time = xa_snd_cur->ch_time * 4; */
  1073.     xa_out_time = 250;  /* keep audio fed 250ms ahead of video - may be 500*/
  1074.     xa_out_init = xa_audio_ring_size - 1;
  1075.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  1076.  
  1077.     xa_audio_status = XA_AUDIO_STARTED;
  1078.     XA_Flush_Ring();
  1079.     XA_Update_Ring(1000);
  1080.     if ( xa_interval_time == 0 )
  1081.     {
  1082.       xa_interval_time = 1;
  1083.     }
  1084.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  1085.  
  1086.     /* POD: The following 8 lines need to be before Merged_Audio_Output now */
  1087.     memset ( & control, '\0', sizeof ( control ) );
  1088.     control.ioctl_request = AUDIO_START;
  1089.     control.request_info  = NULL;
  1090.     control.position      = 0;
  1091.     if ( ( rc = ioctl ( devAudio, AUDIO_CONTROL, & control ) ) < 0 )
  1092.     {
  1093.       fprintf(stderr,"AIX_Audio_On: AUDIO_START failed, errno = %d\n", errno );
  1094.     }
  1095.     New_Merged_Audio_Output();
  1096.   }
  1097.  
  1098. }
  1099.  
  1100.  
  1101. /*----------------------------------------------------------------------------*/
  1102. /*                                                                            */
  1103. /*----------------------------------------------------------------------------*/
  1104. xaULONG AIX_Closest_Freq ( ifreq )
  1105. xaLONG ifreq;
  1106. {
  1107.   static valid [ ] = {  8000,  9600, 11025, 16000, 18900,
  1108.                        22050, 32000, 37800, 44100, 48000, 0 };
  1109.   int  i = 0;
  1110.   xaLONG best = 8000;
  1111.  
  1112.   xa_audio_hard_buff = XA_HARD_BUFF_1K;
  1113.   while ( valid [ i ] )
  1114.   {
  1115.     if ( xaABS(valid[i] - ifreq) < xaABS(best - ifreq) )
  1116.     {
  1117.       best = valid [ i ];
  1118.     }
  1119.     i = i + 1;
  1120.   }
  1121.   return ( best );
  1122. }
  1123.  
  1124.  
  1125. /*----------------------------------------------------------------------------*/
  1126. /*                                                                            */
  1127. /*----------------------------------------------------------------------------*/
  1128. int AIX_Output_Change ( settings )
  1129. xaULONG settings;
  1130. {
  1131.   audio_control control;
  1132.   audio_change  change;
  1133.   int           rc;
  1134.  
  1135.   memset ( & control, '\0', sizeof ( control ) );
  1136.   memset ( & change, '\0', sizeof ( change ) );
  1137.  
  1138.   change.balance       = 0x3fff0000;
  1139.   change.balance_delay = 0;
  1140.  
  1141.   change.volume        = AUDIO_IGNORE;
  1142.   change.volume_delay  = AUDIO_IGNORE;
  1143.  
  1144.   change.input         = AUDIO_IGNORE;
  1145.   change.output        = settings;
  1146.   change.monitor       = AUDIO_IGNORE;
  1147.   change.dev_info      = ( char * ) NULL;
  1148.  
  1149.   control.ioctl_request = AUDIO_CHANGE;
  1150.   control.position      = 0;
  1151.   control.request_info  = ( char * ) & change;
  1152.  
  1153.   if ( ( rc = ioctl ( devAudio, AUDIO_CONTROL, & control ) ) < 0 )
  1154.   {
  1155.     fprintf ( stderr, "AIX_Output_Change: AUDIO_CONTROL failed, errno = %d\n",
  1156.               errno );
  1157.   }
  1158.   return ( rc );
  1159. }
  1160.  
  1161.  
  1162. /*----------------------------------------------------------------------------*/
  1163. /*                                                                            */
  1164. /*----------------------------------------------------------------------------*/
  1165. void AIX_Speaker_Tog ( flag )
  1166. xaULONG flag;
  1167. {
  1168.   int  rc;
  1169.  
  1170.   switch ( flag )
  1171.   {
  1172.     case 0:
  1173.          aix_audio_ports &= ~INTERNAL_SPEAKER;
  1174.          break;
  1175.  
  1176.     case 1:
  1177.          aix_audio_ports |= INTERNAL_SPEAKER;
  1178.          break;
  1179.  
  1180.     default:
  1181.          aix_audio_ports ^= INTERNAL_SPEAKER;
  1182.          break;
  1183.   }
  1184.  
  1185.   if ( ( rc = AIX_Output_Change ( aix_audio_ports ) ) < 0 )
  1186.   {
  1187.     fprintf ( stderr, 
  1188.     "AIX_Speaker_Tog: AUDIO_CONTROL failed, errno = %d\n", errno );
  1189.   }
  1190. }
  1191.  
  1192.  
  1193. /*----------------------------------------------------------------------------*/
  1194. /*                                                                            */
  1195. /*----------------------------------------------------------------------------*/
  1196. void AIX_Headphone_Tog ( flag )
  1197. xaULONG flag;
  1198. {
  1199.   int  rc;
  1200.  
  1201.   switch ( flag )
  1202.   {
  1203.     case 0:
  1204.          aix_audio_ports &= ~EXTERNAL_SPEAKER;
  1205.          break;
  1206.  
  1207.     case 1:
  1208.          aix_audio_ports |= EXTERNAL_SPEAKER;
  1209.          break;
  1210.  
  1211.     default:
  1212.          aix_audio_ports ^= EXTERNAL_SPEAKER;
  1213.          break;
  1214.   }
  1215.  
  1216.   if ( ( rc = AIX_Output_Change ( aix_audio_ports ) ) < 0 )
  1217.   {
  1218.     fprintf(stderr,
  1219.       "AIX_Headphone_Tog: AUDIO_CONTROL failed, errno = %d\n",errno);
  1220.   }
  1221. }
  1222.  
  1223.  
  1224. /*----------------------------------------------------------------------------*/
  1225. /*                                                                            */
  1226. /*----------------------------------------------------------------------------*/
  1227. void AIX_LineOut_Tog ( flag )
  1228. xaULONG flag;
  1229. {
  1230.   int  rc;
  1231.  
  1232.   switch ( flag )
  1233.   {
  1234.     case 0:
  1235.          aix_audio_ports &= ~OUTPUT_1;
  1236.          break;
  1237.  
  1238.     case 1:
  1239.          aix_audio_ports |= OUTPUT_1;
  1240.          break;
  1241.  
  1242.     default:
  1243.          aix_audio_ports ^= OUTPUT_1;
  1244.          break;
  1245.   }
  1246.  
  1247.   if ( ( rc = AIX_Output_Change ( aix_audio_ports ) ) < 0 )
  1248.   {
  1249.     fprintf ( stderr, "AIX_LineOut_Tog: AUDIO_CONTROL failed, errno = %d\n",
  1250.               errno );
  1251.   }
  1252. }
  1253.  
  1254. /*----------------------------------------------------------------------------*/
  1255. /*                                                                            */
  1256. /*----------------------------------------------------------------------------*/
  1257. void AIX_Adjust_Volume ( volume )
  1258. xaULONG volume;
  1259. {
  1260.   audio_control control;
  1261.   audio_change  change;
  1262.   float         percent;
  1263.   long          new_val;
  1264.   int           rc;
  1265.   float         base_vol = 0x7fff;
  1266.  
  1267.   memset ( & control, '\0', sizeof ( control ) );
  1268.   memset ( & change, '\0', sizeof ( change ) );
  1269.  
  1270.   if ( volume > XA_AUDIO_MAXVOL )
  1271.   {
  1272.     volume = XA_AUDIO_MAXVOL;
  1273.   }
  1274.  
  1275.   if ( volume < XA_AUDIO_MINVOL )
  1276.   {
  1277.     volume = XA_AUDIO_MINVOL;
  1278.   }
  1279.  
  1280.   percent = ( double ) volume / XA_AUDIO_MAXVOL;
  1281.   new_val = base_vol * percent;
  1282.   new_val = new_val << 16;
  1283.  
  1284.   change.balance       = AUDIO_IGNORE;
  1285.   change.balance_delay = AUDIO_IGNORE;
  1286.  
  1287.   change.volume        = new_val;
  1288.   change.volume_delay  = 0;
  1289.  
  1290.   change.input         = AUDIO_IGNORE;
  1291.   change.output        = AUDIO_IGNORE;
  1292.   change.monitor       = AUDIO_IGNORE;
  1293.   change.dev_info      = ( char * ) NULL;
  1294.  
  1295.   control.ioctl_request = AUDIO_CHANGE;
  1296.   control.position =      0;
  1297.   control.request_info =  ( char * ) & change;
  1298.  
  1299.   if ( ( rc = ioctl ( devAudio, AUDIO_CONTROL, & control ) ) < 0 )
  1300.   {
  1301.     fprintf ( stderr, "AIX_Audio_Init: AUDIO_CONTROL failed, errno = %d\n",
  1302.               errno );
  1303.   }
  1304.  
  1305. }
  1306. #endif
  1307.  
  1308. /****************************************************************************/
  1309. /**************** S/6000  SPECIFIC ROUTINES *********************************/
  1310. /****************************************************************************/
  1311.  
  1312.  
  1313.  
  1314. /****************************************************************************/
  1315. /**************** NEC EWS SPECIFIC ROUTINES *********************************/
  1316. /****************************************************************************/
  1317. #ifdef XA_EWS_AUDIO
  1318.  
  1319. /*
  1320.  * EWS port provided by Bob Phillips,
  1321.  *    bobp@syl.nj.nec.com
  1322.  * Heavily stolen from the Sparc port
  1323.  * Friday October 26, 1994
  1324.  */
  1325.  
  1326. xaULONG ews_audio_ports = AUOUT_SP;
  1327.  
  1328. void  EWS_Audio_Init();
  1329. void  EWS_Audio_Kill();
  1330. void  EWS_Audio_Off();
  1331. void  EWS_Audio_On();
  1332. void  EWS_Adjust_Volume();
  1333. xaULONG EWS_Closest_Freq();
  1334. void EWS_Speaker_Toggle();
  1335. void EWS_Headphone_Toggle();
  1336.  
  1337. /* EWS audio output volume is controlled with attenuation, not gain.
  1338.  * The upshot is that the control values run from 62 to 0, with low
  1339.  * numbers representing louder volumes.
  1340.  */
  1341.  
  1342. static int devAudio;
  1343. static struct AU_Volume audio_vol;
  1344. static struct AU_Type audio_type;
  1345. static struct AU_Line audio_line;
  1346. static struct AU_Status audio_status;
  1347.  
  1348.  
  1349. /********** XA_Audio_Setup **********************
  1350.  * 
  1351.  * Also defines NEC Specific variables.
  1352.  *
  1353.  *****/
  1354. void XA_Audio_Setup()
  1355. {
  1356.   XA_Audio_Init        = EWS_Audio_Init;
  1357.   XA_Audio_Kill        = EWS_Audio_Kill;
  1358.   XA_Audio_Off        = EWS_Audio_Off;
  1359.   XA_Audio_On        = EWS_Audio_On;
  1360.   XA_Closest_Freq    = EWS_Closest_Freq;
  1361.   XA_Set_Output_Port    = (void *)(0);
  1362.   XA_Speaker_Tog    = EWS_Speaker_Toggle;
  1363.   XA_Headphone_Tog    = EWS_Headphone_Toggle;
  1364.   XA_LineOut_Tog    = EWS_Headphone_Toggle;
  1365.   XA_Adjust_Volume    = EWS_Adjust_Volume;
  1366.  
  1367.  
  1368.   xa_snd_cur = 0;
  1369.   xa_audio_present = XA_AUDIO_UNK;
  1370.   xa_audio_status  = XA_AUDIO_STOPPED;
  1371.   xa_audio_ring_size  = 8;
  1372. }
  1373.  
  1374.  
  1375. /********** EWS_Audio_Init **********************
  1376.  * Open /dev/audio/audio on EWS.
  1377.  *
  1378.  *****/
  1379. void EWS_Audio_Init()
  1380. { int ret;
  1381.   int type;
  1382.  
  1383.  
  1384.   DEBUG_LEVEL2 fprintf(stderr,"EWS_Audio_Init\n");
  1385. /* The NEC EWS audio driver is very similar to the Sparc, but it does
  1386.  * not use an audio control device.  All ioctls are made directly to
  1387.  * the audio device.  Also, it does not support a wide variety of
  1388.  * ioctls.  In fact, it only supports 
  1389.  * AUIOC_[SG]ETTYPE, AUIOC_[SG]ETLINE, AUIOC_[SG]ETVOLUME, and AUIOC_STATUS.
  1390.  * It doesn't support FLUSH, or any of the other funky Sparc ioctls
  1391.  */
  1392.   if (xa_audio_present != XA_AUDIO_UNK) return;
  1393.   devAudio = open("/dev/audio/audio", O_WRONLY | O_NDELAY);
  1394.   if (devAudio == -1)
  1395.   {
  1396.     if (errno == EBUSY) fprintf(stderr,"Audio_Init: Audio device is busy. - ");
  1397.     else fprintf(stderr,"Audio_Init: Error opening audio device. - ");
  1398.     fprintf(stderr,"Will continue without audio\n");
  1399.     xa_audio_present = XA_AUDIO_ERR;
  1400.     return;
  1401.   }
  1402.   DEBUG_LEVEL1 fprintf(stderr,"NEC EWS AUDIO\n");
  1403.     xa_audio_hard_type  = XA_AUDIO_SIGNED_2MB;
  1404.     xa_audio_hard_freq  = AURATE11_0;
  1405.     xa_audio_hard_bps   = 2;
  1406.     xa_audio_hard_chans = 1;
  1407.     xa_audio_hard_buff  = XA_HARD_BUFF_1K;             /* default buffer size */
  1408.  
  1409.     audio_type.rate=AURATE11_0;
  1410.     audio_type.bit_type=AU_PCM16;
  1411.     audio_type.channel=AU_MONO;
  1412.     ret = ioctl(devAudio, AUIOC_SETTYPE, &audio_type);
  1413.     if (ret)
  1414.     {
  1415.       fprintf(stderr,"EWS: AUIOC_SETTYPE error %d\n",errno);
  1416.       xa_audio_present = XA_AUDIO_ERR;
  1417.       return;
  1418.     }
  1419.  
  1420.   xa_interval_id = 0;
  1421.   xa_audio_present = XA_AUDIO_OK;
  1422.   DEBUG_LEVEL2 fprintf(stderr,"   success \n");
  1423.   Init_Audio_Ring(xa_audio_ring_size,
  1424.             (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps) );
  1425. }
  1426.  
  1427. /********** EWS_Audio_Kill **********************
  1428.  * Close /dev/audio/audio
  1429.  *
  1430.  *****/
  1431. void EWS_Audio_Kill()
  1432. { 
  1433.   /* TURN AUDIO OFF */
  1434.   EWS_Audio_Off(0);
  1435.   xa_audio_present = XA_AUDIO_UNK;
  1436.   /* SHUT THINGS DOWN  */
  1437.   close(devAudio);
  1438.   Kill_Audio_Ring();
  1439. }
  1440.  
  1441. /********** EWS_Audio_Off **********************
  1442.  * Stop Audio Stream
  1443.  *
  1444.  *****/
  1445. void EWS_Audio_Off(flag)
  1446. xaULONG flag;
  1447. { long ret;
  1448.  
  1449.   DEBUG_LEVEL1 fprintf(stderr,"EWS_Audio_Off\n");
  1450.   if (xa_audio_status != XA_AUDIO_STARTED) return;
  1451.  
  1452.   /* SET FLAG TO TELL FREE RUNNING OUTPUT ROUTINE */
  1453.   xa_audio_status = XA_AUDIO_STOPPED;
  1454.  
  1455.   /* The Sparc port flushes here.  We cannot. So, just nuke volume.
  1456.    */
  1457.   /* TURN OFF SOUND ??? */
  1458.   EWS_Adjust_Volume(XA_AUDIO_MINVOL);
  1459.  
  1460.  
  1461.   xa_time_audio = -1;
  1462.   xa_audio_flushed = 0;
  1463.  
  1464. }
  1465.  
  1466. /********** EWS_Audio_On **********************
  1467.  * Turn On Audio Stream.
  1468.  *
  1469.  *****/
  1470. void EWS_Audio_On()
  1471. { 
  1472.   DEBUG_LEVEL2 
  1473.     fprintf(stderr,"EWS_Audio_On \n");
  1474.   if (xa_audio_status == XA_AUDIO_STARTED) return;
  1475.   else if (xa_audio_present != XA_AUDIO_OK) return;
  1476.   else if (xa_snd_cur)
  1477.   { int ret;
  1478.  
  1479.     /* CHANGE FREQUENCY IF NEEDED */
  1480.     if (xa_audio_hard_freq != xa_snd_cur->hfreq)
  1481.     { 
  1482.       
  1483.       ret = ioctl(devAudio, AUIOC_GETTYPE, &audio_type);
  1484.       if (ret == -1) fprintf(stderr,"AUIOC_GETTYPE: errno %d\n",errno);
  1485.       audio_type.rate=EWS_Closest_Freq(xa_snd_cur->hfreq);
  1486.       ret = ioctl(devAudio, AUIOC_SETTYPE, &audio_type);
  1487.       if (ret == -1) fprintf(stderr,"AUIOC_SETTYPE: freq %x errno %d\n",
  1488.                         xa_snd_cur->hfreq, errno);
  1489.       xa_audio_hard_freq = xa_snd_cur->hfreq;
  1490.     }
  1491.     if (XAAUD->mute != xaTRUE) EWS_Adjust_Volume(XAAUD->volume);
  1492.  
  1493.     /* xa_snd_cur gets changes in Update_Ring() */
  1494.     xa_out_time = 250; /* keep audio fed 250ms ahead of video */
  1495.     xa_out_init = xa_audio_ring_size - 1;
  1496.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  1497.  
  1498.     xa_audio_status = XA_AUDIO_STARTED;
  1499.     XA_Flush_Ring();
  1500.     XA_Update_Ring(1000);
  1501.  
  1502.     if (xa_interval_time == 0) xa_interval_time = 1;
  1503.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  1504.     New_Merged_Audio_Output();
  1505.   }
  1506. }
  1507.  
  1508.  
  1509. /********** EWS_Closest_Freq **********************************************
  1510.  *
  1511.  * Global Variable Affect:
  1512.  *   xaULONG xa_audio_hard_buff        must set but not larger than
  1513.  *                    XA_AUDIO_MAX_RING_BUF size
  1514.  ****************************************************************************/
  1515. xaULONG EWS_Closest_Freq(ifreq)
  1516. xaLONG ifreq;
  1517. {
  1518.   static int valid[] = { AURATE5_5, AURATE6_6, AURATE8_0,
  1519.     AURATE9_6, AURATE11_0, AURATE16_0, AURATE18_9, AURATE22_1,
  1520.     AURATE27_4, AURATE32_0, AURATE33_1, AURATE37_8, AURATE44_1,
  1521.     AURATE48_0,0};
  1522.   xaLONG i = 0;
  1523.   xaLONG best = 8000;
  1524.  
  1525.   xa_audio_hard_buff = XA_HARD_BUFF_1K;
  1526.   while(valid[i])
  1527.   { 
  1528.     if (xaABS(valid[i] - ifreq) < xaABS(best - ifreq)) best = valid[i];
  1529.     i++;
  1530.   }
  1531.   if (valid[i])
  1532.   {
  1533.     if (best >= 25000) xa_audio_hard_buff = XA_HARD_BUFF_2K;
  1534.     return(best);
  1535.   }
  1536.   else return(AURATE8_0);
  1537. }
  1538.  
  1539. /************* EWS_Speaker_Toggle *****************************************
  1540.  *
  1541.  * flag = 0  turn speaker off
  1542.  * flag = 1  turn speaker on
  1543.  * flag = 2  toggle speaker
  1544.  ****************************************************************************/
  1545. void EWS_Speaker_Toggle(flag)
  1546. xaULONG flag;
  1547. { 
  1548.   xaULONG old_ports = ews_audio_ports;
  1549.   xaLONG ret;
  1550.  
  1551.   switch(flag)
  1552.   {
  1553.     case  0: ews_audio_ports &= ~AUOUT_SP; break;
  1554.     case  1: ews_audio_ports |=  AUOUT_SP; break;
  1555.     default: ews_audio_ports ^=  AUOUT_SP; break;
  1556.   }
  1557.   audio_line.outline = ews_audio_ports;
  1558.   ret = ioctl(devAudio, AUIOC_SETLINE, &audio_line);
  1559.   if (ret == -1)
  1560.   {
  1561.     fprintf(stderr,"Audio: couldn't toggle speaker %d\n",errno);
  1562.     ews_audio_ports = old_ports;
  1563.   }
  1564. }
  1565.  
  1566. /************* EWS_Headphone_Toggle *****************************************
  1567.  *
  1568.  * flag = 0  turn headphones off
  1569.  * flag = 1  turn headphones on
  1570.  * flag = 2  toggle headphones
  1571.  ****************************************************************************/
  1572. void EWS_Headphone_Toggle(flag)
  1573. xaULONG flag;
  1574. { 
  1575.   xaULONG old_ports = ews_audio_ports;
  1576.   xaLONG ret;
  1577.   switch(flag)
  1578.   {
  1579.     case  0: ews_audio_ports &= ~AUOUT_PHONE; break;
  1580.     case  1: ews_audio_ports |=  AUOUT_PHONE; break;
  1581.     default: ews_audio_ports ^=  AUOUT_PHONE; break;
  1582.   }
  1583.   audio_line.outline = ews_audio_ports;
  1584.   ret = ioctl(devAudio, AUIOC_SETLINE, &audio_line);
  1585.   if (ret == -1)
  1586.   {
  1587.     fprintf(stderr,"Audio: couldn't toggle headphone %d\n",errno);
  1588.     ews_audio_ports = old_ports;
  1589.   }
  1590. }
  1591.  
  1592.  
  1593. /********** EWS_Adjust_Volume **********************
  1594.  * Routine for Adjusting Volume on EWS
  1595.  *
  1596.  * Volume is in the range [0,XA_AUDIO_MAXVOL]
  1597.  * EWS Output is a measure of attenuation, so it ranges from [62,0]
  1598.  ****************************************************************************/
  1599. void EWS_Adjust_Volume(volume)
  1600. xaULONG volume;
  1601. { 
  1602.   int vol;
  1603.   int ret;
  1604.   
  1605.   ret = ioctl(devAudio, AUIOC_GETVOLUME, &audio_vol);
  1606.   if (ret == -1)
  1607.   {
  1608.     fprintf(stderr,"Audio: couldn't get volume%d\n",errno);
  1609.     return;
  1610.   }
  1611.  
  1612.   vol= AUOUT_ATTEMAX-((volume*AUOUT_ATTEMAX)/XA_AUDIO_MAXVOL);
  1613.   audio_vol.out.left = audio_vol.out.right = vol;
  1614.   ret = ioctl(devAudio, AUIOC_SETVOLUME, &audio_vol);
  1615.   if (ret == -1)
  1616.   {
  1617.     fprintf(stderr,"Audio: couldn't set volume%d\n",errno);
  1618.   }
  1619.  
  1620. }
  1621.  
  1622. #endif
  1623. /****************************************************************************/
  1624. /******************* END OF NEC EWS SPECIFIC ROUTINES ***********************/
  1625. /****************************************************************************/
  1626.  
  1627. /****************************************************************************/
  1628. /**************** SONY SPECIFIC ROUTINES ***********************************/
  1629. /****************************************************************************/
  1630. #ifdef    XA_SONY_AUDIO
  1631. /*
  1632.  * SONY NEWS port provided by Kazushi Yoshida,
  1633.  *    30eem043@keyaki.cc.u-tokai.ac.jp
  1634.  * Heavily stolen from the Sparc port
  1635.  * Thu Jan 26, 1995
  1636.  *
  1637.  * SVR4/NEWS-OS 6.x port by Takashi Hagiwara, Sony Corporation
  1638.  * Add SB device check routine and some fixes
  1639.  *      hagiwara@sm.sony.co.jp
  1640.  */
  1641. void Sony_Audio_Init();
  1642. void Sony_Audio_Kill();
  1643. void Sony_Audio_Off();
  1644. void Sony_Audio_On();
  1645. void Sony_Adjust_Volume();
  1646. xaULONG Sony_Closest_Freq();
  1647. void Sony_Speaker_Toggle();
  1648. void Sony_Headphone_Toggle();
  1649.  
  1650. /*
  1651.  */
  1652. static int sony_audio_rate1[] =  /* NWS-5000,4000 */
  1653.     { RATE8000, RATE9450, RATE11025, RATE12000, RATE16000,
  1654.       RATE18900, RATE22050, RATE24000, RATE32000, RATE37800,
  1655.       RATE44056, RATE44100, RATE48000, 0 } ;
  1656.  
  1657. static int sony_audio_rate2[] =  /* NWS-3200, 3400, 3700, 3800 */
  1658.     { RATE8000, RATE9450, RATE18900, RATE37800, 0 } ;
  1659.  
  1660. static int sony_audio_rate3[] =  /* NWS-3100 */
  1661.     { RATE8000, 0 } ;
  1662.  
  1663. int sony_audio_buf_len ;
  1664. static int devAudio;
  1665. static struct sbparam    audio_info ;
  1666. static int *sony_audio_rate;
  1667. static int sony_max_vol, sony_min_vol;
  1668.  
  1669.  
  1670. /********** XA_Audio_Setup **********************
  1671. *
  1672. * Also defines Sony Specific variables.
  1673. *
  1674. *****/
  1675. void XA_Audio_Setup()
  1676. {
  1677.     XA_Audio_Init        = Sony_Audio_Init;
  1678.     XA_Audio_Kill        = Sony_Audio_Kill;
  1679.     XA_Audio_Off        = Sony_Audio_Off;
  1680.     XA_Audio_On        = Sony_Audio_On;
  1681.     XA_Closest_Freq        = Sony_Closest_Freq;
  1682.     XA_Set_Output_Port    = (void *)(0);
  1683.     XA_Speaker_Tog        = Sony_Speaker_Toggle;
  1684.     XA_Headphone_Tog    = Sony_Headphone_Toggle;
  1685.     XA_LineOut_Tog        = Sony_Headphone_Toggle;
  1686.     XA_Adjust_Volume    = Sony_Adjust_Volume;
  1687.  
  1688.  
  1689.     xa_snd_cur = 0;
  1690.     xa_audio_present = XA_AUDIO_UNK;
  1691.     xa_audio_status  = XA_AUDIO_STOPPED;
  1692.     xa_audio_ring_size  = 8;
  1693. }
  1694.  
  1695. /********** Sony_Audio_Init **********************
  1696. * Open /dev/sb.
  1697. *
  1698. *****/
  1699. void Sony_Audio_Init()
  1700. {
  1701.     int    ret;
  1702.     int    type;
  1703.     int     sbtype;
  1704.  
  1705.     DEBUG_LEVEL2 fprintf(stderr,"Sony_Audio_Init\n");
  1706.  
  1707.     if (xa_audio_present != XA_AUDIO_UNK) 
  1708.         return;
  1709.     devAudio = open("/dev/sb0", O_WRONLY | O_NDELAY);
  1710.     if (devAudio == -1) {
  1711.       if (errno == EBUSY) 
  1712.         fprintf(stderr,"Audio_Init: Audio device is busy. - ");
  1713.       else 
  1714.         fprintf(stderr,"Audio_Init: Error opening audio device. - ");
  1715.       fprintf(stderr,"Will continue without audio\n");
  1716.       xa_audio_present = XA_AUDIO_ERR;
  1717.       return;
  1718.     }
  1719.  
  1720.     /* Under NEWS-OS 6.x SBIOCGETTYPE is supported by all machines. */
  1721.     /* However, NEWS-OS 4.x SBIOCGETYPE is supported by only NEWS 5000 */
  1722.     /* We should guess if SBUICGETTYPE would generate error,  */
  1723.     /* that machine  would be NEWS-3xxxx */ 
  1724.  
  1725.     if (ioctl(devAudio, SBIOCGETTYPE, (char *)&sbtype) < 0) {
  1726. #ifdef SVR4
  1727.         fprintf(stderr,"CANNOT GET SBTYPE ERROR %d\n",errno);
  1728. #endif 
  1729.         sbtype = SBTYPE_AIF2;    /* I guess so */    
  1730.     }
  1731.     switch(sbtype) {
  1732.         case SBTYPE_AIF2:
  1733.         case SBTYPE_AIF2_L:
  1734.         case SBTYPE_AIF2_E:
  1735.             sony_max_vol = 0;
  1736.             sony_min_vol = -32;
  1737.             sony_audio_rate = &sony_audio_rate2[0];
  1738.             break;
  1739.         case SBTYPE_AIF3:
  1740.             sony_max_vol = 8;
  1741.             sony_min_vol = -8;
  1742.             sony_audio_rate = &sony_audio_rate3[0];
  1743.             break;
  1744.         case SBTYPE_AIF5:
  1745.         case SBTYPE_AD1848:
  1746.         default:
  1747.             sony_max_vol = 16;
  1748.             sony_min_vol = -16;
  1749.             sony_audio_rate = &sony_audio_rate1[0];
  1750.             break;
  1751.     }
  1752.  
  1753.     DEBUG_LEVEL1 fprintf(stderr,"SONY AMD AUDIO\n");
  1754.  
  1755.     xa_audio_hard_type  = XA_AUDIO_SUN_AU;
  1756.     xa_audio_hard_freq  = 8000;
  1757.     xa_audio_hard_buff  = 1024;         /* default buffer size */
  1758.     xa_audio_hard_bps   = 1;
  1759.     xa_audio_hard_chans = 1;
  1760.     Gen_Signed_2_Ulaw() ;
  1761.  
  1762.     audio_info.sb_mode    = LOGPCM ;
  1763.     audio_info.sb_format  = 0 ;        /* was BSZ128 */
  1764.     audio_info.sb_compress= MULAW ;
  1765.     audio_info.sb_rate    = RATE8000 ;
  1766.     audio_info.sb_channel = MONO ;
  1767.     audio_info.sb_bitwidth= RES8B ;
  1768.     audio_info.sb_emphasis= 0 ;        /* was EMPH_OFF */
  1769.  
  1770.     ret = ioctl(devAudio, SBIOCSETPARAM, &audio_info);
  1771.     if (ret) {
  1772.         fprintf(stderr,"AUDIO BRI FATAL ERROR %d\n",errno);
  1773.         TheEnd1("SONY AUDIO BRI FATAL ERROR\n");
  1774.     }
  1775.     ret = ioctl(devAudio, SBIOCGETPARAM, &audio_info);
  1776.     if (ret == -1)
  1777.          fprintf(stderr,"Can't get audio_info %d\n",errno);
  1778.     xa_interval_id = 0;
  1779.     xa_audio_present = XA_AUDIO_OK;
  1780.  
  1781.     DEBUG_LEVEL2 fprintf(stderr,"success \n");
  1782.  
  1783.     Init_Audio_Ring(xa_audio_ring_size,
  1784.         (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps) );
  1785.  
  1786.     sony_audio_buf_len = 32 * 1024 ; /* 4 sec... */
  1787. }
  1788.  
  1789.  
  1790. /********** Sony_Audio_Kill **********************
  1791. * Close /dev/sb0.
  1792. *
  1793. *****/
  1794. void Sony_Audio_Kill()
  1795. {
  1796.   DEBUG_LEVEL1 fprintf(stderr,"Sony_Audio_Kill\n");
  1797.   /* TURN AUDIO OFF */
  1798.   Sony_Audio_Off(0);
  1799.   xa_audio_present = XA_AUDIO_UNK;
  1800.   /* SHUT THINGS DOWN  */
  1801.   close(devAudio);
  1802.   Kill_Audio_Ring();
  1803. }
  1804.  
  1805. /********** Sony_Audio_Off **********************
  1806. * Stop Audio Stream
  1807. *
  1808. *****/
  1809. void Sony_Audio_Off(flag)
  1810. xaULONG flag;
  1811. { long ret;
  1812.  
  1813.   DEBUG_LEVEL1 fprintf(stderr,"Sony_Audio_Off\n");
  1814.   if (xa_audio_status != XA_AUDIO_STARTED) return;
  1815.  
  1816.   /* SET FLAG TO TELL FREE RUNNING OUTPUT ROUTINE */
  1817.   xa_audio_status = XA_AUDIO_STOPPED;
  1818.  
  1819.   /* TURN OFF SOUND ??? */ 
  1820.   Sony_Adjust_Volume(XA_AUDIO_MINVOL);
  1821.  
  1822.   /* FLUSH AUDIO DEVICE */
  1823.   ret = ioctl(devAudio, SBIOCFLUSH, 0);
  1824.   if (ret == -1) fprintf(stderr,"Sony Audio: off flush err %d\n",errno);
  1825.  
  1826.   xa_time_audio = -1;
  1827.   xa_audio_flushed = 0;
  1828.  
  1829.   /* OK... Wait for Sound device */
  1830.   ret = ioctl(devAudio, SBIOCWAIT, 0);
  1831.  
  1832.   /* RESTORE ORIGINAL VOLUME */
  1833.   if (XAAUD->mute != xaTRUE) Sony_Adjust_Volume(XAAUD->volume);
  1834. }
  1835.  
  1836. /********** Sony_Audio_On **********************
  1837. * Turn On Audio Stream.
  1838. *
  1839. *****/
  1840. void Sony_Audio_On()
  1841. { int ret ;
  1842.   struct sbparam a_info ;
  1843.  
  1844.   DEBUG_LEVEL1 fprintf(stderr,"SONY AUDIO ON\n");
  1845.  
  1846.   if (xa_audio_status == XA_AUDIO_STARTED) return;
  1847.   else if (xa_audio_present != XA_AUDIO_OK) return;
  1848.   else if (xa_snd_cur)
  1849.   {
  1850.     /* CHANGE FREQUENCY IF NEEDED */
  1851.     if( xa_audio_hard_freq != xa_snd_cur->hfreq )
  1852.     {
  1853.       a_info.sb_mode    = LOGPCM ;
  1854.       a_info.sb_format  = 0 ;
  1855.       a_info.sb_compress= MULAW ;
  1856.       a_info.sb_rate    = xa_snd_cur->hfreq ;
  1857.       a_info.sb_channel = MONO ;
  1858.       a_info.sb_bitwidth= RES8B ;
  1859.       a_info.sb_emphasis= 0 ;
  1860.       ret=ioctl(devAudio, SBIOCSETPARAM, &a_info); 
  1861.       if( ret == -1 )fprintf(stderr,"audio set freq: freq %lf errno %d\n",
  1862.                     xa_snd_cur->hfreq, errno);
  1863.       xa_audio_hard_freq = xa_snd_cur->hfreq;
  1864.     }
  1865.  
  1866.     /* xa_snd_cur gets changes in Update_Ring() */
  1867.     xa_out_time = 250; /* keep audio fed 250ms ahead of video - could be 500*/
  1868.     xa_out_init = xa_audio_ring_size - 1;
  1869.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  1870.  
  1871.     xa_audio_status = XA_AUDIO_STARTED;
  1872.     XA_Flush_Ring();
  1873.     XA_Update_Ring(1000);
  1874.  
  1875.     if (xa_interval_time == 0) xa_interval_time = 1;
  1876.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  1877.     New_Merged_Audio_Output();
  1878.   }
  1879. }
  1880. /********** Sony_Closest_Freq **********************************************
  1881. *
  1882. ****************************************************************************/
  1883. xaULONG Sony_Closest_Freq(ifreq)
  1884. xaLONG    ifreq;
  1885. { xaLONG i = 0 ;
  1886.   xaLONG best = 8000 ;
  1887.  
  1888.   xa_audio_hard_buff = XA_HARD_BUFF_1K;
  1889.   while(sony_audio_rate[i])
  1890.   {
  1891.     if (xaABS(sony_audio_rate[i] - ifreq) < xaABS(best - ifreq)) 
  1892.                 best = sony_audio_rate[i];
  1893.     i++;
  1894.   }
  1895.   return(best);
  1896. }
  1897. /************* Sony_Speaker_Toggle *****************************************
  1898. *
  1899. * flag = 0  turn speaker off
  1900. * flag = 1  turn speaker on
  1901. * flag = 2  toggle speaker
  1902. ****************************************************************************/
  1903. void Sony_Speaker_Toggle(flag)
  1904. xaULONG flag;
  1905. {
  1906.      /* do nothing */return ;
  1907. }
  1908.  
  1909. /************* Sony_Headphone_Toggle *****************************************
  1910. *
  1911. * flag = 0  turn headphones off
  1912. * flag = 1  turn headphones on
  1913. * flag = 2  toggle headphones
  1914. ****************************************************************************/
  1915. void Sony_Headphone_Toggle(flag)
  1916. xaULONG flag ;
  1917. {
  1918.      /* do nothing */return ;
  1919. }
  1920. /********** Sony_Adjust_Volume **********************/
  1921. void Sony_Adjust_Volume(volume)
  1922. xaULONG volume;
  1923. { 
  1924.   struct sblevel     gain;
  1925.   int            mflg;
  1926.   int            o_level;
  1927.   mflg = MUTE_OFF;
  1928.   ioctl(devAudio, SBIOCMUTE, &mflg);
  1929.   o_level = sony_min_vol +
  1930.                  ((volume * (sony_max_vol - sony_min_vol)) / XA_AUDIO_MAXVOL);
  1931.   if (o_level > sony_max_vol)    o_level = sony_max_vol;
  1932.   if (o_level < sony_min_vol)    o_level = sony_min_vol;
  1933.  
  1934.   if (o_level == sony_min_vol) 
  1935.   {
  1936.     mflg = MUTE_ON;
  1937.     ioctl(devAudio, SBIOCMUTE, &mflg);
  1938.   }
  1939.   gain.sb_right = gain.sb_left = (o_level << 16);
  1940.   ioctl(devAudio, SBIOCSETOUTLVL, &gain);
  1941. }
  1942. #endif
  1943. /****************************************************************************/
  1944. /******************* END OF SONY SPECIFIC ROUTINES *********************/
  1945. /****************************************************************************/
  1946.  
  1947.  
  1948. /****************************************************************************/
  1949. /**************** LINUX SPECIFIC ROUTINES *******************************/
  1950. /****************************************************************************/
  1951. #ifdef XA_LINUX_AUDIO
  1952.  
  1953.  
  1954. void Linux_Audio_Init();
  1955. void Linux_Audio_Kill();
  1956. void Linux_Audio_Off();
  1957. void Linux_Audio_On();
  1958. xaULONG Linux_Closest_Freq();
  1959. void Linux_Speaker_Toggle();
  1960. void Linux_Headphone_Toggle();
  1961. void Linux_Adjust_Volume();
  1962. xaULONG Linux_Read_Volume();
  1963.  
  1964. int linux_vol_chan;
  1965.  
  1966. #define LINUX_MAX_VOL (100)
  1967. #define LINUX_MIN_VOL (0)
  1968.  
  1969. int devAudio;
  1970. int devMixer;
  1971.  
  1972. /********** XA_Audio_Setup **********************
  1973.  * Sets up Linux specific Routines
  1974.  *****/
  1975. void XA_Audio_Setup()
  1976. {
  1977.   XA_Audio_Init        = Linux_Audio_Init;
  1978.   XA_Audio_Kill        = Linux_Audio_Kill;
  1979.   XA_Audio_Off        = Linux_Audio_Off;
  1980.   XA_Audio_On        = Linux_Audio_On;
  1981.   XA_Closest_Freq    = Linux_Closest_Freq;
  1982.   XA_Set_Output_Port    = (void *)(0);
  1983.   XA_Speaker_Tog    = Linux_Speaker_Toggle;
  1984.   XA_Headphone_Tog    = Linux_Headphone_Toggle;
  1985.   XA_LineOut_Tog    = Linux_Headphone_Toggle;
  1986.   XA_Adjust_Volume    = Linux_Adjust_Volume;
  1987.  
  1988.   xa_snd_cur = 0;
  1989.   xa_audio_present = XA_AUDIO_UNK;
  1990.   xa_audio_status  = XA_AUDIO_STOPPED;
  1991.   xa_audio_ring_size  = 8;
  1992.   linux_vol_chan = SOUND_MIXER_VOLUME;  /* default */
  1993. }
  1994.  
  1995. /********** Linux_Audio_Init **********************
  1996.  * Init Linux Audio, init variables, open Audio Devices.
  1997.  *****/
  1998. void Linux_Audio_Init()
  1999. { int ret,tmp;
  2000.   DEBUG_LEVEL2 fprintf(stderr,"Linux_Audio_Init\n");
  2001.  
  2002.   if (xa_audio_present != XA_AUDIO_UNK) return;
  2003.  
  2004.   devAudio = open(_FILE_DSP, O_WRONLY | O_NDELAY, 0);
  2005.   if (devAudio == -1)
  2006.   { fprintf(stderr,"Can't Open %s device\n",_FILE_DSP);
  2007.     xa_audio_present = XA_AUDIO_ERR;
  2008.     return;
  2009.   }
  2010.   ioctl(devAudio, SNDCTL_DSP_SYNC, NULL);
  2011.   /* SETUP SAMPLE SIZE */
  2012.   if (xa_kludge900_aud == 900) tmp = 8;  /* POD testing purposes */
  2013.   else tmp = 16;
  2014. #ifdef SNDCTL_DSP_SAMPLESIZE
  2015. #ifdef XA_LINUX_NEWER_SND
  2016.   ret = ioctl(devAudio, SNDCTL_DSP_SAMPLESIZE, &tmp);
  2017. #else
  2018.   ret = ioctl(devAudio, SNDCTL_DSP_SAMPLESIZE, tmp);
  2019. #endif
  2020. #else
  2021.   ret = -1;
  2022. #endif
  2023.   if ((ret == -1) || (tmp == 8)) xa_audio_hard_bps = 1;
  2024.   else xa_audio_hard_bps = 2;
  2025.  
  2026.   /* SETUP Mono/Stereo */
  2027.   tmp = 0;  /* mono(0) stereo(1) */ 
  2028. #ifdef XA_LINUX_NEWER_SND
  2029.   ret = ioctl(devAudio, SNDCTL_DSP_STEREO, &tmp);
  2030. #else
  2031.   ret = ioctl(devAudio, SNDCTL_DSP_STEREO, tmp);
  2032. #endif
  2033.   if (ret == -1) fprintf(stderr,"Linux Audio: Error setting mono\n");
  2034.   xa_audio_hard_chans = 1;
  2035.  
  2036.   xa_audio_hard_freq  = 11025;  /* 22050 and sometimes 44100 */
  2037.   xa_audio_hard_buff  = XA_HARD_BUFF_1K;
  2038.  
  2039. #ifdef SNDCTL_DSP_GETBLKSIZE
  2040. #ifdef XA_LINUX_NEWER_SND
  2041.   ret = ioctl(devAudio, SNDCTL_DSP_GETBLKSIZE, &tmp);
  2042. #else
  2043.   ret = ioctl(devAudio, SNDCTL_DSP_GETBLKSIZE, 0);
  2044. #endif
  2045. #else
  2046.   ret = 0;
  2047. #endif
  2048.   if (ret == -1) fprintf(stderr,"Linux Audio: Error getting buf size\n");
  2049.   /* POD NOTE: should probably do something with this value. :^) */
  2050.   /* Maybe XA_AUDIO_MAX_RING_BUFF should be a variable */
  2051.   
  2052.   ioctl(devAudio, SNDCTL_DSP_SYNC, NULL);
  2053.  
  2054.   devMixer = open(_FILE_MIXER,  O_RDONLY | O_NDELAY, 0);
  2055.   /* Mixer only present on SB Pro's and above */
  2056.   /* if not present then it's set to -1 and ignored later */
  2057.   /* THOUGHT: what about doing mixer ioctl to the /dev/dsp device??? */
  2058.   if (devMixer < 0) devMixer = devAudio;
  2059.    /* determine what volume settings exist */
  2060.   { int devices;
  2061. #ifdef XA_LINUX_NEWER_SND
  2062.     ret = ioctl(devMixer, SOUND_MIXER_READ_DEVMASK, &devices);
  2063.     if (ret == -1) devices = 0;
  2064. #else
  2065.     devices = ioctl(devMixer, SOUND_MIXER_READ_DEVMASK, 0 );
  2066.     if (devices == -1) devices = 0;
  2067. #endif
  2068.     if (devices & (1 << SOUND_MIXER_PCM)) 
  2069.         linux_vol_chan = SOUND_MIXER_PCM;
  2070.     else    linux_vol_chan = SOUND_MIXER_VOLUME;
  2071.   }
  2072.  
  2073. /*
  2074.   XAAUD->volume = Linux_Read_Volume();
  2075. */
  2076.  
  2077.   if (xa_audio_hard_bps == 1) xa_audio_hard_type  = XA_AUDIO_LINEAR_1M;
  2078.   else        xa_audio_hard_type  = XA_AUDIO_SIGNED_2ML;
  2079.  
  2080.   xa_interval_id = 0;
  2081.   xa_audio_present = XA_AUDIO_OK;
  2082.   DEBUG_LEVEL2 fprintf(stderr,"   success \n");
  2083.   Init_Audio_Ring(xa_audio_ring_size,
  2084.             (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps) );
  2085. }
  2086.  
  2087. /********** Linux_Audio_Kill *************************************************
  2088.  * Stop Linux Audio and Close Linux Audio Devices. Free up memory.
  2089.  *
  2090.  *****************************************************************************/
  2091. void Linux_Audio_Kill()
  2092. {
  2093.   Linux_Audio_Off(0);
  2094.   xa_audio_present = XA_AUDIO_UNK;
  2095.   if ( (devMixer != -1) && (devMixer != devAudio)) close(devMixer);
  2096.   close(devAudio);
  2097.   Kill_Audio_Ring();
  2098. }
  2099.  
  2100. /********** Linux_Audio_Off *************************************************
  2101.  * Stop Linux Audio
  2102.  *
  2103.  *****************************************************************************/
  2104. void Linux_Audio_Off(flag)
  2105. xaULONG flag;
  2106. {
  2107.   if (xa_audio_status != XA_AUDIO_STARTED) return;
  2108.   /* SET FLAG TO STOP OUTPUT ROUTINE */
  2109.   xa_audio_status = XA_AUDIO_STOPPED;
  2110.  
  2111.   ioctl(devAudio, SNDCTL_DSP_RESET, NULL);
  2112.  
  2113.   /* Linux_Adjust_Volume(XA_AUDIO_MINVOL); */
  2114.   /* ioctl(devAudio, SNDCTL_DSP_SYNC, NULL); */
  2115.   xa_time_audio = -1;
  2116.   xa_audio_flushed = 0;
  2117.   ioctl(devAudio, SNDCTL_DSP_SYNC, NULL);
  2118.   /* if (XAAUD->mute != xaTRUE) Linux_Adjust_Volume(XAAUD->volume); */
  2119.  
  2120. }
  2121.  
  2122. /********** Linux_Audio_On ***************************************************
  2123.  * Startup Linux Audio
  2124.  *
  2125.  *****************************************************************************/
  2126. void Linux_Audio_On()
  2127. {
  2128.   DEBUG_LEVEL2 fprintf(stderr,"Linux_Audio_On \n");
  2129.   if (xa_audio_status == XA_AUDIO_STARTED) return;
  2130.   else if (xa_snd_cur)
  2131.   { int ret,tmp;
  2132.   
  2133.     if (xa_audio_present != XA_AUDIO_OK) return;
  2134.  
  2135.     Linux_Adjust_Volume(XA_AUDIO_MINVOL);
  2136.     ioctl(devAudio, SNDCTL_DSP_SYNC, NULL);
  2137.  
  2138.     /* CHANGE FREQUENCY */
  2139.     if (xa_audio_hard_freq != xa_snd_cur->hfreq)
  2140.     {
  2141.       tmp = xa_snd_cur->hfreq;
  2142. #ifdef XA_LINUX_NEWER_SND
  2143.       ret = ioctl(devAudio, SNDCTL_DSP_SPEED, &tmp);
  2144. #else
  2145.       tmp = ioctl(devAudio, SNDCTL_DSP_SPEED, tmp);
  2146. #endif
  2147.       if ((ret == -1) || (tmp != xa_snd_cur->hfreq))
  2148.     fprintf(stderr,"Linux_Audio: err setting freq %x\n"
  2149.                         ,xa_snd_cur->hfreq);
  2150.       xa_audio_hard_freq = xa_snd_cur->hfreq;
  2151.     }
  2152.     ioctl(devAudio, SNDCTL_DSP_SYNC, NULL);
  2153.     if (XAAUD->mute != xaTRUE) Linux_Adjust_Volume(XAAUD->volume);
  2154.  
  2155.     /* xa_snd_cur gets changes in Update_Ring() */
  2156.     xa_out_time = 250;  /* keep audio 250 ms ahead of video. could be 500ms */
  2157.     xa_out_init = xa_audio_ring_size - 1;
  2158.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  2159.  
  2160.     xa_audio_status = XA_AUDIO_STARTED;
  2161.     XA_Flush_Ring();
  2162.     XA_Update_Ring(1000);
  2163.  
  2164.     if (xa_interval_time == 0) xa_interval_time = 1;
  2165.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  2166.     New_Merged_Audio_Output();
  2167.   }
  2168. }
  2169.  
  2170. /********** Linux_Closest_Freq **********************************************
  2171.  * Return closest support frequeny and set hard_buff.
  2172.  *
  2173.  *****************************************************************************/
  2174. xaULONG Linux_Closest_Freq(ifreq)
  2175. xaLONG ifreq;    /* incoming frequency */
  2176. { static int valid[] = {11025, 22050, 44100, 0};
  2177.   xaLONG i = 0;
  2178.   xaLONG tmp_freq,ofreq = ifreq;
  2179. #ifdef XA_LINUX_NEWER_SND
  2180.   xaLONG ret;
  2181. #endif
  2182.  
  2183.    /* search up for closest frequency */
  2184.   while(valid[i])
  2185.   {
  2186.     if (xaABS(valid[i] - ifreq) < xaABS(ofreq - ifreq)) ofreq = valid[i];
  2187.     i++;
  2188.   }
  2189.  
  2190.   tmp_freq = ofreq;
  2191. #ifdef XA_LINUX_NEWER_SND
  2192.   ret = ioctl(devAudio, SNDCTL_DSP_SPEED, &tmp_freq);
  2193.   if (ret == -1) tmp_freq = 0;
  2194. #else
  2195.   tmp_freq = ioctl(devAudio, SNDCTL_DSP_SPEED, tmp_freq);
  2196.   if (tmp_freq == -1) tmp_freq = 0;
  2197. #endif
  2198.   if (tmp_freq) ofreq = tmp_freq;
  2199.  
  2200.   if (ofreq >= 25000) xa_audio_hard_buff = XA_HARD_BUFF_2K;
  2201.   else xa_audio_hard_buff = XA_HARD_BUFF_1K;
  2202.   return(ofreq);
  2203. }
  2204.  
  2205. /********** Linux_Speaker_Toggle **********************************************
  2206.  * Turn off/on/toggle Linux's Speaker(if possible)
  2207.  * flag= 0   1   2 
  2208.  *****************************************************************************/
  2209. void Linux_Speaker_Toggle(flag)
  2210. xaULONG flag;
  2211. {
  2212.   return;
  2213. }
  2214.  
  2215. /********** Linux_Headphone_Toggle ********************************************
  2216.  * Turn off/on/toggle Linux's Headphone(if possible)
  2217.  * flag= 0   1   2 
  2218.  *****************************************************************************/
  2219. void Linux_Headphone_Toggle(flag)
  2220. xaULONG flag;
  2221. {
  2222.   return;
  2223. }
  2224.  
  2225. /********** Linux_Adjust_Volume ***********************************************
  2226.  * Routine for Adjusting Volume on Linux
  2227.  *
  2228.  *****************************************************************************/
  2229. void Linux_Adjust_Volume(volume)
  2230. xaULONG volume;
  2231. { xaULONG adj_volume;
  2232.  
  2233.   if (devMixer < 0) return;
  2234.   adj_volume = LINUX_MIN_VOL +
  2235.         ((volume * (LINUX_MAX_VOL - LINUX_MIN_VOL)) / XA_AUDIO_MAXVOL);
  2236.   if (adj_volume > LINUX_MAX_VOL) adj_volume = LINUX_MAX_VOL;
  2237.   adj_volume |= adj_volume << 8;    /* left channel | right channel */
  2238. #ifdef XA_LINUX_NEWER_SND
  2239.   ioctl(devMixer, MIXER_WRITE(linux_vol_chan), &adj_volume);
  2240. #else
  2241.   ioctl(devMixer, MIXER_WRITE(linux_vol_chan), adj_volume);
  2242. #endif
  2243. }
  2244.  
  2245. /********** Linux_Adjust_Volume ***********************************************
  2246.  * Routine for Adjusting Volume on Linux
  2247.  *
  2248.  *****************************************************************************/
  2249. xaULONG Linux_Read_Volume()
  2250. { xaLONG ret,the_volume = 0;
  2251.   if (devMixer < 0) return(0);
  2252. #ifdef XA_LINUX_NEWER_SND
  2253.   ret = ioctl(devMixer, MIXER_READ(linux_vol_chan), &the_volume);
  2254.   if (ret < 0) the_volume = 0;
  2255. #else
  2256.   the_volume = ioctl(devMixer, MIXER_READ(linux_vol_chan), 0);
  2257.   if (the_volume < 0) the_volume = 0;
  2258. #endif
  2259.  
  2260.   the_volume =  (XA_AUDIO_MAXVOL * (the_volume - LINUX_MIN_VOL)) 
  2261.                         / (LINUX_MAX_VOL);
  2262.  
  2263.   fprintf(stderr,"volume = %d %d %d",the_volume,LINUX_MIN_VOL,LINUX_MAX_VOL);
  2264.   return(the_volume);
  2265. }
  2266. #endif
  2267. /****************************************************************************/
  2268. /******************* END OF LINUX SPECIFIC ROUTINES *********************/
  2269. /****************************************************************************/
  2270.  
  2271.  
  2272. /****************************************************************************/
  2273. /**************** SGI SPECIFIC ROUTINES *******************************/
  2274. /****************************************************************************/
  2275. #ifdef XA_SGI_AUDIO
  2276.  
  2277. void SGI_Audio_Init();
  2278. void SGI_Audio_Kill();
  2279. void SGI_Audio_Off();
  2280. void SGI_Audio_On();
  2281. xaULONG SGI_Closest_Freq();
  2282. void SGI_Speaker_Toggle();
  2283. void SGI_Headphone_Toggle();
  2284. void SGI_Adjust_Volume();
  2285.  
  2286. #define SGI_MAX_VOL (255)
  2287. #define SGI_MIN_VOL (0)
  2288.  
  2289. static ALport port;
  2290. static ALconfig conf;
  2291.  
  2292. /********** XA_Audio_Setup **********************
  2293.  * Sets up SGI specific Routines
  2294.  *****/
  2295. void XA_Audio_Setup()
  2296. {
  2297.   XA_Audio_Init        = SGI_Audio_Init;
  2298.   XA_Audio_Kill        = SGI_Audio_Kill;
  2299.   XA_Audio_Off        = SGI_Audio_Off;
  2300.   XA_Audio_On        = SGI_Audio_On;
  2301.   XA_Closest_Freq    = SGI_Closest_Freq;
  2302.   XA_Set_Output_Port    = (void *)(0);
  2303.   XA_Speaker_Tog    = SGI_Speaker_Toggle;
  2304.   XA_Headphone_Tog    = SGI_Headphone_Toggle;
  2305.   XA_LineOut_Tog    = SGI_Headphone_Toggle;
  2306.   XA_Adjust_Volume    = SGI_Adjust_Volume;
  2307.  
  2308.   xa_snd_cur = 0;
  2309.   xa_audio_present = XA_AUDIO_UNK;
  2310.   xa_audio_status  = XA_AUDIO_STOPPED;
  2311.   xa_audio_ring_size  = 8;
  2312. }
  2313.  
  2314. /********** SGI_Audio_Init **********************
  2315.  * Init SGI Audio, init variables, open Audio Devices.
  2316.  *****/
  2317. void SGI_Audio_Init()
  2318. { long sgi_params[4];
  2319.   DEBUG_LEVEL2 fprintf(stderr,"SGI_Audio_Init\n");
  2320.  
  2321.   if (xa_audio_present != XA_AUDIO_UNK) return;
  2322.  
  2323.   conf = ALnewconfig();
  2324.   ALsetwidth(conf, AL_SAMPLE_16);
  2325.   ALsetchannels(conf, AL_MONO);
  2326.   ALsetqueuesize(conf, 16384);
  2327.   port = ALopenport("XAnim Mono", "w", conf);
  2328.   if (port == 0)
  2329.   { fprintf(stderr,"Can't Open SGI Audio device\n");
  2330.     xa_audio_present = XA_AUDIO_ERR;
  2331.     return;
  2332.   }
  2333.  
  2334.   /* get default frequency - no really necessary */
  2335.   sgi_params[0] = AL_OUTPUT_RATE;
  2336.   sgi_params[1] = 11025;
  2337.   ALsetparams(AL_DEFAULT_DEVICE, sgi_params, 2);
  2338.   ALgetparams(AL_DEFAULT_DEVICE, sgi_params, 2);
  2339.   xa_audio_hard_freq = sgi_params[1];
  2340.  
  2341.   xa_audio_hard_bps = 2;
  2342.   xa_audio_hard_chans = 1;
  2343.   xa_audio_hard_buff  = XA_HARD_BUFF_2K;   /* was XA_HARD_BUFF_1K */
  2344.   xa_audio_hard_type  = XA_AUDIO_SIGNED_2MB;
  2345.  
  2346.   xa_interval_id = 0;
  2347.   xa_audio_present = XA_AUDIO_OK;
  2348.   DEBUG_LEVEL2 fprintf(stderr,"   success \n");
  2349.   Init_Audio_Ring(xa_audio_ring_size,
  2350.             (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps) );
  2351. }
  2352. /********** SGI_Audio_Kill **********************
  2353.  * Stop SGI Audio and Close SGI Audio Devices. Free up memory.
  2354.  *****/
  2355. void SGI_Audio_Kill()
  2356. {
  2357.   /* TURN AUDIO OFF */
  2358.   SGI_Audio_Off(0);
  2359.   xa_audio_present = XA_AUDIO_UNK;
  2360.   /* SHUT THINGS DOWN  */
  2361.   ALcloseport(port);
  2362.   ALfreeconfig(conf);
  2363.   Kill_Audio_Ring();
  2364.   return;
  2365. }
  2366.  
  2367. /********** SGI_Audio_Off **********************
  2368.  * Stop SGI Audio
  2369.  *****/
  2370. void SGI_Audio_Off(flag)
  2371. xaULONG flag;
  2372. {
  2373.   DEBUG_LEVEL2 fprintf(stderr,"SGI_Audio_Off\n");
  2374.   if (xa_audio_status != XA_AUDIO_STARTED) return;
  2375.  
  2376.   /* SET FLAG TO STOP OUTPUT ROUTINE */
  2377.   xa_audio_status = XA_AUDIO_STOPPED;
  2378.  
  2379.   /* TURN OFF SOUND ??? */
  2380.   SGI_Adjust_Volume(XA_AUDIO_MINVOL);
  2381.  
  2382.   /* FLUSH DEVICE SHOULD GO HERE */
  2383.   /* POD NOTE: DOES SGI HAVE A FLUSH???? */
  2384.  
  2385.   /* Wait until all samples drained */
  2386.   while(ALgetfilled(port) != 0) sginap(1);
  2387.  
  2388.   xa_time_audio = -1;
  2389.   xa_audio_flushed = 0;
  2390.  
  2391.   /* RESTORE ORIGINAL VOLUME */
  2392.   if (XAAUD->mute != xaTRUE) SGI_Adjust_Volume(XAAUD->volume);
  2393. }
  2394.  
  2395. /********** SGI_Audio_On **********************
  2396.  * Startup SGI Audio
  2397.  *****/
  2398. void SGI_Audio_On()
  2399. {
  2400.   DEBUG_LEVEL2 fprintf(stderr,"SGI_Audio_On \n");
  2401.   if (xa_audio_status == XA_AUDIO_STARTED) return;
  2402.   else if (xa_audio_present != XA_AUDIO_OK) return;
  2403.   else if (xa_snd_cur)
  2404.   { 
  2405.     /* Change Frequency If necessary */
  2406.     if (xa_audio_hard_freq != xa_snd_cur->hfreq)
  2407.     { long sgi_params[2];
  2408.       sgi_params[0] = AL_OUTPUT_RATE;
  2409.       sgi_params[1] = xa_snd_cur->hfreq;
  2410.       ALsetparams(AL_DEFAULT_DEVICE, sgi_params, 2);
  2411.       xa_audio_hard_freq = xa_snd_cur->hfreq;
  2412.     }
  2413.  
  2414.     /* xa_snd_cur gets changes in Update_Ring() */
  2415.     xa_out_time = 500;  /* keep audio fed 500ms ahead of video */
  2416.     xa_out_init = xa_audio_ring_size - 1;
  2417.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  2418.  
  2419.     xa_audio_status = XA_AUDIO_STARTED;
  2420.     XA_Flush_Ring();
  2421.     XA_Update_Ring(1000);
  2422.  
  2423.     if (xa_interval_time == 0) xa_interval_time = 1;
  2424.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  2425.     New_Merged_Audio_Output();
  2426.   }
  2427. }
  2428.  
  2429. /********** SGI_Closest_Freq **********************
  2430.  * Return closest support frequeny and set hard_buff.
  2431.  * The IRIX 4.0.5 audio.h file lists the following frequencies:
  2432.  * {8000,11025,16000,22050,32000,44100,48000}
  2433.  *****/
  2434. xaULONG SGI_Closest_Freq(ifreq)
  2435. xaLONG ifreq;
  2436. { static int valid[] = { 8000,11025,16000,22050,32000,44100,0};
  2437.   xaLONG i = 0;
  2438.   xaLONG ofreq = 8000;
  2439.   long sgi_params[2];
  2440.  
  2441.   while(valid[i])
  2442.   { 
  2443.     if (xaABS(valid[i] - ifreq) < xaABS(ofreq - ifreq)) ofreq = valid[i];
  2444.     i++;
  2445.   }
  2446.   sgi_params[0] = AL_OUTPUT_RATE;
  2447.   sgi_params[1] = ofreq;
  2448.   ALsetparams(AL_DEFAULT_DEVICE, sgi_params, 2); 
  2449.   ALgetparams(AL_DEFAULT_DEVICE, sgi_params, 2); 
  2450.   if (ofreq != sgi_params[1])
  2451.     fprintf(stderr,"SGI AUDIO: freq gotten %d wasn't wanted %d\n",
  2452.         sgi_params[1],ofreq);
  2453.   ofreq = sgi_params[1];
  2454.   xa_audio_hard_buff = XA_HARD_BUFF_2K; /* fixed for SGI */
  2455.   return(ofreq);
  2456. }
  2457.  
  2458.  
  2459. /********** SGI_Speaker_Toggle **********************
  2460.  * Turn off/on/toggle SGI's Speaker(if possible)
  2461.  * flag= 0   1   2 
  2462.  *****/
  2463. void SGI_Speaker_Toggle(flag)
  2464. xaULONG flag;
  2465. {
  2466.   return;
  2467. }
  2468.  
  2469. /********** SGI_Headphone_Toggle **********************
  2470.  * Turn off/on/toggle SGI's Headphone(if possible)
  2471.  * flag= 0   1   2 
  2472.  *****/
  2473. void SGI_Headphone_Toggle(flag)
  2474. xaULONG flag;
  2475. {
  2476.   return;
  2477. }
  2478.  
  2479. /********** SGI_Adjust_Volume **********************
  2480.  * Routine for Adjusting Volume on SGI
  2481.  *
  2482.  *****/
  2483. void SGI_Adjust_Volume(volume)
  2484. xaULONG volume;
  2485. { xaULONG adj_volume;
  2486.   long sgi_params[4];
  2487.   adj_volume =
  2488.       (int)(pow(10.0, (float)volume / XA_AUDIO_MAXVOL * 2.406540183) + 0.5);
  2489.   if (adj_volume > SGI_MAX_VOL) adj_volume = SGI_MAX_VOL;
  2490.   sgi_params[0] = AL_LEFT_SPEAKER_GAIN;
  2491.   sgi_params[1] = adj_volume;
  2492.   sgi_params[2] = AL_RIGHT_SPEAKER_GAIN;
  2493.   sgi_params[3] = adj_volume;
  2494.   ALsetparams(AL_DEFAULT_DEVICE, sgi_params, 4);
  2495. }
  2496.  
  2497. #endif
  2498. /****************************************************************************/
  2499. /******************* END OF SGI SPECIFIC ROUTINES *********************/
  2500. /****************************************************************************/
  2501.  
  2502. /****************************************************************************/
  2503. /**************** HP SPECIFIC ROUTINES *******************************/
  2504. /****************************************************************************/
  2505. #ifdef XA_HP_AUDIO
  2506.  
  2507. void HP_Audio_Init();
  2508. void HP_Audio_Kill();
  2509. void HP_Audio_Off();
  2510. void HP_Audio_On();
  2511. xaULONG HP_Closest_Freq();
  2512. void HP_Speaker_Toggle();
  2513. void HP_Headphone_Toggle();
  2514. void HP_Adjust_Volume();
  2515. void HP_Print_Error();
  2516. void HP_Print_ErrEvent();
  2517. long HP_Audio_Err_Handler();
  2518. void TheEnd();
  2519. int  streamSocket; /*POD NOTE: rename */
  2520.  
  2521.  
  2522. #define HP_MAX_VOL (audio_connection->max_output_gain)
  2523. #define HP_MIN_VOL (audio_connection->min_output_gain)
  2524.  
  2525. Audio        *audio_connection = 0;
  2526.  
  2527. /* structures */
  2528. AudioAttributes    play_attribs;
  2529. SSPlayParams    streamParams;
  2530. SStream     audio_stream;
  2531. /* longs */
  2532. ATransID    hp_trans_id;
  2533. AudioAttrMask    hp_attr_mask;
  2534. AErrorHandler    hp_prev_handler;
  2535. AGainEntry    gainEntry[4];
  2536. long        hp_status;
  2537.  
  2538. long *hp_sample_rates = 0;
  2539. int hp_audio_paused = xaFALSE;
  2540.  
  2541. long HP_Audio_Err_Handler(audio,err_event)
  2542. Audio *audio;
  2543. AErrorEvent *err_event;
  2544. {
  2545.   fprintf(stderr,"HP_Audio_Err_Handler:\n");
  2546.   xa_audio_present = XA_AUDIO_ERR;
  2547.   xa_audio_status  = XA_AUDIO_STOPPED;
  2548.   HP_Print_ErrEvent("HP_Audio_Err_Handler: ","\n",err_event->error_code);
  2549.   /* PODNOTE: temporary: eventually we'll try a gracefull recovery
  2550.    * and shift back to visual only 
  2551.    */
  2552.   TheEnd();
  2553. }
  2554.  
  2555. /********** XA_Audio_Setup **********************
  2556.  * Sets up HP specific Routines
  2557.  *****/
  2558. void XA_Audio_Setup()
  2559. {
  2560.   XA_Audio_Init        = HP_Audio_Init;
  2561.   XA_Audio_Kill        = HP_Audio_Kill;
  2562.   XA_Audio_Off        = HP_Audio_Off;
  2563.   XA_Audio_On        = HP_Audio_On;
  2564.   XA_Closest_Freq    = HP_Closest_Freq;
  2565.   XA_Set_Output_Port    = (void *)(0);
  2566.   XA_Speaker_Tog    = HP_Speaker_Toggle;
  2567.   XA_Headphone_Tog    = HP_Headphone_Toggle;
  2568.   XA_LineOut_Tog    = HP_Headphone_Toggle;
  2569.  
  2570.   xa_snd_cur = 0;
  2571.   xa_audio_present = XA_AUDIO_UNK;
  2572.   xa_audio_status  = XA_AUDIO_STOPPED;
  2573.   xa_audio_ring_size  = 8;
  2574.   hp_audio_paused = xaFALSE;
  2575. }
  2576.  
  2577. /********** HP_Print_Error **********************
  2578.  * print error message
  2579.  *****/
  2580. void HP_Print_Error(pre_str,post_str,status)
  2581. char *pre_str,*post_str;
  2582. AError status;
  2583. { char err_buff[132];
  2584.   if (pre_str) fprintf(stderr,"%s (%d)",pre_str,(int)(status));
  2585.   AGetErrorText(audio_connection,status,err_buff,131);
  2586.   fprintf(stderr,"%s",err_buff);
  2587.   if (post_str) fprintf(stderr,"%s",post_str);
  2588. }
  2589.  
  2590. /********** HP_Print_ErrEvent **********************
  2591.  * print error message
  2592.  *****/
  2593. void HP_Print_ErrEvent(pre_str,post_str,errorCode)
  2594. char *pre_str,*post_str;
  2595. int  errorCode;
  2596. { char err_buff[132];
  2597.   if (pre_str) fprintf(stderr,"%s (%d)",pre_str,(int)(errorCode));
  2598.   AGetErrorText(audio_connection,errorCode,err_buff,131);
  2599.   fprintf(stderr,"%s",err_buff);
  2600.   if (post_str) fprintf(stderr,"%s",post_str);
  2601. }
  2602.  
  2603.  
  2604. /********** HP_Audio_Init ***************************************************
  2605.  * Init HP Audio, init variables, open Audio Devices.
  2606.  *****/
  2607. void HP_Audio_Init()
  2608. { int ret,tmp,type;
  2609.   AudioAttributes req_attribs;
  2610.   AByteOrder  req_byteorder;
  2611.   AudioAttrMask req_mask;
  2612.   char server[256];
  2613.   server[0] = '\0';
  2614.  
  2615.   DEBUG_LEVEL2 fprintf(stderr,"HP_Audio_Init\n");
  2616.   DEBUG_LEVEL2 fprintf(stderr,"HP_Audio_Init: theAudContext = %x\n",
  2617.                         (xaULONG)theAudContext);
  2618.  
  2619.   if (xa_audio_present != XA_AUDIO_UNK) return;
  2620.  
  2621.   /* Setup Error Handler */
  2622.   hp_prev_handler = ASetErrorHandler(HP_Audio_Err_Handler);
  2623.  
  2624.   /* Open Up Audio */
  2625.   audio_connection = AOpenAudio( server, &hp_status);
  2626.   if (audio_connection == NULL)
  2627.   { char buf[256];
  2628.     HP_Print_Error("HP_Audio: couldn't connect to Audio -","\n",hp_status);
  2629.     xa_audio_present = XA_AUDIO_ERR;
  2630.     return;
  2631.   }
  2632.  
  2633.  
  2634.   /* Request the following attributes and see what get's returned */
  2635.   req_attribs.type = ATSampled;
  2636.   req_attribs.attr.sampled_attr.data_format = ADFLin16;
  2637.   req_attribs.attr.sampled_attr.bits_per_sample = 16;
  2638.   req_attribs.attr.sampled_attr.sampling_rate = 8000;
  2639.   req_attribs.attr.sampled_attr.channels = 1;  /* MONO */
  2640.   req_attribs.attr.sampled_attr.interleave = 1; /*???*/
  2641.   req_byteorder = AMSBFirst;
  2642.  
  2643.   play_attribs.type = ATSampled;
  2644.   play_attribs.attr.sampled_attr.data_format = ADFLin16;
  2645.   play_attribs.attr.sampled_attr.bits_per_sample = 16;
  2646.   play_attribs.attr.sampled_attr.sampling_rate = 8000;
  2647.   play_attribs.attr.sampled_attr.channels = 1;  /* MONO */
  2648.   play_attribs.attr.sampled_attr.interleave = 1; /*???*/
  2649.  
  2650.   fprintf(stderr,"REQ- format %d  bits %d  rate %d  chans %d bo %d\n",
  2651.     req_attribs.attr.sampled_attr.data_format,
  2652.     req_attribs.attr.sampled_attr.bits_per_sample,
  2653.     req_attribs.attr.sampled_attr.sampling_rate,
  2654.     req_attribs.attr.sampled_attr.channels,
  2655.     req_byteorder );
  2656.  
  2657. /*
  2658.   req_mask =   ASDataFormatMask | ASBitsPerSampleMask | ASSamplingRateMask
  2659.         | ASChannelsMask;
  2660. */
  2661.   req_mask = ASDurationMask;
  2662.  
  2663.   AChoosePlayAttributes(audio_connection, &req_attribs,req_mask,
  2664.                 &play_attribs, &req_byteorder, NULL);
  2665.  
  2666.   fprintf(stderr,"REQ+ format %d  bits %d  rate %d  chans %d bo %d\n",
  2667.     req_attribs.attr.sampled_attr.data_format,
  2668.     req_attribs.attr.sampled_attr.bits_per_sample,
  2669.     req_attribs.attr.sampled_attr.sampling_rate,
  2670.     req_attribs.attr.sampled_attr.channels,
  2671.     req_byteorder );
  2672.  
  2673.   fprintf(stderr,"PLAY format %d  bits %d  rate %d  chans %d\n",
  2674.     play_attribs.attr.sampled_attr.data_format,
  2675.     play_attribs.attr.sampled_attr.bits_per_sample,
  2676.     play_attribs.attr.sampled_attr.sampling_rate,
  2677.     play_attribs.attr.sampled_attr.channels    );
  2678.  
  2679.   switch(play_attribs.attr.sampled_attr.data_format)
  2680.   {
  2681.     case ADFLin16:    xa_audio_hard_type  = XA_AUDIO_SIGNED_2MB; break;
  2682.     case ADFLin8:    xa_audio_hard_type  = XA_AUDIO_LINEAR_1M; break;
  2683.     case ADFLin8Offset:    xa_audio_hard_type  = XA_AUDIO_SIGNED_1M; break;
  2684.     default:
  2685.     fprintf(stderr,"HP_Audio: unknown hardware format\n");
  2686.     xa_audio_present = XA_AUDIO_ERR;
  2687.     return;
  2688.     break;
  2689.   }
  2690.  
  2691.   if (play_attribs.attr.sampled_attr.bits_per_sample == 16)
  2692.           xa_audio_hard_bps = 2;
  2693.   else        xa_audio_hard_bps = 1;
  2694.  
  2695.   if ( (req_byteorder == AMSBFirst) && (xa_audio_hard_bps > 1) )
  2696.             xa_audio_hard_type |= XA_AUDIO_BIGEND_MSK;
  2697.  
  2698.   xa_audio_hard_chans = play_attribs.attr.sampled_attr.channels;
  2699.   if (xa_audio_hard_chans == 2) 
  2700.             xa_audio_hard_type |= XA_AUDIO_STEREO_MSK;
  2701.  
  2702. DEBUG_LEVEL1 fprintf(stderr,"HP hard_type %x\n",xa_audio_hard_type);
  2703.  
  2704.   xa_audio_hard_freq = play_attribs.attr.sampled_attr.sampling_rate;
  2705.  
  2706.   xa_audio_hard_buff  = XA_HARD_BUFF_1K;
  2707.  
  2708. /* NOT USED FOR NOW, BUT HOPEFULLY EVENTUALLY */
  2709.   { unsigned long *tmp;
  2710.     long num;
  2711.     hp_sample_rates = 0;
  2712.     num = ANumSamplingRates(audio_connection);
  2713.     if (num >= 0)
  2714.     {
  2715.       hp_sample_rates = (long *)malloc( (num + 2) * sizeof(long) );
  2716.       tmp = ASamplingRates(audio_connection);
  2717.       if (tmp)
  2718.       { xaULONG i;
  2719.         for(i=0; i < num; i++) hp_sample_rates[i] = tmp[i];
  2720.         hp_sample_rates[num] = 0;
  2721. /*
  2722. DEBUG_LEVEL1
  2723. */
  2724. { 
  2725.   fprintf(stderr,"HP sampling rates: ");
  2726.   for(i=0;i<num;i++) fprintf(stderr,"<%d>",hp_sample_rates[i]);
  2727.   fprintf(stderr,"\n");
  2728. }
  2729.       }
  2730.       else {FREE(hp_sample_rates,0x500); hp_sample_rates=0;}
  2731.       if (hp_sample_rates==0)
  2732.       {
  2733.     fprintf(stderr,"Audio_Init: couldn't get sampling rates\n");
  2734.     xa_audio_present = XA_AUDIO_ERR;
  2735.     return;
  2736.       }
  2737.     }
  2738.   }
  2739.  
  2740.   xa_interval_id = 0;
  2741.   xa_audio_present = XA_AUDIO_OK;
  2742.  
  2743.   Init_Audio_Ring(xa_audio_ring_size,
  2744.             (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps) );
  2745.  
  2746.   switch(play_attribs.attr.sampled_attr.channels)
  2747.   {
  2748.     case 1:
  2749.     gainEntry[0].u.o.out_ch = AOCTMono;
  2750.     gainEntry[0].gain = AUnityGain;
  2751.     if (XAAUD->port & XA_AUDIO_PORT_INT)
  2752.         gainEntry[0].u.o.out_dst = AODTMonoIntSpeaker; /* internal */
  2753.     else    gainEntry[0].u.o.out_dst = AODTMonoJack; /* ext or hdphones */
  2754.     break;
  2755.     case 2:
  2756.     default:
  2757.     fprintf(stderr,"HP_AUDIO: Warning hardware wants stereo\n");
  2758.     gainEntry[0].u.o.out_ch = AOCTLeft;
  2759.     gainEntry[0].gain = AUnityGain;
  2760.     gainEntry[1].u.o.out_ch = AOCTRight;
  2761.     gainEntry[1].gain = AUnityGain;
  2762.     if (XAAUD->port & XA_AUDIO_PORT_INT)
  2763.     {
  2764.       gainEntry[0].u.o.out_dst = AODTLeftIntSpeaker;
  2765.       gainEntry[1].u.o.out_dst = AODTRightIntSpeaker;
  2766.     }
  2767.     else
  2768.     {
  2769.       gainEntry[0].u.o.out_dst = AODTLeftJack;
  2770.       gainEntry[1].u.o.out_dst = AODTRightJack;
  2771.     }
  2772.         break;
  2773.   }
  2774.   streamParams.gain_matrix.type = AGMTOutput;
  2775.   streamParams.gain_matrix.num_entries = 
  2776.             play_attribs.attr.sampled_attr.channels;  
  2777.   streamParams.gain_matrix.gain_entries = gainEntry;
  2778.   streamParams.play_volume = AUnityGain;
  2779.   streamParams.priority = APriorityNormal;
  2780.   streamParams.event_mask = 0;
  2781.    
  2782.  
  2783.   /* START UP SOCKET CONNECTION TO HP's AUDIO DEVICE */
  2784. /*
  2785.   hp_attr_mask = ASDataFormatMask | ASBitsPerSampleMask | 
  2786.             ASSamplingRateMask | ASChannelsMask | ASInterleaveMask;
  2787. */
  2788.   hp_attr_mask = ~0;
  2789.  
  2790.   /* create the stream */
  2791.   hp_trans_id = APlaySStream(audio_connection,hp_attr_mask,&play_attribs,
  2792.                 &streamParams,&audio_stream,NULL);
  2793.  
  2794.   /* create socket */
  2795.   streamSocket = socket(AF_INET, SOCK_STREAM, 0);
  2796.   if (streamSocket < 0) fprintf(stderr,"HP_Audio: socket err %d\n",errno);
  2797.  
  2798.   ret = connect(streamSocket,(struct sockaddr *)&audio_stream.tcp_sockaddr,
  2799.                     sizeof(struct sockaddr_in) );
  2800.   if (ret < 0) fprintf(stderr,"HP_Audio: connect error %d\n",errno);
  2801.  
  2802.   /* Pause Audio Stream */
  2803.   APauseAudio( audio_connection, hp_trans_id, NULL, NULL );
  2804.   hp_audio_paused = xaTRUE;
  2805. }
  2806.  
  2807. /********** HP_Audio_Kill ***************************************************
  2808.  * Stop HP Audio and Close HP Audio Devices. Free up memory.
  2809.  *****/
  2810. void HP_Audio_Kill()
  2811. {
  2812.   DEBUG_LEVEL2 fprintf(stderr,"HP_Audio_Kill\n");
  2813.   HP_Audio_Off(0);
  2814.   close(streamSocket);
  2815.   /* IS THIS NEEDED? need to get man page for ASetCloseDownMode */
  2816.   ASetCloseDownMode(audio_connection, AKeepTransactions, NULL );
  2817.   ACloseAudio(audio_connection,NULL);
  2818.   Kill_Audio_Ring();
  2819. }
  2820.  
  2821. /********** HP_Audio_Off ***************************************************
  2822.  * Stop HP Audio
  2823.  *****/
  2824. void HP_Audio_Off(flag)
  2825. xaULONG flag;
  2826. {
  2827.   DEBUG_LEVEL2 fprintf(stderr,"HP_Audio_Off\n");
  2828.   if (xa_audio_status != XA_AUDIO_STARTED) return;
  2829.   /* SET FLAG TO STOP OUTPUT ROUTINE */
  2830.   xa_audio_status = XA_AUDIO_STOPPED;
  2831.  
  2832.   /* POD NOTE: USE PAUSE FOR NOW */
  2833. /*
  2834.   APauseAudio(audio_connection,hp_trans_id, NULL, NULL);
  2835.   hp_audio_paused = xaTRUE;
  2836. */
  2837.   xa_audio_status = XA_AUDIO_STOPPED;
  2838.   xa_time_audio = -1;
  2839.   xa_audio_flushed = 0;
  2840. }
  2841.  
  2842. /********** HP_Audio_On ***************************************************
  2843.  * Startup HP Audio
  2844.  *****/
  2845. void HP_Audio_On()
  2846. { AudioAttrMask attr_mask;
  2847.   DEBUG_LEVEL2 fprintf(stderr,"HP_Audio_On \n");
  2848.   if (xa_audio_status == XA_AUDIO_STARTED) return;
  2849.   else if (xa_audio_present != XA_AUDIO_OK) return;
  2850.   else if (xa_snd_cur)
  2851.   { int ret,tmp,utime;
  2852.  
  2853.     /* Change Frequency If necessary */
  2854.     if (xa_audio_hard_freq != xa_snd_cur->hfreq)
  2855.     { 
  2856.       play_attribs.attr.sampled_attr.sampling_rate = xa_snd_cur->hfreq;
  2857.       xa_audio_hard_freq = xa_snd_cur->hfreq;
  2858.     }
  2859.  
  2860.     /* xa_snd_cur gets changes in Update_Ring() */
  2861.     xa_out_time = 250;  /* keep audio fed 500ms ahead of video */
  2862.     xa_out_init = xa_audio_ring_size - 1;
  2863.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  2864.  
  2865.     xa_audio_status = XA_AUDIO_STARTED;
  2866.     XA_Flush_Ring();
  2867.     XA_Update_Ring(1000);
  2868.  
  2869.     if (xa_interval_time == 0) xa_interval_time = 1;
  2870.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  2871.     New_Merged_Audio_Output();
  2872.   }
  2873. }
  2874.  
  2875. /********** HP_Closest_Freq **********************
  2876.  * Return closest support frequeny and set hard_buff.
  2877.  *****/
  2878. xaULONG HP_Closest_Freq(ifreq)
  2879. xaLONG ifreq;
  2880. {
  2881.  /* POD TEMPORARY */
  2882.   xa_audio_hard_buff = XA_HARD_BUFF_1K;
  2883.   return(8000);
  2884. }
  2885.  
  2886. /********** HP_Speaker_Toggle **********************
  2887.  * Turn off/on/toggle HP's Speaker(if possible)
  2888.  * flag= 0   1   2 
  2889.  *****/
  2890. void HP_Speaker_Toggle(flag)
  2891. xaULONG flag;
  2892. {
  2893.   return;
  2894. }
  2895.  
  2896. /********** HP_Headphone_Toggle **********************
  2897.  * Turn off/on/toggle HP's Headphone(if possible)
  2898.  * flag= 0   don't use Headphones(defaults to internal speaker)
  2899.  * flag= 1   Use Headphones.
  2900.  * flag= 2   Toggle. If headphone then internal and vice_versa. 
  2901.  *****/
  2902. void HP_Headphone_Toggle(flag)
  2903. xaULONG flag;
  2904. {
  2905.   return;
  2906. }
  2907.  
  2908. /********** HP_Adjust_Volume **********************
  2909.  * Routine for Adjusting Volume on HP
  2910.  *
  2911.  *****/
  2912.  
  2913. /* AUnityGain is 0. AZeroGain is 0x80000000 */
  2914. void HP_Adjust_Volume(volume)
  2915. xaLONG volume;
  2916. { xaLONG adj_volume;
  2917.   AGainDB play_gain,tmp_gain;
  2918.   int ret;
  2919.   adj_volume = HP_MIN_VOL + 
  2920.     ((volume * (HP_MAX_VOL - HP_MIN_VOL)) / XA_AUDIO_MAXVOL);
  2921.   if (adj_volume > HP_MAX_VOL) adj_volume = HP_MAX_VOL;
  2922.   play_gain = (AGainDB)adj_volume;
  2923. /*
  2924.   AGetSystemChannelGain(audio_connection,ASGTPlay,ACTMono,&tmp_gain,NULL);
  2925.   fprintf(stderr,"Get Gain %x adj_vol %x  hpmin %x hpmax %x\n",
  2926.                 tmp_gain,adj_volume,HP_MIN_VOL, HP_MAX_VOL);
  2927.   ASetSystemChannelGain(audio_connection,ASGTPlay,ACTMono,play_gain,NULL);
  2928.   ASetChannelGain(audio_connection,hp_trans_id,ACTMono,play_gain,NULL);
  2929.   ASetGain(audio_connection,hp_trans_id,play_gain,NULL);
  2930. */
  2931.   ASetSystemPlayGain(audio_connection,play_gain,NULL);
  2932. }
  2933.  
  2934. #endif
  2935. /****************************************************************************/
  2936. /******************* END OF HP SPECIFIC ROUTINES ****************************/
  2937. /****************************************************************************/
  2938.  
  2939.  
  2940. /****************************************************************************/
  2941. /**************** HPDEV SPECIFIC ROUTINES ***************************/
  2942. /****************************************************************************/
  2943. #ifdef XA_HPDEV_AUDIO
  2944.  
  2945. void HPDEV_Audio_Init();
  2946. void HPDEV_Audio_Kill();
  2947. void HPDEV_Audio_Off();
  2948. void HPDEV_Audio_On();
  2949. xaULONG HPDEV_Closest_Freq();
  2950. void HPDEV_Speaker_Toggle();
  2951. void HPDEV_Headphone_Toggle();
  2952. void HPDEV_LineOut_Toggle();
  2953. void HPDEV_Adjust_Volume();
  2954. static void HPDEV_Audio_Output();
  2955.  
  2956. static int devAudio;
  2957. static struct audio_describe audioDesc;
  2958.  
  2959.  
  2960. /********** XA_Audio_Setup **********************
  2961.  * Sets up HP specific routines
  2962.  *****/
  2963. void XA_Audio_Setup()
  2964. {
  2965.   XA_Audio_Init        = HPDEV_Audio_Init;
  2966.   XA_Audio_Kill        = HPDEV_Audio_Kill;
  2967.   XA_Audio_Off        = HPDEV_Audio_Off;
  2968.   XA_Audio_On        = HPDEV_Audio_On;
  2969.   XA_Closest_Freq    = HPDEV_Closest_Freq;
  2970.   XA_Set_Output_Port    = (void *)(0);
  2971.   XA_Speaker_Tog    = HPDEV_Speaker_Toggle;
  2972.   XA_Headphone_Tog    = HPDEV_Headphone_Toggle;
  2973.   XA_LineOut_Tog    = HPDEV_LineOut_Toggle;
  2974.   XA_Adjust_Volume    = HPDEV_Adjust_Volume;
  2975.  
  2976.   xa_snd_cur = 0;
  2977.   xa_audio_present = XA_AUDIO_UNK;
  2978.   xa_audio_status = XA_AUDIO_STOPPED;
  2979.   xa_audio_ring_size = 8;
  2980. }
  2981.  
  2982. /********** HPDEV_Audio_Init ***************************************************
  2983.  * open /dev/audio and init
  2984.  *****/
  2985. void HPDEV_Audio_Init()
  2986. {
  2987.   DEBUG_LEVEL2 fprintf(stderr,"HPDEV_Audio_Init\n");
  2988.   if (xa_audio_present != XA_AUDIO_UNK) return;
  2989.  
  2990.   if ((devAudio = open ("/dev/audio", O_WRONLY | O_NDELAY, 0)) < 0)
  2991.   {
  2992.     if (errno == EBUSY) fprintf(stderr,"Audio_Init: Audio device is busy. - ");
  2993.     else fprintf(stderr,"Audio_Init: Error opening audio device. - ");
  2994.     fprintf(stderr,"Will continue without audio\n");
  2995.     xa_audio_present = XA_AUDIO_ERR;
  2996.     return;
  2997.   }
  2998.  
  2999.   fcntl(devAudio,F_SETFL,O_NDELAY);
  3000.  
  3001.  
  3002.   /* Get description of /dev/audio: */
  3003.   if (ioctl (devAudio, AUDIO_DESCRIBE, &audioDesc))
  3004.   {
  3005.     perror ("ioctl AUDIO_DESCRIBE on /dev/audio");
  3006.     xa_audio_present = XA_AUDIO_ERR;
  3007.     return;
  3008.   }
  3009.  
  3010.   xa_audio_hard_type  = XA_AUDIO_SIGNED_2MB;
  3011.   xa_audio_hard_freq  = 0;      /* none yet (HPDEV_Audio_On does this job) */
  3012.   xa_audio_hard_bps   = 2;
  3013.   xa_audio_hard_chans = 1;
  3014.   xa_audio_hard_buff  = XA_HARD_BUFF_1K;
  3015.  
  3016.   if (ioctl (devAudio, AUDIO_SET_DATA_FORMAT, AUDIO_FORMAT_LINEAR16BIT))
  3017.   {
  3018.     perror ("ioctl AUDIO_SET_DATA_FORMAT on /dev/audio");
  3019.     xa_audio_present = XA_AUDIO_ERR;
  3020.     return;
  3021.   }
  3022.   if (ioctl (devAudio, AUDIO_SET_CHANNELS, 1))
  3023.   {
  3024.     perror ("ioctl AUDIO_SET_CHANNELS on /dev/audio");
  3025.     xa_audio_present = XA_AUDIO_ERR;
  3026.     return;
  3027.   }
  3028.  
  3029.   /* set device internal buffer size: */
  3030.   if (ioctl (devAudio, AUDIO_SET_TXBUFSIZE, 16 * 1024))
  3031.     perror ("ioctl AUDIO_SET_TXBUFSIZE on /dev/audio");
  3032.  
  3033.   xa_interval_id = 0;
  3034.   xa_audio_present = XA_AUDIO_OK;
  3035.   Init_Audio_Ring(xa_audio_ring_size, (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps) );
  3036. }
  3037.  
  3038. /********** HPDEV_Audio_Kill ***************************************************
  3039.  * Stop HP Audio and Close HP Audio Devices. Free up memory.
  3040.  *****/
  3041. void HPDEV_Audio_Kill()
  3042. {
  3043.   DEBUG_LEVEL2 fprintf(stderr,"HPDEV_Audio_Kill\n");
  3044.   HPDEV_Audio_Off(0);
  3045.   xa_audio_present = XA_AUDIO_UNK;
  3046.   close(devAudio);
  3047.   Kill_Audio_Ring();
  3048. }
  3049.  
  3050. /********** HPDEV_Audio_Off ***************************************************
  3051.  * Stop HP Audio
  3052.  *****/
  3053. void HPDEV_Audio_Off(flag)
  3054. xaULONG flag;
  3055. {
  3056.   DEBUG_LEVEL2 fprintf(stderr,"HPDEV_Audio_Off\n");
  3057.   if (xa_audio_status != XA_AUDIO_STARTED) return;
  3058.  
  3059.   /* SET FLAG TO STOP OUTPUT ROUTINE */
  3060.   xa_audio_status = XA_AUDIO_STOPPED;
  3061.  
  3062.   if (ioctl (devAudio, AUDIO_DRAIN, 0))
  3063.     perror ("ioctl AUDIO_DRAIN on /dev/audio");
  3064.  
  3065.   xa_time_audio = -1;
  3066.   xa_audio_flushed = 0;
  3067. }
  3068.  
  3069. /********** HPDEV_Audio_On ***************************************************
  3070.  * Startup HP Audio
  3071.  *****/
  3072. void HPDEV_Audio_On()
  3073. {
  3074.   DEBUG_LEVEL2 fprintf(stderr,"HPDEV_Audio_On\n");
  3075.   if (xa_audio_status == XA_AUDIO_STARTED) return;
  3076.   else if (xa_audio_present != XA_AUDIO_OK) return;
  3077.   else if (xa_snd_cur)
  3078.   { int ret,tmp,utime;
  3079.  
  3080.     /* Change frequency if necessary */
  3081.     if (xa_audio_hard_freq != xa_snd_cur->hfreq)
  3082.     { 
  3083.       do { ret = ioctl(devAudio, AUDIO_SET_SAMPLE_RATE, xa_snd_cur->hfreq);
  3084.          } while( (ret < 0) && (errno == EBUSY) );
  3085.       if (ret < 0) perror ("ioctl AUDIO_SET_SAMPLE_RATE on /dev/audio");
  3086.       xa_audio_hard_freq = xa_snd_cur->hfreq;
  3087.     }
  3088.  
  3089.     /* xa_snd_cur gets changes in Update_Ring() */
  3090.     xa_out_time = 250; /* keep audio fed 250ms ahead of video */
  3091.     xa_out_init = xa_audio_ring_size - 1;
  3092.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  3093.  
  3094.     xa_audio_status = XA_AUDIO_STARTED;
  3095.     XA_Flush_Ring();
  3096.     XA_Update_Ring(1000);
  3097.  
  3098.     if (xa_interval_time == 0) xa_interval_time = 1;
  3099.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  3100.     New_Merged_Audio_Output();
  3101.   }
  3102. }
  3103.  
  3104. /********** HPDEV_Closest_Freq **********************
  3105.  * Return closest support frequeny and set hard_buff.
  3106.  *****/
  3107. xaULONG HPDEV_Closest_Freq(ifreq)
  3108. xaLONG ifreq;
  3109. {
  3110.   unsigned int rate_index;
  3111.   long nearest_frequency = 8000;
  3112.   long frequency_diff = 999999;
  3113.  
  3114.   xa_audio_hard_buff = XA_HARD_BUFF_1K;
  3115.  
  3116.   for (rate_index = 0; rate_index < audioDesc.nrates; ++rate_index)
  3117.   { if (abs (audioDesc.sample_rate[rate_index] - ifreq) <= frequency_diff)
  3118.     { nearest_frequency = audioDesc.sample_rate[rate_index];
  3119.       frequency_diff = abs (audioDesc.sample_rate[rate_index] - ifreq);
  3120.     }
  3121.   }
  3122.   return nearest_frequency;
  3123. }
  3124.  
  3125. /********** HPDEV_Speaker_Toggle **********************
  3126.  * Turn off/on/toggle HP's Speaker(if possible)
  3127.  * flag= 0   1   2 
  3128.  *****/
  3129. void HPDEV_Speaker_Toggle(flag)
  3130. xaULONG flag;
  3131. {
  3132.   int output_channel;
  3133.  
  3134.   if (ioctl (devAudio, AUDIO_GET_OUTPUT, &output_channel))
  3135.   {
  3136.     perror ("ioctl AUDIO_GET_OUTPUT on /dev/audio");
  3137.     output_channel = 0;
  3138.   }
  3139.   switch (flag)
  3140.   {
  3141.     case 0:
  3142.       output_channel &= ~AUDIO_OUT_SPEAKER; break;
  3143.     case 1:
  3144.       output_channel |= AUDIO_OUT_SPEAKER; break;
  3145.     case 2:
  3146.       output_channel ^= AUDIO_OUT_SPEAKER;
  3147.   }
  3148.   if (ioctl (devAudio, AUDIO_SET_OUTPUT, output_channel))
  3149.     perror ("ioctl AUDIO_SET_OUTPUT on /dev/audio");
  3150. }
  3151.  
  3152. /********** HPDEV_Headphone_Toggle **********************
  3153.  * Turn off/on/toggle HP's Headphone(if possible)
  3154.  * flag= 0   don't use Headphones(defaults to internal speaker)
  3155.  * flag= 1   Use Headphones.
  3156.  * flag= 2   Toggle. If headphone then internal and vice_versa. 
  3157.  *****/
  3158. void HPDEV_Headphone_Toggle(flag)
  3159. xaULONG flag;
  3160. {
  3161.   int output_channel;
  3162.  
  3163.   if (ioctl (devAudio, AUDIO_GET_OUTPUT, &output_channel))
  3164.   {
  3165.     perror ("ioctl AUDIO_GET_OUTPUT on /dev/audio");
  3166.     output_channel = 0;
  3167.   }
  3168.   switch (flag)
  3169.   {
  3170.     case 0:
  3171.       output_channel &= ~AUDIO_OUT_HEADPHONE; break;
  3172.     case 1:
  3173.       output_channel |= AUDIO_OUT_HEADPHONE; break;
  3174.     case 2:
  3175.       output_channel ^= AUDIO_OUT_HEADPHONE;
  3176.   }
  3177.   if (ioctl (devAudio, AUDIO_SET_OUTPUT, output_channel))
  3178.     perror ("ioctl AUDIO_SET_OUTPUT on /dev/audio");
  3179. }
  3180.  
  3181. /********** HPDEV_LineOut_Toggle **********************
  3182.  * Turn off/on/toggle HP's LineOut(if possible)
  3183.  * flag= 0   don't use LineOut(defaults to internal speaker)
  3184.  * flag= 1   Use LineOut.
  3185.  * flag= 2   Toggle. If LineOut then internal and vice_versa. 
  3186.  *****/
  3187. void HPDEV_LineOut_Toggle(flag)
  3188. xaULONG flag;
  3189. {
  3190.   int output_channel;
  3191.  
  3192.   if (ioctl (devAudio, AUDIO_GET_OUTPUT, &output_channel))
  3193.   {
  3194.     perror ("ioctl AUDIO_GET_OUTPUT on /dev/audio");
  3195.     output_channel = 0;
  3196.   }
  3197.   switch (flag)
  3198.   {
  3199.     case 0:
  3200.       output_channel &= ~AUDIO_OUT_LINE; break;
  3201.     case 1:
  3202.       output_channel |= AUDIO_OUT_LINE; break;
  3203.     case 2:
  3204.       output_channel ^= AUDIO_OUT_LINE;
  3205.   }
  3206.   if (ioctl (devAudio, AUDIO_SET_OUTPUT, output_channel))
  3207.     perror ("ioctl AUDIO_SET_OUTPUT on /dev/audio");
  3208. }
  3209.  
  3210. /********** HPDEV_Adjust_Volume **********************
  3211.  * Routine for Adjusting Volume on HP
  3212.  *
  3213.  *****/
  3214. void HPDEV_Adjust_Volume(volume)
  3215. xaLONG volume;
  3216. {
  3217.   struct audio_describe description;
  3218.   struct audio_gains gains;
  3219.   float floatvolume = ((float)volume - (float)XA_AUDIO_MINVOL) /
  3220.               ((float)XA_AUDIO_MAXVOL - (float)XA_AUDIO_MINVOL);
  3221.  
  3222.   if (ioctl (devAudio, AUDIO_DESCRIBE, &description))
  3223.   {
  3224.     perror ("ioctl AUDIO_DESCRIBE on /dev/audio");
  3225.     return;
  3226.   }
  3227.   if (ioctl (devAudio, AUDIO_GET_GAINS, &gains))
  3228.   {
  3229.     perror ("ioctl AUDIO_GET_GAINS on /dev/audio");
  3230.     return;
  3231.   }
  3232.   gains.transmit_gain = (int)((float)description.min_transmit_gain +
  3233.                   (float)(description.max_transmit_gain
  3234.                       - description.min_transmit_gain) * floatvolume);
  3235.   if (ioctl (devAudio, AUDIO_SET_GAINS, &gains))
  3236.     perror ("ioctl AUDIO_SET_GAINS on /dev/audio");
  3237. }
  3238.  
  3239. #endif
  3240. /****************************************************************************/
  3241. /******************* END OF HPDEV SPECIFIC ROUTINES ******************/
  3242. /****************************************************************************/
  3243.  
  3244. /****************************************************************************/
  3245. /**************** AF SPECIFIC ROUTINES **************************************/
  3246. /****************************************************************************/
  3247. #ifdef XA_AF_AUDIO
  3248.  
  3249. /*
  3250.  * AF port provided by Tom Levergood,
  3251.  *    tml@crl.dec.com
  3252.  * Thu Aug 25 14:05:47 1994
  3253.  * This is a quick hack, I need to stare at the xa buffering
  3254.  * further to clean up the port.
  3255.  */
  3256.  
  3257. void  AF_Audio_Init();
  3258. void  AF_Audio_Kill();
  3259. void  AF_Audio_Off();
  3260. void  AF_Audio_On();
  3261. void  AF_Adjust_Volume();
  3262. xaULONG AF_Closest_Freq();
  3263. void AF_Speaker_Toggle();
  3264. void AF_Headphone_Toggle();
  3265.  
  3266.  
  3267. static AFAudioConn *AFaud;
  3268. static AC ac;
  3269. static AFSetACAttributes AFattributes;
  3270. static int    AFdevice;
  3271. static ATime AFtime0=0;
  3272. static ATime AFbaseT=0;
  3273.  
  3274. /********** XA_Audio_Setup **********************
  3275.  * 
  3276.  * Also defines Sparc Specific variables.
  3277.  *
  3278.  *****/
  3279. void XA_Audio_Setup()
  3280. {
  3281.   XA_Audio_Init        = AF_Audio_Init;
  3282.   XA_Audio_Kill        = AF_Audio_Kill;
  3283.   XA_Audio_Off        = AF_Audio_Off;
  3284.   XA_Audio_On        = AF_Audio_On;
  3285.   XA_Closest_Freq    = AF_Closest_Freq;
  3286.   XA_Set_Output_Port    = (void *)(0);
  3287.   XA_Speaker_Tog    = AF_Speaker_Toggle;
  3288.   XA_Headphone_Tog    = AF_Headphone_Toggle;
  3289.   XA_LineOut_Tog    = AF_Headphone_Toggle;
  3290.   XA_Adjust_Volume    = AF_Adjust_Volume;
  3291.  
  3292.   xa_snd_cur = 0;
  3293.   xa_audio_present = XA_AUDIO_UNK;
  3294.   xa_audio_status  = XA_AUDIO_STOPPED;
  3295.   xa_audio_ring_size  = 8;
  3296. }
  3297.  
  3298.  
  3299. #define    AF_C_MIN    -30
  3300. #define    AF_C_MAX    30
  3301. #define AF_MAP_TO_C_GAIN(vol) (( ((vol)*AF_C_MAX)/XA_AUDIO_MAXVOL) + (AF_C_MIN))
  3302.  
  3303. #define SPU(type)       AF_sample_sizes[type].samps_per_unit
  3304. #define BPU(type)       AF_sample_sizes[type].bytes_per_unit
  3305.  
  3306. #define DPHONE(od) (int)(((AAudioDeviceDescriptor(AFaud, (od)))->outputsToPhone))
  3307. #define DFREQ(od) (int)(((AAudioDeviceDescriptor(AFaud, (od)))->playSampleFreq))
  3308. #define DCHAN(od) (int)((AAudioDeviceDescriptor(AFaud, (od)))->playNchannels)
  3309. #define DTYPE(od) ((AAudioDeviceDescriptor(AFaud, (od)))->playBufType)
  3310.  
  3311. #define    TOFFSET    250
  3312.  
  3313.  
  3314. /*
  3315.  * Find a suitable default device (the first device not connected to the phone),
  3316.  *  returns device number.
  3317.  *
  3318.  * Returns -1 if no suitable device can be found.
  3319.  */
  3320. static int FindDefaultDevice(aud)
  3321. AFAudioConn *aud;
  3322. {
  3323.   int i;
  3324.   char *ep;
  3325.  
  3326.   if ((ep = getenv("AF_DEVICE")) != NULL) 
  3327.   { int udevice;
  3328.     udevice = atoi(ep);
  3329.     if ((udevice >= 0) && (udevice < ANumberOfAudioDevices(aud)))
  3330.     return udevice;
  3331.   }
  3332.   for(i=0; i<ANumberOfAudioDevices(aud); i++) 
  3333.   {
  3334.     if ( DPHONE(i) == 0 && DCHAN(i) == 1 ) return i;
  3335.   }
  3336.   return -1;
  3337. }
  3338.  
  3339. void XA_No_Audio_Support()
  3340. {
  3341.   fprintf(stderr,"AUDIO SUPPORT NOT COMPILED IN THIS EXECUTABLE.\n");
  3342.   return;
  3343. }
  3344.  
  3345. /********** AF_Audio_Init **********************
  3346.  *****/
  3347. void AF_Audio_Init()
  3348. { 
  3349.   DEBUG_LEVEL2 fprintf(stderr,"AF_Audio_Init\n");
  3350.   if (xa_audio_present != XA_AUDIO_UNK) return;
  3351.  
  3352.   /* Open connection. */
  3353.   if ( (AFaud = AFOpenAudioConn("")) == NULL) 
  3354.   {
  3355.       fprintf(stderr, "Could not open connection to AF audio server.\n");
  3356.       fprintf(stderr, "Disabling audio service.\n");
  3357.       /* As long as xa_audio_present isn't OK, audio is effectively disabled*/
  3358.       /* but might as well really disable it */
  3359.       XA_Null_Audio_Setup();
  3360.       xa_audio_present = XA_AUDIO_UNK;
  3361.       return;
  3362.   }
  3363.   AFdevice = FindDefaultDevice(AFaud);
  3364.   AFattributes.type = LIN16;
  3365.   AFattributes.endian = ALittleEndian;
  3366.   AFattributes.play_gain = AF_MAP_TO_C_GAIN(XAAUD->volume);
  3367.   ac = AFCreateAC(AFaud, AFdevice, (ACPlayGain | ACEncodingType | ACEndian), &AFattributes);
  3368.   AFSync(AFaud, 0);     /* Make sure we confirm encoding type support. */
  3369.   if (ac == NULL)
  3370.   {
  3371.     fprintf(stderr,"AF: Could not create audio context for device %d\n",AFdevice);
  3372.     xa_audio_present = XA_AUDIO_ERR;
  3373.     return;
  3374.   }
  3375.  
  3376. DEBUG_LEVEL2 fprintf(stderr,"Created audio context, SR %d device %d\n",
  3377.              DFREQ(AFdevice),AFdevice);
  3378.  
  3379.   /* get default frequency - not really necessary */
  3380.   xa_audio_hard_freq = DFREQ(AFdevice);
  3381.  
  3382.   xa_audio_hard_bps = 2;
  3383.   xa_audio_hard_chans = 1;
  3384.   xa_audio_hard_buff  = XA_HARD_BUFF_1K;
  3385.   xa_audio_hard_type  = XA_AUDIO_SIGNED_2ML;
  3386.  
  3387.   xa_interval_id = 0;
  3388.   xa_audio_present = XA_AUDIO_OK;
  3389.   DEBUG_LEVEL2 fprintf(stderr,"   success \n");
  3390.   Init_Audio_Ring(xa_audio_ring_size,
  3391.             (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps) );
  3392. }
  3393.  
  3394. /********** AF_Audio_Kill **********************
  3395.  *****/
  3396. void AF_Audio_Kill()
  3397. { 
  3398. DEBUG_LEVEL2 fprintf(stderr,"AF_Audio_Kill\n");
  3399.  
  3400.   AF_Audio_Off(0);
  3401.   xa_audio_present = XA_AUDIO_UNK;
  3402.  
  3403.   /* XXX */
  3404.   AFCloseAudioConn(AFaud);
  3405.  
  3406.   Kill_Audio_Ring();
  3407. }
  3408.  
  3409. /********** AF_Audio_Off **********************
  3410.  * Stop Audio Stream
  3411.  *
  3412.  *****/
  3413. void AF_Audio_Off(flag)
  3414. xaULONG flag;
  3415. { 
  3416.   DEBUG_LEVEL2 fprintf(stderr,"AF_Audio_Off\n");
  3417.   if (xa_audio_status == XA_AUDIO_STOPPED) return;
  3418.  
  3419.   /* XXX */
  3420.  
  3421.   xa_audio_status = XA_AUDIO_STOPPED;
  3422. }
  3423.  
  3424. /********** AF_Audio_On **********************
  3425.  * Turn On Audio Stream.
  3426.  *
  3427.  *****/
  3428. void AF_Audio_On()
  3429. {
  3430.   DEBUG_LEVEL2 fprintf(stderr,"AF_Audio_On \n");
  3431.   if (xa_audio_status == XA_AUDIO_STARTED) return;
  3432.   else if (xa_audio_present != XA_AUDIO_OK) return;
  3433.   else if (xa_snd_cur)
  3434.   { 
  3435.     /* Change Frequency If necessary */
  3436.     if (xa_audio_hard_freq != xa_snd_cur->hfreq)
  3437.     { 
  3438.     /* XXX */
  3439.       xa_audio_hard_freq = xa_snd_cur->hfreq;
  3440.     }
  3441.  
  3442.     /* xa_snd_cur gets changes in Update_Ring() */
  3443.     xa_out_time = 250; /* keep audio fed 250ms ahead of video - could be 500*/
  3444.     xa_out_init = xa_audio_ring_size - 1;
  3445.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  3446.  
  3447.     xa_audio_status = XA_AUDIO_STARTED;
  3448.     XA_Flush_Ring();
  3449.     XA_Update_Ring(1000);
  3450.  
  3451.     AFtime0 = AFbaseT = AFGetTime(ac) + TOFFSET;
  3452.     if (xa_interval_time == 0) xa_interval_time = 1;
  3453.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  3454.     New_Merged_Audio_Output();
  3455.   }
  3456. }
  3457.  
  3458. /*************
  3459.  * flag = 0  turn speaker off
  3460.  * flag = 1  turn speaker on
  3461.  * flag = 2  toggle speaker
  3462.  */
  3463. void AF_Speaker_Toggle(flag)
  3464. xaULONG flag;
  3465. { 
  3466.   DEBUG_LEVEL2 fprintf(stderr,"AF_Speaker_Toggle\n");
  3467. }
  3468.  
  3469. void AF_Headphone_Toggle(flag)
  3470. xaULONG flag;
  3471. { 
  3472.   DEBUG_LEVEL2 fprintf(stderr,"AF_Headphone_Toggle\n");
  3473. }
  3474.  
  3475. /********** AF_Adjust_Volume **********************
  3476.  * Routine for Adjusting Volume on a AF
  3477.  *
  3478.  *****/
  3479. void AF_Adjust_Volume(volume)
  3480. xaULONG volume;
  3481. { 
  3482.  DEBUG_LEVEL2 fprintf(stderr,"AF_Audio_Volume %d\n",volume);
  3483.  
  3484.  /* Client gain settings range from -30 to +30 dB. */
  3485.  AFattributes.play_gain = AF_MAP_TO_C_GAIN(volume);
  3486.  AFChangeACAttributes(ac, ACPlayGain, &AFattributes);
  3487.  AFSync(AFaud,0);
  3488. }
  3489.  
  3490. /********** AF_Closest_Freq **********************
  3491.  *
  3492.  * Global Variable Affect:
  3493.  *   xaULONG xa_audio_hard_buff        must set but not larger than
  3494.  *                    XA_AUDIO_MAX_RING_BUF size
  3495.  */
  3496. xaULONG AF_Closest_Freq(ifreq)
  3497. xaLONG ifreq;
  3498. {
  3499.  return (DFREQ(AFdevice));
  3500. }
  3501.  
  3502. #endif
  3503. /****************************************************************************/
  3504. /******************* END OF AF SPECIFIC ROUTINES ****************************/
  3505. /****************************************************************************/
  3506.  
  3507.  
  3508. /****************************************************************************/
  3509. /**************** DEC Multimedia Services SPECIFIC ROUTINES *****************/
  3510. /****************************************************************************/
  3511. #ifdef XA_MMS_AUDIO
  3512.  
  3513. /*
  3514.  * MMS port provided by Tom Morris (morris@zko.dec.com)
  3515.  */
  3516.  
  3517. void  MMS_Audio_Init();
  3518. void  MMS_Audio_Kill();
  3519. void  MMS_Audio_Off();
  3520. void  MMS_Audio_On();
  3521. void  MMS_Adjust_Volume();
  3522. xaULONG MMS_Closest_Freq();
  3523. void MMS_Speaker_Toggle();
  3524. void MMS_Headphone_Toggle();
  3525.  
  3526. /* Global variables */
  3527.  
  3528. static HWAVEOUT        mms_device_handle = 0;
  3529. static UINT        mms_device_id = 0;
  3530. static xaULONG        mms_device_volume = xaFALSE;
  3531. static LPWAVEHDR    mms_lpWaveHeader;
  3532. static LPSTR        mms_audio_buffer;
  3533. static int        mms_buffers_outstanding = 0;
  3534. static int        mms_next_buffer = 0;
  3535.  
  3536. /********** XA_Audio_Setup **********************
  3537.  *
  3538.  *****/
  3539. void XA_Audio_Setup()
  3540. {
  3541.   XA_Audio_Init        = MMS_Audio_Init;
  3542.   XA_Audio_Kill        = MMS_Audio_Kill;
  3543.   XA_Audio_Off        = MMS_Audio_Off;
  3544.   XA_Audio_On        = MMS_Audio_On;
  3545.   XA_Closest_Freq    = MMS_Closest_Freq;
  3546.   XA_Set_Output_Port    = (void *)(0);
  3547.   XA_Speaker_Tog    = MMS_Speaker_Toggle;
  3548.   XA_Headphone_Tog    = MMS_Headphone_Toggle;
  3549.   XA_LineOut_Tog    = MMS_Headphone_Toggle;
  3550.   XA_Adjust_Volume    = MMS_Adjust_Volume;
  3551.  
  3552.   xa_snd_cur = 0;
  3553.   xa_audio_present = XA_AUDIO_UNK;
  3554.   xa_audio_status  = XA_AUDIO_STOPPED;
  3555.   xa_audio_ring_size  = 8;
  3556. }
  3557.  
  3558. void XA_No_Audio_Support()
  3559. {
  3560.   fprintf(stderr,"AUDIO SUPPORT NOT COMPILED IN THIS EXECUTABLE.\n");
  3561.   return;
  3562. }
  3563.  
  3564. /********** MMS_Audio_Init **********************
  3565.  
  3566.   This just does some generic initialization.  The actual audio
  3567.   output device open is done in the Audio_On routine so that we
  3568.   can get a device which matches the requested sample rate & format
  3569.  
  3570.  *****/
  3571. void MMS_Audio_Init()
  3572. {
  3573.   MMRESULT    status;
  3574.   LPWAVEOUTCAPS    lpCaps;
  3575.  
  3576.   DEBUG_LEVEL2 fprintf(stderr,"MMS_Audio_Init\n");
  3577.   if (xa_audio_present != XA_AUDIO_UNK) return;
  3578.  
  3579.   if( waveOutGetNumDevs() < 1 ) 
  3580.   {
  3581.     xa_audio_present = XA_AUDIO_ERR;
  3582.     fprintf(stderr,"Audio disabled - No Multimedia Services compatible audio devices available\n");
  3583.     return;
  3584.   }
  3585.  
  3586.   /* Figure out device capabilities  - Just use device 0 for now */
  3587.  
  3588.   if((lpCaps = (LPWAVEOUTCAPS)mmeAllocMem(sizeof(WAVEOUTCAPS))) == NULL ) {
  3589.       fprintf(stderr,"Failed to allocate WAVEOUTCAPS struct\n");
  3590.       return;
  3591.   }
  3592.   status = waveOutGetDevCaps( 0, lpCaps, sizeof(WAVEOUTCAPS));
  3593.   if( status != MMSYSERR_NOERROR ) {
  3594.       fprintf(stderr,"waveOutGetDevCaps failed - status = %d\n", status);
  3595.   }
  3596.  
  3597.   /* Multimedia Services will do sample rate & format conversion for
  3598.   ** simpler devices, so just go for the max
  3599.   */
  3600. /* No stereo support currently?
  3601.   xa_audio_hard_type  = XA_AUDIO_SIGNED_2SL;
  3602.   xa_audio_hard_chans = 2;
  3603.   xa_audio_hard_bps = 4;
  3604. */
  3605.  
  3606.   xa_audio_hard_type  = XA_AUDIO_SIGNED_2ML;
  3607.   xa_audio_hard_chans = 1;
  3608.   xa_audio_hard_bps = 2;
  3609.  
  3610.   /* Make sure device gets openend first time through */
  3611.   xa_audio_hard_freq = 0;
  3612.  
  3613.  
  3614.   /* Remember whether the volume control will work */
  3615.   if( lpCaps->dwSupport & WAVECAPS_VOLUME )
  3616.     mms_device_volume = xaTRUE;
  3617.   else
  3618.     mms_device_volume = xaFALSE;
  3619.  
  3620.   mmeFreeMem(lpCaps);
  3621.  
  3622.   /*
  3623.   ** We don't really care what this value is - use something easy
  3624.   */
  3625.   xa_audio_hard_buff  = XA_HARD_BUFF_1K;
  3626.  
  3627.   xa_interval_id = 0;
  3628.   xa_audio_present = XA_AUDIO_OK;
  3629.  
  3630.   /* Register our callback routine to be called whenever there is work */
  3631.   XtAppAddInput(theAudContext,
  3632.         mmeServerFileDescriptor(),
  3633.         (XtPointer)XtInputReadMask,
  3634.         (XtInputCallbackProc)mmeProcessCallbacks,
  3635.         0);
  3636.  
  3637.   Init_Audio_Ring(xa_audio_ring_size,
  3638.             (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps) );
  3639. }
  3640.  
  3641. /********** MMS_Audio_Kill **********************
  3642.  *****/
  3643. void MMS_Audio_Kill()
  3644. {
  3645.   MMRESULT status;
  3646.   DEBUG_LEVEL2 fprintf(stderr,"MMS_Audio_Kill\n");
  3647.  
  3648.   MMS_Audio_Off(0);
  3649.   xa_audio_present = XA_AUDIO_UNK;
  3650.  
  3651.   status = waveOutReset(mms_device_handle);
  3652.   if( status != MMSYSERR_NOERROR ) {
  3653.       fprintf(stderr,"waveOutReset failed - status = %d\n", status);
  3654.   }
  3655.   status = waveOutClose(mms_device_handle);
  3656.   if( status != MMSYSERR_NOERROR ) {
  3657.       fprintf(stderr,"waveOutClose failed - status = %d\n", status);
  3658.   }
  3659.  
  3660.   mmeFreeBuffer(mms_audio_buffer);
  3661.   mmeFreeMem(mms_lpWaveHeader);
  3662.  
  3663.   Kill_Audio_Ring();
  3664. }
  3665.  
  3666. /********** MMS_Audio_Off **********************
  3667.  * Stop Audio Stream
  3668.  *
  3669.  *****/
  3670. void MMS_Audio_Off(flag)
  3671. xaULONG flag;
  3672. {
  3673.   DEBUG_LEVEL2 fprintf(stderr,"MMS_Audio_Off\n");
  3674.   if (xa_audio_status == XA_AUDIO_STOPPED) return;
  3675.  
  3676.   /* Just set our flag and let things drain */
  3677.   /* we could use waveOutReset if we were in a hurry */
  3678.   xa_audio_status = XA_AUDIO_STOPPED;
  3679. }
  3680.  
  3681. /********** MMS_Audio_On **********************
  3682.  * Turn On Audio Stream.
  3683.  *
  3684.  *****/
  3685. /*POD TEMP
  3686. static void MMS_wave_callback(HANDLE hWaveOut,
  3687.                   UINT wMsg,
  3688.                   DWORD dwInstance,
  3689.                   LPARAM lParam1,
  3690.                   LPARAM lParam2)
  3691. */
  3692. static void MMS_wave_callback(hWaveOut,wMsg,dwInstance,lParam1,lParam2)
  3693. HANDLE hWaveOut;
  3694. UINT wMsg;
  3695. DWORD dwInstance;
  3696. LPARAM lParam1;
  3697. LPARAM lParam2;
  3698. {
  3699.     switch(wMsg)
  3700.       {
  3701.       case WOM_OPEN:
  3702.       case WOM_CLOSE: {
  3703.           /* Ignore these */
  3704.           break;
  3705.       }
  3706.       case WOM_DONE: {
  3707.           LPWAVEHDR lpwh = (LPWAVEHDR)lParam1;
  3708.           mms_buffers_outstanding--;
  3709.           break;
  3710.       }
  3711.       default: {
  3712.           fprintf(stderr,
  3713.               "Unknown MMS waveOut callback messages receieved.\n");
  3714.           break;
  3715.       }
  3716.       }
  3717. }
  3718.  
  3719. void MMS_Audio_On()
  3720. {
  3721.   MMRESULT status;
  3722.   LPPCMWAVEFORMAT lpWaveFormat;
  3723.  
  3724.   DEBUG_LEVEL2 fprintf(stderr,"MMS_Audio_On \n");
  3725.   if (xa_audio_status == XA_AUDIO_STARTED) return;
  3726.   else if (xa_audio_present != XA_AUDIO_OK) return;
  3727.   else if (xa_snd_cur)
  3728.   {
  3729.     /* Close & Reopen device if necessary */
  3730.     if (xa_audio_hard_freq != xa_snd_cur->hfreq )
  3731.     {
  3732.     if( mms_device_handle != 0 ) {
  3733.         status = waveOutReset(mms_device_handle);
  3734.         if( status != MMSYSERR_NOERROR ) {
  3735.         fprintf(stderr,"waveOutReset failed - status = %d\n", status);
  3736.         }
  3737.         status = waveOutClose(mms_device_handle);
  3738.         if( status != MMSYSERR_NOERROR ) {
  3739.         fprintf(stderr,"waveOutClose failed - status = %d\n", status);
  3740.         }
  3741.     }
  3742.     if((lpWaveFormat = (LPPCMWAVEFORMAT)
  3743.             mmeAllocMem(sizeof(PCMWAVEFORMAT))) == NULL ) 
  3744.     {
  3745.         fprintf(stderr,"Failed to allocate PCMWAVEFORMAT struct\n");
  3746.         return;
  3747.     }
  3748.     lpWaveFormat->wf.nSamplesPerSec = xa_snd_cur->hfreq;
  3749.  
  3750.     lpWaveFormat->wf.nChannels = xa_audio_hard_chans;
  3751.     lpWaveFormat->wBitsPerSample = xa_audio_hard_bps*8/xa_audio_hard_chans;
  3752.     if( xa_audio_hard_type == XA_AUDIO_SUN_AU )
  3753.       lpWaveFormat->wf.wFormatTag = WAVE_FORMAT_MULAW;
  3754.     else if((xa_audio_hard_type & XA_AUDIO_TYPE_MASK) == XA_AUDIO_SIGNED ||
  3755.         (xa_audio_hard_type & XA_AUDIO_TYPE_MASK) == XA_AUDIO_LINEAR )
  3756.       lpWaveFormat->wf.wFormatTag = WAVE_FORMAT_PCM;
  3757.     else {
  3758.         fprintf(stderr,"Unsupported audio format\n");
  3759.         return;
  3760.     }
  3761.  
  3762.     /* The audio format to convert to has already been picked based on what
  3763.        we said the hardware capabilities were, so don't change now or we'll
  3764.        confuse everyone.  If we were going to take maximum advantage of the
  3765.        MMS & hardware capabilities, we'd do it something like this:
  3766.     */
  3767. #if 0
  3768.     if (xa_audio_hard_freq != xa_snd_cur->hfreq ||
  3769.         xa_audio_hard_type != xa_snd_cur->type );
  3770.      
  3771.     if( xa_snd_cur->type & XA_AUDIO_STEREO_MSK )
  3772.       lpWaveFormat->wf.nChannels = 2;
  3773.     else
  3774.       lpWaveFormat->wf.nChannels = 1;
  3775.     if( xa_snd_cur->type & XA_AUDIO_BPS_2_MSK )
  3776.       lpWaveFormat->wBitsPerSample = 16;
  3777.     else
  3778.       lpWaveFormat->wBitsPerSample = 8;
  3779.     if( (xa_snd_cur->type & XA_AUDIO_TYPE_MASK) == XA_AUDIO_SUN_AU )
  3780.       lpWaveFormat->wf.wFormatTag = WAVE_FORMAT_MULAW;
  3781.     else if(   (xa_snd_cur->type & XA_AUDIO_TYPE_MASK) == XA_AUDIO_SIGNED 
  3782.         || (xa_snd_cur->type & XA_AUDIO_TYPE_MASK) == XA_AUDIO_LINEAR )
  3783.       lpWaveFormat->wf.wFormatTag = WAVE_FORMAT_PCM;
  3784.     else if( (xa_snd_cur->type & XA_AUDIO_TYPE_MASK) == XA_AUDIO_ADPCM)
  3785.       lpWaveFormat->wf.wFormatTag = WAVE_FORMAT_IMA_ADPCM;
  3786.     else {
  3787.         fprintf(stderr,"Unsupported audio format\n");
  3788.         return;
  3789.     }
  3790. #endif
  3791.  
  3792.     lpWaveFormat->wf.nBlockAlign = lpWaveFormat->wf.nChannels *
  3793.                                    ((lpWaveFormat->wBitsPerSample+7)/8);
  3794.     lpWaveFormat->wf.nAvgBytesPerSec = lpWaveFormat->wf.nBlockAlign *
  3795.                         lpWaveFormat->wf.nSamplesPerSec;
  3796.  
  3797.     /* Open the audio device in the appropriate rate/format */
  3798.     mms_device_handle = 0;
  3799.     status = waveOutOpen( &mms_device_handle,
  3800.                  WAVE_MAPPER,
  3801.                  (LPWAVEFORMAT)lpWaveFormat,
  3802.                  MMS_wave_callback,
  3803.                  NULL,
  3804.                  CALLBACK_FUNCTION | WAVE_OPEN_SHAREABLE );
  3805.     if( status != MMSYSERR_NOERROR ) {
  3806.         fprintf(stderr,"waveOutOpen failed - status = %d\n", status);
  3807.     }
  3808.  
  3809.     /* Get & save the device ID for volume control */
  3810.     status = waveOutGetID( mms_device_handle, &mms_device_id );
  3811.     if( status != MMSYSERR_NOERROR ) {
  3812.         fprintf(stderr,"waveOutGetID failed - status = %d\n", status);
  3813.     }
  3814.  
  3815.     DEBUG_LEVEL2 fprintf(stderr,"Opened waveOut device #%d \n",
  3816.         mms_device_id);
  3817.     DEBUG_LEVEL2 fprintf(stderr,
  3818.                  "Format=%d, Rate=%d, channels=%d, bps=%d \n",
  3819.                  lpWaveFormat->wf.wFormatTag,
  3820.                  lpWaveFormat->wf.nSamplesPerSec,
  3821.                  lpWaveFormat->wf.nChannels,
  3822.                  lpWaveFormat->wBitsPerSample );
  3823.  
  3824.     mmeFreeMem(lpWaveFormat);
  3825.  
  3826.     /* Allocate wave header for use in write */
  3827.     if((mms_lpWaveHeader = (LPWAVEHDR)
  3828.                 mmeAllocMem(sizeof(WAVEHDR))) == NULL ) 
  3829.     {
  3830.         fprintf(stderr,"Failed to allocate WAVEHDR struct\n");
  3831.         return;
  3832.     }
  3833.  
  3834.     /* Allocate shared audio buffer for communicating with audio device */
  3835.     /* NOTE: It's just a matter of convenience that it's the same size  */
  3836.     /*    as  XAnim's audio ring buffer - don't confuse the two        */
  3837.     if ( (mms_audio_buffer = (LPSTR)
  3838.           mmeAllocBuffer(xa_audio_hard_buff*xa_audio_ring_size )) == NULL)
  3839.         {
  3840.       fprintf(stderr,"Failed to allocate shared audio buffer\n");
  3841.       return;
  3842.     }
  3843.  
  3844.     /* Save current hardware settings */
  3845.     xa_audio_hard_freq = xa_snd_cur->hfreq;
  3846.     xa_audio_hard_type = xa_snd_cur->type;
  3847.     }
  3848.  
  3849.     /* These values are all cut & paste from other devices - hope they got
  3850.        them right there! - tfm */
  3851.     xa_out_time = 100;
  3852.     xa_out_init = xa_audio_ring_size - 1;
  3853.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  3854.  
  3855.     xa_audio_status = XA_AUDIO_STARTED;
  3856.     XA_Flush_Ring();
  3857.     XA_Update_Ring(1000);
  3858.  
  3859.     /* initialize time base */
  3860.     if (xa_interval_time == 0) xa_interval_time = 1;
  3861.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  3862.     New_Merged_Audio_Output();
  3863.   }
  3864. }
  3865.  
  3866. /********** MMS_Closest_Freq **********************************************
  3867.  *
  3868.  * Global Variable Affect:
  3869.  *   xaULONG xa_audio_hard_buff        must set but not larger than
  3870.  *                    XA_AUDIO_MAX_RING_BUF size
  3871.  ****************************************************************************/
  3872. xaULONG MMS_Closest_Freq(ifreq)
  3873. xaLONG ifreq;
  3874. {
  3875.   xa_audio_hard_buff = XA_HARD_BUFF_1K;
  3876.  
  3877.   /* Query our audio devices to see what sample rates are supported */
  3878.  
  3879.   if (xa_audio_hard_type == XA_AUDIO_SIGNED_2ML)
  3880.   { static int valid[] = { 8000, 11025, 16000, 22050, 32000, 44100, 48000, 0};
  3881.     xaLONG i = 0;
  3882.     xaLONG best = valid[0];
  3883.  
  3884.     while(valid[i])
  3885.     {
  3886.       if (xaABS(valid[i] - ifreq) < xaABS(best - ifreq)) best = valid[i];
  3887.       i++;
  3888.     }
  3889.  
  3890.     return(best);
  3891.   }
  3892.   else return(8000);
  3893. }
  3894.  
  3895. /* Select the appropriate output port */
  3896.  
  3897. void MMS_Set_Output_Port(aud_ports)
  3898. xaULONG aud_ports;
  3899. {
  3900.   MMRESULT status;
  3901.   DWORD ports = 0;
  3902. /* dummy definitions to support pseudo code below - needs to be fixed - tfm */
  3903.   int device_type = 0;
  3904. #define J300 0
  3905. #define BBA 1
  3906.  
  3907.   if (aud_ports & XA_AUDIO_PORT_INT &&
  3908.       device_type == BBA )
  3909.     ports |= MME_PORTMASK_02;
  3910.   if (aud_ports & XA_AUDIO_PORT_HEAD) {
  3911.       if(device_type = BBA)
  3912.     ports |= MME_PORTMASK_02;
  3913.       if(device_type = J300)
  3914.     ports |= MME_PORTMASK_01;
  3915.   }
  3916.   if (aud_ports & XA_AUDIO_PORT_EXT &&
  3917.       device_type == J300)
  3918.     ports |= MME_PORTMASK_02;
  3919.  
  3920.   status = waveOutSelectPorts(mms_device_id,ports);
  3921.   if( status != MMSYSERR_NOERROR ) {
  3922.       fprintf(stderr,"waveOutSelectPorts failed - status = %d\n", status); }
  3923. }
  3924.  
  3925.  
  3926.  
  3927. /*************
  3928.  * flag = 0  turn speaker off
  3929.  * flag = 1  turn speaker on
  3930.  * flag = 2  toggle speaker
  3931.  */
  3932. void MMS_Speaker_Toggle(flag)
  3933. xaULONG flag;
  3934. {
  3935.   DEBUG_LEVEL2 fprintf(stderr,"MMS_Speaker_Toggle\n");
  3936. }
  3937.  
  3938. void MMS_Headphone_Toggle(flag)
  3939. xaULONG flag;
  3940. {
  3941.   DEBUG_LEVEL2 fprintf(stderr,"MMS_Headphone_Toggle\n");
  3942. }
  3943.  
  3944. /********** MMS_Adjust_Volume **********************
  3945.  * Routine for adjusting output volume
  3946.  *
  3947.  * NOTE: It isn't really a good idea to do this on a per application
  3948.  *       basis, particularly at startup where we are going to override
  3949.  *       the value the user has set up
  3950.  *     I've left this disabled for now
  3951.  *
  3952.  * POD NOTE: once xanim leaves default volume alone at startup, remember
  3953.  *           to renable this.
  3954.  *****/
  3955. void MMS_Adjust_Volume(volume)
  3956. xaULONG volume;
  3957. {
  3958.  DWORD vol;
  3959.  DEBUG_LEVEL2 fprintf(stderr,"MMS_Audio_Volume %d\n",volume);
  3960.  
  3961.  vol = (0xFFFF * volume) / 100;    /* convert to 16 bit scale */
  3962.  vol = (vol << 16) | vol;    /* duplicate for left & right channels */
  3963.  
  3964. #ifdef MMS_VOL
  3965.  waveOutSetVolume(mms_device_id, vol);
  3966. #endif
  3967.  
  3968. }
  3969.  
  3970. #endif
  3971. /****************************************************************************/
  3972. /************************* END OF MMS SPECIFIC ROUTINES *********************/
  3973. /****************************************************************************/
  3974.  
  3975. /****************************************************************************/
  3976. /**************** NAS SPECIFIC ROUTINES *************************************/
  3977. /****************************************************************************/
  3978. #ifdef XA_NAS_AUDIO
  3979.  
  3980. /*
  3981.  * NAS port provided by Bob Phillips,
  3982.  *    bobp@syl.nj.nec.com
  3983.  * Adapted from AF port by Tom Levergood
  3984.  * Wednesday October 26, 1994
  3985.  *
  3986.  * Re-written by Greg Renda (greg@ncd.com) 5/10/95
  3987.  */
  3988.   
  3989. static void        NAS_Audio_Init();
  3990. static void        NAS_Audio_Kill();
  3991. static void        NAS_Audio_Off();
  3992. static void        NAS_Audio_On();
  3993. static void        NAS_Adjust_Volume();
  3994. static xaULONG        NAS_Closest_Freq();
  3995. static void        NAS_Speaker_Toggle();
  3996. static void        NAS_Headphone_Toggle();
  3997.  
  3998. static xaULONG        NAS_pod_flag = 0;
  3999.  
  4000. typedef struct _NASChunk
  4001. {
  4002.     xaUBYTE          *buf;
  4003.     xaULONG           len,
  4004.                     offset;
  4005.     struct _NASChunk *next;
  4006. }               NASChunk, *NASChunkPtr;
  4007.  
  4008. typedef struct
  4009. {
  4010.     AuServer       *aud;
  4011.     AuFlowID        flow;
  4012.     AuDeviceID      device;
  4013.     NASChunkPtr     head,
  4014.                     tail;
  4015.     xaULONG           bytes;
  4016.     AuDeviceAttributes *da;
  4017.     AuEventHandlerRec *handler;
  4018.     AuBool flowRunning;
  4019. }               NASInfo, *NASInfoPtr;
  4020.  
  4021. static NASInfo  nas;
  4022.  
  4023. static AuBool
  4024. NAS_Event_Handler(aud, ev, handler)
  4025. AuServer       *aud;
  4026. AuEvent        *ev;
  4027. AuEventHandlerRec *handler;
  4028. {
  4029.     NASInfoPtr      np = (NASInfoPtr) handler->data;
  4030.  
  4031.     switch (ev->type)
  4032.     {
  4033.     case AuEventTypeElementNotify:
  4034.         {
  4035.         AuElementNotifyEvent *event = (AuElementNotifyEvent *) ev;
  4036.  
  4037.         switch (event->kind)
  4038.         {
  4039.             case AuElementNotifyKindLowWater:
  4040.             np->bytes += event->num_bytes;
  4041.             break;
  4042.             case AuElementNotifyKindState:
  4043.             switch (event->cur_state)
  4044.             {
  4045.                 case AuStatePause:
  4046.                 if (event->reason != AuReasonUser)
  4047.                     np->bytes += event->num_bytes;
  4048.                 break;
  4049.                 case AuStateStop:
  4050.                 np->flowRunning = AuFalse;
  4051.                 break;
  4052.             }
  4053.         }
  4054.         }
  4055.     }
  4056.  
  4057.     return AuTrue;
  4058. }
  4059.  
  4060. static void
  4061. NAS_Audio_Init()
  4062. {
  4063.     char           *errmsg;
  4064.     int             i;
  4065.  
  4066.     DEBUG_LEVEL2    fprintf(stdout, "NAS_Audio_Init\n");
  4067.  
  4068.     if (xa_audio_present != XA_AUDIO_UNK)
  4069.     return;
  4070.  
  4071.     /* Open connection. */
  4072.     if (!(nas.aud = AuOpenServer(NULL, 0, NULL, 0, NULL, &errmsg)))
  4073.     {
  4074.     fprintf(stderr, "Could not open connection to NAS audio server.\n");
  4075.     fprintf(stderr, "Error is \"%s\".\n", errmsg);
  4076.     fprintf(stderr, "Disabling audio service.\n");
  4077.     /*
  4078.      * As long as xa_audio_present isn't OK, audio is effectively
  4079.      * disabled
  4080.      */
  4081.     /* but might as well really disable it */
  4082.     AuFree(errmsg);
  4083.     XA_Null_Audio_Setup();
  4084.     xa_audio_present = XA_AUDIO_UNK;
  4085.     return;
  4086.     }
  4087.  
  4088.     /* look for an output device */
  4089.     for (i = 0; i < AuServerNumDevices(nas.aud); i++)
  4090.     if ((AuDeviceKind(AuServerDevice(nas.aud, i)) ==
  4091.          AuComponentKindPhysicalOutput) &&
  4092.         AuDeviceNumTracks(AuServerDevice(nas.aud, i)) == 1)
  4093.     {
  4094.         nas.device = AuDeviceIdentifier(AuServerDevice(nas.aud, i));
  4095.         nas.da = AuServerDevice(nas.aud, i);
  4096.         break;
  4097.     }
  4098.  
  4099.     if (i == AuServerNumDevices(nas.aud))
  4100.     {
  4101.     fprintf(stderr, "NAS: Couldn't find an appropriate output device\n");
  4102.     XA_Null_Audio_Setup();
  4103.     xa_audio_present = XA_AUDIO_UNK;
  4104.     return;
  4105.     }
  4106.  
  4107.     if (!(nas.flow = AuCreateFlow(nas.aud, NULL)))
  4108.     {
  4109.     fprintf(stderr, "NAS: Couldn't create flow\n");
  4110.     XA_Null_Audio_Setup();
  4111.     xa_audio_present = XA_AUDIO_UNK;
  4112.     return;
  4113.     }
  4114.  
  4115.     nas.handler = AuRegisterEventHandler(nas.aud, AuEventHandlerIDMask, 0,
  4116.                      nas.flow, NAS_Event_Handler,
  4117.                      (AuPointer) &nas);
  4118.  
  4119.     xa_audio_present = XA_AUDIO_OK;
  4120.     xa_audio_hard_type = XA_AUDIO_SIGNED_2MB;
  4121.     xa_audio_hard_bps = 2;
  4122.     xa_audio_hard_chans = 1;
  4123.     NAS_pod_flag = 0;
  4124.     Init_Audio_Ring(xa_audio_ring_size,
  4125.             (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps));
  4126. }
  4127.  
  4128. static void
  4129. NAS_Audio_Kill()
  4130. {
  4131.     DEBUG_LEVEL2    fprintf(stdout, "NAS_Audio_Kill\n");
  4132.  
  4133.     NAS_Audio_Off(0);
  4134.     xa_audio_present = XA_AUDIO_UNK;
  4135.  
  4136.     AuUnregisterEventHandler(nas.aud, nas.handler);
  4137.     AuCloseServer(nas.aud);
  4138.  
  4139.     Kill_Audio_Ring();
  4140. }
  4141.  
  4142.  
  4143. static void
  4144. NAS_Audio_Off(flag)
  4145. xaULONG           flag;
  4146. {
  4147.     NASChunkPtr     p = nas.head,
  4148.                     next;
  4149.  
  4150.     if (NAS_pod_flag) return; NAS_pod_flag = 1; /* POD TEST */
  4151.  
  4152.     DEBUG_LEVEL2    fprintf(stdout, "NAS_Audio_Off\n");
  4153.  
  4154.     if (!nas.flowRunning && xa_audio_status != XA_AUDIO_STARTED)
  4155.     return;
  4156. /* POD new */
  4157.     xa_audio_status = XA_AUDIO_STOPPED;
  4158.  
  4159.     AuStopFlow(nas.aud, nas.flow, NULL);
  4160.  
  4161.     while (nas.flowRunning == AuTrue) AuHandleEvents(nas.aud);
  4162.  
  4163.     while (p)
  4164.     {
  4165.     next = p->next;
  4166.     free(p->buf);
  4167.     free(p);
  4168.     p = next;
  4169.     }
  4170.  
  4171.     nas.head = nas.tail = NULL;
  4172.  
  4173.     /* SET FLAG TO STOP OUTPUT ROUTINE */
  4174. /* POD Was
  4175.     xa_audio_status = XA_AUDIO_STOPPED;
  4176. */
  4177.  
  4178.     xa_time_audio = -1;
  4179.     xa_audio_flushed = 0;
  4180.  
  4181.     NAS_pod_flag = 0; /* POD TEST */
  4182. }
  4183.  
  4184. static void
  4185. NAS_Audio_On()
  4186. {
  4187.     if (NAS_pod_flag) return; NAS_pod_flag = 1; /* POD TEST */
  4188.  
  4189.     DEBUG_LEVEL2    fprintf(stdout, "NAS_Audio_On \n");
  4190.  
  4191.     if ( (xa_audio_status == XA_AUDIO_STARTED) ||
  4192.      (xa_audio_present != XA_AUDIO_OK) || (!xa_snd_cur) )
  4193.     return;
  4194.  
  4195.     if (nas.flowRunning == AuTrue) NAS_Audio_Off(0);
  4196.  
  4197. #define NASBufSize 30000
  4198.     /* Change Frequency If necessary */
  4199.     if (xa_audio_hard_freq != xa_snd_cur->hfreq)
  4200.     {
  4201.     AuElement       elements[3];
  4202.  
  4203.     AuMakeElementImportClient(&elements[0], xa_snd_cur->hfreq,
  4204.                   AuFormatLinearSigned16MSB,
  4205.                   1, AuTrue, NASBufSize,
  4206.                   NASBufSize / 4 * 3, 0, NULL);
  4207.     AuMakeElementMultiplyConstant(&elements[1], 0,
  4208.                       AuFixedPointFromFraction(100, 100));
  4209.     AuMakeElementExportDevice(&elements[2], 1, nas.device,
  4210.                   xa_snd_cur->hfreq, AuUnlimitedSamples,
  4211.                   0, NULL);
  4212.  
  4213.     AuSetElements(nas.aud, nas.flow, AuTrue, 3, elements, NULL);
  4214.  
  4215.     xa_audio_hard_freq = xa_snd_cur->hfreq;
  4216.     }
  4217.  
  4218.     nas.bytes = 0;
  4219.     AuStartFlow(nas.aud, nas.flow, NULL);
  4220.     nas.flowRunning = AuTrue;
  4221.  
  4222.     /* xa_snd_cur gets changes in Update_Ring() */
  4223.     /* FINE TUNED from 4 to 20 */
  4224.     xa_out_time = 250;                   /* keep audio fed XXms ahead
  4225.                             * of video - could be 500 */
  4226.     xa_out_init = xa_audio_ring_size - 1;
  4227.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  4228.  
  4229.     xa_audio_status = XA_AUDIO_STARTED;
  4230.     XA_Flush_Ring();
  4231.     XA_Update_Ring(1000);
  4232.  
  4233.     if (xa_interval_time == 0)
  4234.     xa_interval_time = 1;
  4235.     xa_time_now = XA_Read_AV_Time();           /* get new time */
  4236.     New_Merged_Audio_Output();
  4237.     NAS_pod_flag = 0; /* POD TEST */
  4238. }
  4239.  
  4240. static void
  4241. NAS_Toggle_OutputMode(flag, mode)
  4242. xaULONG flag, mode;
  4243. {
  4244.     if (!(AuDeviceChangableMask(nas.da) & AuCompDeviceOutputModeMask))
  4245.     return;
  4246.  
  4247.     switch(flag)
  4248.     {
  4249.     case 0:
  4250.         AuDeviceOutputMode(nas.da) &= ~mode;
  4251.         break;
  4252.     case 1:
  4253.         AuDeviceOutputMode(nas.da) |= mode;
  4254.         break;
  4255.       case 2:
  4256.         AuDeviceOutputMode(nas.da) ^= mode;
  4257.         break;
  4258.     }
  4259.  
  4260.     AuSetDeviceAttributes(nas.aud, AuDeviceIdentifier(nas.da),
  4261.               AuCompDeviceOutputModeMask, nas.da, NULL);
  4262.     AuFlush(nas.aud);
  4263. }
  4264.  
  4265. /*************
  4266.  * flag = 0  turn speaker off
  4267.  * flag = 1  turn speaker on
  4268.  * flag = 2  toggle speaker
  4269.  */
  4270. static void
  4271. NAS_Speaker_Toggle(flag)
  4272. xaULONG           flag;
  4273. {
  4274.     DEBUG_LEVEL2    fprintf(stdout, "NAS_Speaker_Toggle\n");
  4275.     NAS_Toggle_OutputMode(flag, AuDeviceOutputModeSpeaker);
  4276. }
  4277.  
  4278. static void
  4279. NAS_Headphone_Toggle(flag)
  4280. xaULONG           flag;
  4281. {
  4282.     DEBUG_LEVEL2    fprintf(stdout, "NAS_Headphone_Toggle\n");
  4283.     NAS_Toggle_OutputMode(flag, AuDeviceOutputModeHeadphone);
  4284. }
  4285.  
  4286.  
  4287. /********** NAS_Adjust_Volume **********************
  4288.  * Routine for Adjusting Volume on NAS
  4289.  *
  4290.  *****/
  4291. static void
  4292. NAS_Adjust_Volume(volume)
  4293. xaULONG           volume;
  4294. {
  4295.     AuElementParameters parms;
  4296.  
  4297.     DEBUG_LEVEL2    fprintf(stdout, "NAS_Audio_Volume %d\n", volume);
  4298.     parms.flow = nas.flow;
  4299.     parms.element_num = 1;
  4300.     parms.num_parameters = AuParmsMultiplyConstant;
  4301.     parms.parameters[AuParmsMultiplyConstantConstant] =
  4302.     AuFixedPointFromFraction(volume, 100);
  4303.     AuSetElementParameters(nas.aud, 1, &parms, NULL);
  4304.     AuFlush(nas.aud);
  4305. }
  4306.  
  4307. /********** NAS_Closest_Freq **********************
  4308.  *
  4309.  * Global Variable Affect:
  4310.  *   xaULONG xa_audio_hard_buff        must set but not larger than
  4311.  *                    XA_AUDIO_MAX_RING_BUF size
  4312.  */
  4313. static xaULONG
  4314. NAS_Closest_Freq(ifreq)
  4315. xaLONG            ifreq;
  4316. {
  4317.     xa_audio_hard_buff = XA_AUDIO_MAX_RING_BUFF;
  4318.     return ifreq;
  4319. }
  4320.  
  4321. static void
  4322. NAS_Write_Data(buf, len)
  4323. xaUBYTE          *buf;
  4324. xaULONG           len;
  4325. {
  4326.     NASChunkPtr     p;
  4327.  
  4328.     if (!(p = (NASChunkPtr) malloc(sizeof(NASChunk))))
  4329.     return;
  4330.  
  4331.     if (!(p->buf = (xaUBYTE *) malloc(len)))
  4332.     {
  4333.     free(p);
  4334.     return;
  4335.     }
  4336.  
  4337.     memcpy((char *) p->buf, (char *) buf, (int) len);
  4338.     p->len = len;
  4339.     p->offset = 0;
  4340.     p->next = NULL;
  4341.  
  4342.     if (nas.tail)
  4343.     {
  4344.     nas.tail->next = p;
  4345.     nas.tail = p;
  4346.     }
  4347.     else
  4348.     nas.head = nas.tail = p;
  4349.  
  4350.     AuHandleEvents(nas.aud);
  4351.  
  4352.     while (nas.head && nas.bytes && (xa_audio_status == XA_AUDIO_STARTED) )
  4353.     {
  4354.     int             n = xaMIN(nas.bytes, nas.head->len);
  4355.     AuWriteElement(nas.aud, nas.flow, 0, n,
  4356.                nas.head->buf + nas.head->offset, AuFalse, NULL);
  4357.  
  4358.     nas.bytes -= n;
  4359.     nas.head->len -= n;
  4360.     nas.head->offset += n;
  4361.  
  4362.     if (!nas.head->len)
  4363.     {
  4364.         NASChunkPtr     next = nas.head->next;
  4365.  
  4366.         free(nas.head->buf);
  4367.         free(nas.head);
  4368.  
  4369.         if (!(nas.head = next))
  4370.         nas.tail = nas.head;
  4371.     }
  4372.  
  4373.     AuHandleEvents(nas.aud);
  4374.     }
  4375. }
  4376.  
  4377. void
  4378. XA_Audio_Setup()
  4379. {
  4380.     DEBUG_LEVEL2    fprintf(stdout, "XA_Audio_Setup()\n");
  4381.     XA_Audio_Init = NAS_Audio_Init;
  4382.     XA_Audio_Kill = NAS_Audio_Kill;
  4383.     XA_Audio_Off = NAS_Audio_Off;
  4384.     XA_Audio_On = NAS_Audio_On;
  4385.     XA_Closest_Freq = NAS_Closest_Freq;
  4386.     XA_Set_Output_Port = (void *) (0);
  4387.     XA_Speaker_Tog = NAS_Speaker_Toggle;
  4388.     XA_Headphone_Tog = NAS_Headphone_Toggle;
  4389.     XA_LineOut_Tog = NAS_Headphone_Toggle;
  4390.     XA_Adjust_Volume = NAS_Adjust_Volume;
  4391.  
  4392.     xa_snd_cur = 0;
  4393.     xa_audio_present = XA_AUDIO_UNK;
  4394.     xa_audio_status = XA_AUDIO_STOPPED;
  4395.     xa_audio_ring_size = 8;
  4396. }
  4397.  
  4398. #endif
  4399. /****************************************************************************/
  4400. /******************* END OF NAS SPECIFIC ROUTINES ***************************/
  4401. /****************************************************************************/
  4402.  
  4403.  
  4404. /****************************************************************************/
  4405. /**************** NetBSD SPECIFIC ROUTINES **********************************/
  4406. /****************************************************************************/
  4407.  
  4408. /*
  4409.  * NetBSD port provided by Roland C Dowdeswell
  4410.  * roland@imrryr.org
  4411.  * Heavily stolen from the Sparc port (like the others)
  4412.  * Tuesday 9/May 1995 -- very early -- still dark.
  4413.  */
  4414.  
  4415. #ifdef XA_NetBSD_AUDIO
  4416.  
  4417. void  NetBSD_Audio_Init();
  4418. void  NetBSD_Audio_Kill();
  4419. void  NetBSD_Audio_Off();
  4420. void  NetBSD_Audio_On();
  4421. void  NetBSD_Adjust_Volume();
  4422. xaULONG NetBSD_Closest_Freq();
  4423. void NetBSD_Set_Output_Port();
  4424. void NetBSD_Speaker_Toggle();
  4425. void NetBSD_Headphone_Toggle();
  4426.  
  4427. #define NetBSD_MAX_VOL AUDIO_MAX_GAIN
  4428. #define NetBSD_MIN_VOL AUDIO_MIN_GAIN
  4429.  
  4430. static int devAudio;
  4431.  
  4432. /********** XA_Audio_Setup **********************
  4433.  * 
  4434.  * Also defines NetBSD Specific variables.
  4435.  *
  4436.  *****/
  4437. void XA_Audio_Setup()
  4438. {
  4439.   XA_Audio_Init        = NetBSD_Audio_Init;
  4440.   XA_Audio_Kill        = NetBSD_Audio_Kill;
  4441.   XA_Audio_Off        = NetBSD_Audio_Off;
  4442.   XA_Audio_On        = NetBSD_Audio_On;
  4443.   XA_Closest_Freq    = NetBSD_Closest_Freq;
  4444.   XA_Set_Output_Port    = NetBSD_Set_Output_Port;
  4445.   XA_Speaker_Tog    = NetBSD_Speaker_Toggle;
  4446.   XA_Headphone_Tog    = NetBSD_Headphone_Toggle;
  4447.   XA_LineOut_Tog    = NetBSD_Headphone_Toggle;
  4448.   XA_Adjust_Volume    = NetBSD_Adjust_Volume;
  4449.  
  4450.   xa_snd_cur = 0;
  4451.   xa_audio_present = XA_AUDIO_UNK;
  4452.   xa_audio_status  = XA_AUDIO_STOPPED;
  4453.   xa_audio_ring_size  = 8;
  4454. }
  4455.  
  4456.  
  4457. /********** NetBSD_Audio_Init **********************
  4458.  * Open /dev/audio and NetBSD.
  4459.  *
  4460.  *****/
  4461. void NetBSD_Audio_Init()
  4462. { int ret;
  4463.   int type;
  4464.   audio_info_t a_info;
  4465.   DEBUG_LEVEL2 fprintf(stderr,"NetBSD_Audio_Init\n");
  4466.   if (xa_audio_present != XA_AUDIO_UNK) return;
  4467.   devAudio = open("/dev/audio", O_WRONLY | O_NDELAY);
  4468.   if (devAudio == -1)
  4469.   {
  4470.     if (errno == EBUSY) fprintf(stderr,"Audio_Init: Audio device is busy. - ");
  4471.     else fprintf(stderr,"Audio_Init: Error opening audio device. - ");
  4472.     fprintf(stderr,"Will continue without audio\n");
  4473.     xa_audio_present = XA_AUDIO_ERR;
  4474.     return;
  4475.   }
  4476.  
  4477.   DEBUG_LEVEL1 fprintf(stderr,"NetBSD AUDIO\n");
  4478.  
  4479.   AUDIO_INITINFO(&a_info);
  4480.   a_info.blocksize = 1024;
  4481.   ioctl(devAudio, AUDIO_SETINFO, &a_info);
  4482.   AUDIO_INITINFO(&a_info);
  4483.   a_info.play.encoding = AUDIO_ENCODING_PCM16;
  4484.   ioctl(devAudio, AUDIO_SETINFO, &a_info);
  4485.   AUDIO_INITINFO(&a_info);
  4486.   a_info.mode = AUMODE_PLAY | AUMODE_PLAY_ALL;
  4487.   ioctl(devAudio, AUDIO_SETINFO, &a_info);
  4488.   AUDIO_INITINFO(&a_info);
  4489.   a_info.play.precision = 16;
  4490.   ioctl(devAudio, AUDIO_SETINFO, &a_info);
  4491.   AUDIO_INITINFO(&a_info);
  4492.   a_info.play.sample_rate = 11025;
  4493.   ioctl(devAudio, AUDIO_SETINFO, &a_info);
  4494.   ioctl(devAudio, AUDIO_GETINFO, &a_info);
  4495.  
  4496.   xa_audio_hard_type  = (a_info.play.precision==8)?XA_AUDIO_LINEAR_1M
  4497.                           :XA_AUDIO_SIGNED_2ML;
  4498.   xa_audio_hard_freq  = a_info.play.sample_rate;
  4499.   xa_audio_hard_buff  = a_info.blocksize;
  4500.   xa_audio_hard_bps   = (a_info.play.precision==8)?1:2;
  4501.   xa_audio_hard_chans = 1;
  4502.   Gen_Ulaw_2_Signed();
  4503.   Gen_Signed_2_Ulaw();
  4504.  
  4505.   xa_interval_id = 0;
  4506.   xa_audio_present = XA_AUDIO_OK;
  4507.   DEBUG_LEVEL2 fprintf(stderr,"   success \n");
  4508.   Init_Audio_Ring(xa_audio_ring_size,
  4509.             (XA_AUDIO_MAX_RING_BUFF * xa_audio_hard_bps) );
  4510. }
  4511.  
  4512. /********** NetBSD_Audio_Kill **********************
  4513.  * Close /dev/audio.
  4514.  *
  4515.  *****/
  4516. void NetBSD_Audio_Kill()
  4517. { 
  4518.   /* TURN AUDIO OFF */
  4519.   NetBSD_Audio_Off(0);
  4520.   xa_audio_present = XA_AUDIO_UNK;
  4521.   /* SHUT THINGS DOWN  */
  4522.   close(devAudio);
  4523.   Kill_Audio_Ring();
  4524. }
  4525.  
  4526. /********** NetBSD_Audio_Off **********************
  4527.  * Stop Audio Stream
  4528.  *
  4529.  *****/
  4530. void NetBSD_Audio_Off(flag)
  4531. xaULONG flag;
  4532. { /* long ret; */
  4533.  
  4534.   DEBUG_LEVEL1 fprintf(stderr,"NetBSD_Audio_Off\n");
  4535.   if (xa_audio_status != XA_AUDIO_STARTED) return;
  4536.  
  4537.   /* SET FLAG TO STOP OUTPUT ROUTINE */
  4538.   xa_audio_status = XA_AUDIO_STOPPED;
  4539.  
  4540.   /* TURN OFF SOUND ??? */
  4541.   NetBSD_Adjust_Volume(XA_AUDIO_MINVOL);
  4542.  
  4543.   /* FLUSH AUDIO DEVICE */ /* NOT! */
  4544. /*
  4545.   ret = ioctl(devAudio, AUDIO_FLUSH, NULL);
  4546.   if (ret == -1) fprintf(stderr,"NetBSD Audio: off flush err %d\n",errno);
  4547. */
  4548.  
  4549.   xa_time_audio = -1;
  4550.   xa_audio_flushed = 0;
  4551.  
  4552.   /* FLUSH AUDIO DEVICE AGAIN */ /* NOT! */
  4553. /*
  4554.   ret = ioctl(devAudio, AUDIO_FLUSH, NULL);
  4555.   if (ret == -1) fprintf(stderr,"NetBSD Audio: off flush err %d\n",errno);
  4556. */
  4557.  
  4558.   /* RESTORE ORIGINAL VOLUME */
  4559.   if (XAAUD->mute != xaTRUE) NetBSD_Adjust_Volume(XAAUD->volume);
  4560. }
  4561.  
  4562. /********** NetBSD_Audio_On **********************
  4563.  * Turn On Audio Stream.
  4564.  *
  4565.  *****/
  4566. void NetBSD_Audio_On()
  4567. {
  4568.   DEBUG_LEVEL2 
  4569.   {
  4570.     fprintf(stderr,"NetBSD_Audio_On \n");
  4571.   }
  4572.   if (xa_audio_status == XA_AUDIO_STARTED) return;
  4573.   else if (xa_audio_present != XA_AUDIO_OK) return;
  4574.  
  4575.   else if (xa_snd_cur)
  4576.   { int ret;
  4577.  
  4578.     /* CHANGE FREQUENCY IF NEEDED */
  4579.     if (xa_audio_hard_freq != xa_snd_cur->hfreq)
  4580.     { audio_info_t a_info;
  4581.       AUDIO_INITINFO(&a_info);
  4582.       a_info.play.sample_rate = xa_snd_cur->hfreq;
  4583.       ret = ioctl(devAudio, AUDIO_SETINFO, &a_info);
  4584.       if (ret == -1) fprintf(stderr,"audio setfreq: freq %x errno %d\n",
  4585.                         xa_snd_cur->hfreq, errno);
  4586.       xa_audio_hard_freq = xa_snd_cur->hfreq;
  4587.     }
  4588.  
  4589.     /* xa_snd_cur gets changes in Update_Ring() */
  4590.     xa_out_time = 100;  /* keep audio fed 500ms ahead of video */  /* was 500, changed it to 100 - rcd */
  4591.     xa_out_init = xa_audio_ring_size - 1;
  4592.     xa_interval_time = xa_snd_cur->ch_time / XAAUD->divtest;
  4593.  
  4594. DEBUG_LEVEL1 fprintf(stderr,"ch_time %d out_time %d int time %d \n",xa_snd_cur->ch_time,xa_out_time,xa_interval_time);
  4595.  
  4596.     xa_audio_status = XA_AUDIO_STARTED;
  4597.     XA_Flush_Ring();
  4598.     XA_Update_Ring(1000);
  4599.  
  4600.     if (xa_interval_time == 0) xa_interval_time = 1;
  4601.     xa_time_now = XA_Read_AV_Time();  /* get new time */
  4602.     New_Merged_Audio_Output();
  4603.   }
  4604. }
  4605.  
  4606.  
  4607. /********** NetBSD_Closest_Freq **********************************************
  4608.  *
  4609.  * Global Variable Affect:
  4610.  *   xaULONG xa_audio_hard_buff        must set but not larger than
  4611.  *                    XA_AUDIO_MAX_RING_BUF size
  4612.  ****************************************************************************/
  4613. xaULONG NetBSD_Closest_Freq(ifreq)
  4614. xaLONG ifreq;
  4615. { audio_info_t a_info;
  4616.  
  4617.   AUDIO_INITINFO(&a_info);
  4618.   a_info.play.sample_rate = ifreq;
  4619.   ioctl(devAudio, AUDIO_SETINFO, &a_info);
  4620.  
  4621.   ioctl(devAudio, AUDIO_GETINFO, &a_info);
  4622.  
  4623.   xa_audio_hard_buff  = a_info.blocksize;
  4624.   return (a_info.play.sample_rate);
  4625. }
  4626.  
  4627.  
  4628. /* Eventually merge everything to one */
  4629. void NetBSD_Set_Output_Port(aud_ports)
  4630. xaULONG aud_ports;
  4631. {
  4632. /* Commented out for now ;-) */
  4633. /*
  4634. audio_info_t a_info;
  4635.   xaLONG ret;
  4636.   xaULONG NetBSD_ports = 0;
  4637.   if (aud_ports & XA_AUDIO_PORT_INT)  NetBSD_ports |= AUDIO_SPEAKER;
  4638.   if (aud_ports & XA_AUDIO_PORT_HEAD) NetBSD_ports |= AUDIO_HEADPHONE;
  4639.   if (aud_ports & XA_AUDIO_PORT_EXT)  NetBSD_ports |= AUDIO_LINE_OUT;
  4640.   AUDIO_INITINFO(&a_info);
  4641.   a_info.play.port = NetBSD_ports;
  4642.   ret = ioctl(devAudio, AUDIO_SETINFO, &a_info);
  4643.   if (ret < 0) fprintf(stderr,"Audio: couldn't set speaker port %d\n",errno);
  4644. */
  4645. }
  4646.  
  4647. /************* NetBSD_Speaker_Toggle *****************************************
  4648.  *
  4649.  * flag = 0  turn speaker off
  4650.  * flag = 1  turn speaker on
  4651.  * flag = 2  toggle speaker
  4652.  ****************************************************************************/
  4653. void NetBSD_Speaker_Toggle(flag)
  4654. xaULONG flag;
  4655. { 
  4656.   switch(flag)
  4657.   {
  4658.     case  0: XAAUD->port &= ~XA_AUDIO_PORT_INT; break;
  4659.     case  1: XAAUD->port |=  XA_AUDIO_PORT_INT; break;
  4660.     default:  /* mutually exclusive set for now - never turn off */
  4661.     { if ( !(XAAUD->port & XA_AUDIO_PORT_INT)) 
  4662.         XAAUD->port = XA_AUDIO_PORT_INT;
  4663.     }
  4664.   }
  4665.   NetBSD_Set_Output_Port(XAAUD->port);
  4666. }
  4667.  
  4668. /************* NetBSD_Headphone_Toggle *****************************************
  4669.  *
  4670.  * flag = 0  turn headphones off
  4671.  * flag = 1  turn headphones on
  4672.  * flag = 2  toggle headphones
  4673.  ****************************************************************************/
  4674. void NetBSD_Headphone_Toggle(flag)
  4675. xaULONG flag;
  4676. { 
  4677.   switch(flag)
  4678.   {
  4679.     case  0: XAAUD->port &= ~XA_AUDIO_PORT_HEAD; break;
  4680.     case  1: XAAUD->port |=  XA_AUDIO_PORT_HEAD; break;
  4681.     default:  /* mutually exclusive set for now - never turn off */
  4682.     { if ( !(XAAUD->port & XA_AUDIO_PORT_HEAD)) 
  4683.         XAAUD->port = XA_AUDIO_PORT_HEAD;
  4684.     }
  4685.   }
  4686.   NetBSD_Set_Output_Port(XAAUD->port);
  4687. }
  4688.  
  4689.  
  4690. /********** NetBSD_Adjust_Volume **********************
  4691.  * Routine for Adjusting Volume on NetBSD
  4692.  *
  4693.  * Volume is in the range [0,XA_AUDIO_MAXVOL]
  4694.  ****************************************************************************/
  4695. void NetBSD_Adjust_Volume(volume)
  4696. xaULONG volume;
  4697. { audio_info_t a_info;
  4698.  
  4699.   AUDIO_INITINFO(&a_info);
  4700.   a_info.play.gain = NetBSD_MIN_VOL +
  4701.     ((volume * (NetBSD_MAX_VOL - NetBSD_MIN_VOL)) / XA_AUDIO_MAXVOL);
  4702.   if (a_info.play.gain > NetBSD_MAX_VOL) a_info.play.gain = NetBSD_MAX_VOL;
  4703.   ioctl(devAudio, AUDIO_SETINFO, &a_info);
  4704.  
  4705. }
  4706. #endif
  4707. /****************************************************************************/
  4708. /****************************************************************************/
  4709. /******************* END OF NetBSD SPECIFIC ROUTINES ************************/
  4710. /****************************************************************************/
  4711.  
  4712.  
  4713.  
  4714. XA_SND *XA_Audio_Next_Snd(snd_hdr)
  4715. XA_SND *snd_hdr;
  4716. { DEBUG_LEVEL2 fprintf(stderr,"XA_Audio_Next_Snd: snd_hdr %x \n",
  4717.                             (xaULONG)snd_hdr);
  4718.   xa_snd_cur = snd_hdr->next;
  4719.   /* brief clean up of old header */
  4720.   snd_hdr->inc_cnt = 0;
  4721.   snd_hdr->byte_cnt = 0;
  4722.   snd_hdr->samp_cnt = snd_hdr->tot_samps;
  4723.   if (snd_hdr->fpos >= 0) snd_hdr->snd = 0;
  4724.   if (xa_snd_cur==0) return(0);
  4725.   /* full init of new header */
  4726.   XA_Audio_Init_Snd(xa_snd_cur);
  4727.   /* read in info from file if necessary */
  4728.   if (xa_snd_cur->fpos >= 0)
  4729.   { xa_snd_cur->snd = xa_audcodec_buf;
  4730.     XA_Read_Audio_Delta(xa_aud_fd,xa_snd_cur->fpos,
  4731.                 xa_snd_cur->tot_bytes,xa_audcodec_buf);
  4732.   }
  4733.   return(xa_snd_cur);
  4734. }
  4735.  
  4736. void XA_Read_Audio_Delta(fd,fpos,fsize,buf)
  4737. int fd;
  4738. xaLONG fpos;
  4739. xaULONG fsize;
  4740. char *buf;
  4741. { int ret;
  4742.   ret  = lseek(fd,fpos,SEEK_SET);
  4743.   if (ret != fpos) TheEnd1("XA_Read_Audio_Delta:seek err");
  4744.   ret = read(fd, buf, fsize);
  4745.   if (ret != fsize) TheEnd1("XA_Read_Audio_Delta:read err");
  4746. }
  4747.  
  4748.  
  4749.  
  4750. /*************
  4751.  *  May not be needed
  4752.  *
  4753.  *****/
  4754. xaUBYTE XA_Signed_To_Ulaw(ch)
  4755. xaLONG ch;
  4756. {
  4757.   xaLONG mask;
  4758.   if (ch < 0) { ch = -ch; mask = 0x7f; }
  4759.   else { mask = 0xff; }
  4760.   if (ch < 32)        { ch = 0xF0 | (15 - (ch / 2)); }
  4761.   else if (ch < 96)    { ch = 0xE0 | (15 - (ch - 32) / 4); }
  4762.   else if (ch < 224)    { ch = 0xD0 | (15 - (ch - 96) / 8); }
  4763.   else if (ch < 480)    { ch = 0xC0 | (15 - (ch - 224) / 16); }
  4764.   else if (ch < 992)    { ch = 0xB0 | (15 - (ch - 480) / 32); }
  4765.   else if (ch < 2016)    { ch = 0xA0 | (15 - (ch - 992) / 64); }
  4766.   else if (ch < 4064)    { ch = 0x90 | (15 - (ch - 2016) / 128); }
  4767.   else if (ch < 8160)    { ch = 0x80 | (15 - (ch - 4064) /  256); }
  4768.   else            { ch = 0x80; }
  4769.   return (mask & ch);
  4770. }
  4771.  
  4772. void Gen_Signed_2_Ulaw()
  4773. {
  4774.   xaULONG i;
  4775.   for(i=0;i<256;i++)
  4776.   { xaUBYTE d;
  4777.     xaBYTE ch = i;
  4778.     xaLONG chr = ch;
  4779.     d = XA_Signed_To_Ulaw(chr * 16);
  4780.     xa_sign_2_ulaw[i] = d;
  4781.   }
  4782. }
  4783.  
  4784.  
  4785. /*
  4786. ** This routine converts from ulaw to 16 bit linear.
  4787. **
  4788. ** Craig Reese: IDA/Supercomputing Research Center
  4789. ** 29 September 1989
  4790. **
  4791. ** References:
  4792. ** 1) CCITT Recommendation G.711  (very difficult to follow)
  4793. ** 2) MIL-STD-188-113,"Interoperability and Performance Standards
  4794. **     for Analog-to_Digital Conversion Techniques,"
  4795. **     17 February 1987
  4796. **
  4797. ** Input: 8 bit ulaw sample
  4798. ** Output: signed 16 bit linear sample
  4799. */
  4800.  
  4801. xaLONG XA_Ulaw_to_Signed( ulawbyte )
  4802. xaUBYTE ulawbyte;
  4803. {
  4804.   static int exp_lut[8] = { 0, 132, 396, 924, 1980, 4092, 8316, 16764 };
  4805.   int sign, exponent, mantissa, sample;
  4806.  
  4807.   ulawbyte = ~ ulawbyte;
  4808.   sign = ( ulawbyte & 0x80 );
  4809.   exponent = ( ulawbyte >> 4 ) & 0x07;
  4810.   mantissa = ulawbyte & 0x0F;
  4811.   sample = exp_lut[exponent] + ( mantissa << ( exponent + 3 ) );
  4812.   if ( sign != 0 ) sample = -sample;
  4813.  
  4814.   return sample;
  4815. }
  4816.  
  4817. /**************************************
  4818.  *
  4819.  *************************************/
  4820. void Gen_Ulaw_2_Signed()
  4821. { xaULONG i;
  4822.   for(i=0;i<256;i++)
  4823.   { xaUBYTE data = (xaUBYTE)(i);
  4824.     xaLONG d = XA_Ulaw_to_Signed( data );
  4825.     xa_ulaw_2_sign[i] = (xaULONG)((xaULONG)(d) & 0xffff);
  4826.   }
  4827. }
  4828.  
  4829.  
  4830. /* Pod this was 4096, I changed to 32768 */
  4831. #define XA_ARM_VAL_LIMIT       32768
  4832. /* Mu-law format constants */
  4833. #define XA_ARM_SIGN_BIT        1
  4834. #define XA_ARM_NCHORDS         8
  4835. #define XA_ARM_NPOINTS         16
  4836.     /* limit of "magnitude" (logarithmic) */
  4837. #define XA_ARM_DAC_LIMIT       (XA_ARM_NCHORDS*XA_ARM_NPOINTS)  
  4838.  
  4839. xaULONG arm_dac_to_val[XA_ARM_DAC_LIMIT];     /* obsolete */
  4840.  
  4841. /**************************************
  4842.  *
  4843.  * original code courtesy of Mark Taunton, Acorn Computers Ltd, June 1992.
  4844.  * hacked by Mark Podlipec
  4845.  *************************************/
  4846. void Gen_Arm_2_Signed()
  4847. { int c, p, ux, step, curval, max;
  4848.   double adjust;
  4849.  
  4850.   ux = 0; curval = 0;
  4851.   for (c = 0; c < XA_ARM_NCHORDS; ++c)
  4852.   {
  4853.     step = 1 << c;
  4854.     for (p = 0; p < XA_ARM_NPOINTS; ++p)
  4855.     {
  4856.       arm_dac_to_val[ux++] = curval;
  4857.       curval += step;
  4858.     }
  4859.   }
  4860.   
  4861.   /* Now adjust for 0..4095 notional linear range rather than 0..4016 */
  4862.   /* i.e. half-step over max nominal: 3952+128/2 = 4016 */
  4863.   max = curval - step/2;  
  4864.   adjust = (double)(XA_ARM_VAL_LIMIT-1) / (double)max;
  4865.   /* Scale dac_to_val table to give 0..4095 linear range coverage */
  4866.   for (ux = 0; ux < XA_ARM_DAC_LIMIT; ++ux)
  4867.   {                       /* implement rounding */
  4868.     arm_dac_to_val[ux] = (int) (arm_dac_to_val[ux] * adjust + 0.5); 
  4869.         /* Compute signed table values also */
  4870.     xa_arm_2_signed[ux << 1 |        0]        =  arm_dac_to_val[ux];
  4871.     xa_arm_2_signed[ux << 1 | XA_ARM_SIGN_BIT] = -arm_dac_to_val[ux];
  4872.   }
  4873. }
  4874.  
  4875. /********* Init_Audio_Ring ************
  4876.  *
  4877.  * Global Variables:
  4878.  *  xa_audio_ring        pointer to somewhere in the ring
  4879.  *************************************/
  4880. void Init_Audio_Ring(ring_num,buf_size)
  4881. xaULONG ring_num;
  4882. xaULONG buf_size;
  4883. {
  4884.   xaULONG i;
  4885.   XA_AUDIO_RING_HDR *t_ring,*t_first;
  4886.   xaUBYTE *t_buf;
  4887.   if (xa_audio_ring) Kill_Audio_Ring();
  4888.   t_first = xa_audio_ring = 0;
  4889.   for(i=0;i<ring_num;i++)
  4890.   {
  4891.     t_ring = (XA_AUDIO_RING_HDR *)malloc( sizeof(XA_AUDIO_RING_HDR) );
  4892.     if (t_ring==0) TheEnd1("Init Audio Ring: malloc err0");
  4893.     t_buf = (xaUBYTE *)malloc( buf_size );
  4894.     if (t_buf==0) TheEnd1("Init Audio Ring: malloc err1");
  4895.     t_ring->time = t_ring->timelo = 0;
  4896.     t_ring->len = 0;
  4897.     t_ring->buf = t_buf;
  4898.     if (t_first == 0) t_first = xa_audio_ring = t_ring;
  4899.     t_ring->next = t_first;
  4900.     xa_audio_ring->next = t_ring;
  4901.     xa_audio_ring = t_ring;
  4902.   }
  4903.   xa_audio_ring_t = xa_audio_ring;
  4904. }
  4905.  
  4906. /********* Kill_Audio_Ring ************
  4907.  * Move around ring, free'ing up memory structures.
  4908.  *
  4909.  * Global Variables:
  4910.  *  xa_audio_ring        pointer to somewhere in the ring
  4911.  **************************************/
  4912. void Kill_Audio_Ring()
  4913. {
  4914.   XA_AUDIO_RING_HDR *t_first;
  4915.  
  4916.   if (xa_audio_ring==0) return;
  4917.   t_first = xa_audio_ring;
  4918.  
  4919.   do
  4920.   { XA_AUDIO_RING_HDR *t_tmp = xa_audio_ring;
  4921.     if (xa_audio_ring->buf) FREE(xa_audio_ring->buf,0x508);
  4922.     xa_audio_ring->time = xa_audio_ring->timelo = 0;
  4923.     xa_audio_ring->len = 0;
  4924.     xa_audio_ring->buf = 0;
  4925.     xa_audio_ring = xa_audio_ring->next;
  4926.     FREE(t_tmp,0x509);
  4927.   } while(xa_audio_ring != t_first);
  4928.   xa_audio_ring = 0;
  4929.   xa_audio_ring_t = 0;
  4930. }
  4931.  
  4932. /****************************************************************
  4933.  * Fill up any unused Audio Ring Entries with sound.
  4934.  *
  4935.  ****************************************************************/
  4936.  
  4937. void XA_Update_Ring(cnt)
  4938. xaULONG cnt;
  4939. { 
  4940. DEBUG_LEVEL1 fprintf(stderr,"UPDATE RING %d\n",cnt);
  4941.   while( (xa_audio_ring_t->len == 0) && (xa_snd_cur) && cnt)
  4942.   { xaULONG tmp_time, tmp_timelo; xaLONG i,xx;
  4943.     cnt--;
  4944.     tmp_time = xa_snd_cur->ch_time;    /* save these */
  4945.     tmp_timelo = xa_snd_cur->ch_timelo;
  4946.     /* uncompress sound chunk */
  4947.     i = xa_audio_ring_t->len = xa_snd_cur->ch_size * xa_audio_hard_bps;
  4948.     /* NOTE: the following delta call may modify xa_snd_cur */
  4949.     xx = xa_snd_cur->delta(xa_snd_cur,xa_audio_ring_t->buf,0,
  4950.                             xa_snd_cur->ch_size);
  4951.     i -= xx * xa_audio_hard_bps;
  4952.     if (i > 0) /* Some system need fixed size chunks */
  4953.     { xaUBYTE *dptr = xa_audio_ring_t->buf;
  4954.       while(i--) *dptr++ = 0;
  4955.     }
  4956.     xa_audio_ring_t->time = tmp_time;
  4957.     xa_audio_ring_t->timelo = tmp_timelo;
  4958.     xa_audio_ring_t = xa_audio_ring_t->next; 
  4959.   }
  4960. }
  4961.  
  4962. /***************************************************************8
  4963.  * Flush Ring of All Conversions
  4964.  * SHOULD ONLY BE CALLED BY OUTPUT ROUTINE.
  4965.  */
  4966.  
  4967. void XA_Flush_Ring()
  4968. { XA_AUDIO_RING_HDR *tring = xa_audio_ring;
  4969.  
  4970. DEBUG_LEVEL1 fprintf(stderr,"FLUSH_RING\n");
  4971.   do
  4972.   { xa_audio_ring->len = 0;
  4973.     xa_audio_ring = xa_audio_ring->next;
  4974.   } while(xa_audio_ring != tring);
  4975.   xa_audio_ring_t = xa_audio_ring;    /* resync  fill and empty */
  4976.   xa_audio_flushed = 1;
  4977. }
  4978.  
  4979.  
  4980. /********** New_Merged_Audio_Output **********************
  4981.  * Set Volume if needed and then write audio data to audio device.
  4982.  *
  4983.  * IS 
  4984.  *****/
  4985. void New_Merged_Audio_Output()
  4986. { xaLONG time_diff, loop_cnt = xa_audio_ring_size;
  4987.  
  4988.   /* normal exit is when audio gets ahead */
  4989.   while(loop_cnt--)
  4990.   {
  4991.     if (xa_audio_status != XA_AUDIO_STARTED) { return; }
  4992.     time_diff = xa_time_audio - xa_time_now; /* how far ahead is audio */
  4993.     if (time_diff > xa_out_time) /* potentially ahead */
  4994.     {
  4995.       xa_time_now = XA_Read_AV_Time();  /* get new time */
  4996.       time_diff = xa_time_audio - xa_time_now;
  4997.       if (time_diff > xa_out_time)  /* definitely ahead */
  4998.       { /* If we're ahead, update the ring. */
  4999.         XA_Update_Ring(2);
  5000.     xa_interval_id = XtAppAddTimeOut(theAudContext,xa_interval_time,
  5001.         (XtTimerCallbackProc)New_Merged_Audio_Output,(XtPointer)(NULL));
  5002.         return;
  5003.       }
  5004.     }
  5005.  
  5006.  
  5007.     if (xa_audio_ring->len)
  5008.     { 
  5009.       /* If audio buffer is full, write() can't write all of the data. */
  5010.       /* So, next routine checks the rest length in buffer.            */
  5011. #ifdef XA_SONY_AUDIO
  5012.       { int ret, buf_len;
  5013.     ret = ioctl(devAudio, SBIOCBUFRESID,&buf_len) ;
  5014.     if( ret == -1 ) fprintf(stderr,"SONY_AUDIO: SIOCBUFRESID error.\n");
  5015.     if(buf_len > sony_audio_buf_len - xa_audio_ring->len)
  5016.     {
  5017.       xa_interval_id = XtAppAddTimeOut(theAudContext,xa_interval_time,
  5018.         (XtTimerCallbackProc)New_Merged_Audio_Output,(XtPointer)(NULL));
  5019.       return;
  5020.     }
  5021.       }
  5022. #endif
  5023.  
  5024. #ifdef XA_SGI_AUDIO
  5025.       { int buf_len;
  5026.     buf_len = ALgetfillable(port) ;
  5027.     if (buf_len < (xa_audio_ring->len >> 1))
  5028.     { 
  5029.       xa_interval_id = XtAppAddTimeOut(theAudContext,xa_interval_time,
  5030.         (XtTimerCallbackProc)New_Merged_Audio_Output,(XtPointer)(NULL));
  5031.       return;
  5032.     }
  5033.       }
  5034. #endif
  5035.  
  5036. #ifdef XA_MMS_AUDIO
  5037.       {
  5038.         mmeProcessCallbacks();
  5039.     /* NOTE: These buffers aren't part of the XAnim audio ring buffer */
  5040.     /*       Our ring buffer just happens to be the same size */
  5041.     if( mms_buffers_outstanding  >= xa_audio_ring_size ) 
  5042.     {
  5043.       xa_interval_id = XtAppAddTimeOut(theAudContext,xa_interval_time,
  5044.         (XtTimerCallbackProc)New_Merged_Audio_Output,(XtPointer)(NULL));
  5045.        return ;
  5046.     }
  5047.       }
  5048. #endif
  5049.  
  5050. #ifdef XA_HP_AUDIO
  5051.       if (hp_audio_paused == xaTRUE)
  5052.       { DEBUG_LEVEL1 fprintf(stderr,"HP-out-unpause\n");
  5053.         AResumeAudio( audio_connection, hp_trans_id, NULL, NULL );
  5054.         hp_audio_paused = xaFALSE;
  5055.       }
  5056. #endif
  5057.  
  5058.  
  5059. /*---------------- Now for the Write Segments -------------------------------*/
  5060.  
  5061. #ifdef XA_SPARC_AUDIO
  5062.       write(devAudio,xa_audio_ring->buf,xa_audio_ring->len); 
  5063. #endif
  5064.  
  5065. #ifdef XA_NetBSD_AUDIO
  5066.       write(devAudio,xa_audio_ring->buf,xa_audio_ring->len);
  5067. #endif
  5068.  
  5069. #ifdef XA_AIX_AUDIO
  5070.       { int rc;
  5071.         rc = write ( devAudio, xa_audio_ring->buf, xa_audio_ring->len );
  5072.       }
  5073. #endif
  5074.  
  5075. #ifdef XA_SGI_AUDIO
  5076.       /* # of Samples, not Bytes. Note: assume 16 bit samples. */
  5077.       ALwritesamps(port,xa_audio_ring->buf, (xa_audio_ring->len >> 1) );
  5078. #endif
  5079.  
  5080. #ifdef XA_LINUX_AUDIO
  5081.       write(devAudio,xa_audio_ring->buf,xa_audio_ring->len);
  5082. #endif
  5083.  
  5084. #ifdef XA_NAS_AUDIO
  5085.       NAS_Write_Data(xa_audio_ring->buf, xa_audio_ring->len);
  5086. #endif
  5087.  
  5088. #ifdef XA_SONY_AUDIO
  5089.       { int ret;
  5090.         write(devAudio,xa_audio_ring->buf,xa_audio_ring->len);
  5091.         /* Buffer of Sony audio device is too large */ /* HP needs this */
  5092.         ret = ioctl(devAudio, SBIOCFLUSH, 0);
  5093.         if( ret == -1 ) fprintf(stderr,"audio output:SBIOCFLUSH error.\n");
  5094.       }
  5095. #endif
  5096.  
  5097. #ifdef XA_EWS_AUDIO
  5098.       write(devAudio,xa_audio_ring->buf,xa_audio_ring->len);
  5099. #endif
  5100.  
  5101. #ifdef XA_AF_AUDIO
  5102.       { ATime act, atd = AFtime0;
  5103.     if (XAAUD->mute != xaTRUE)
  5104.       act = AFPlaySamples(ac,AFtime0,xa_audio_ring->len,xa_audio_ring->buf);
  5105.     else act = AFGetTime(ac);
  5106.     if (AFtime0 < act)    AFtime0 = act+TOFFSET;
  5107.     else    AFtime0 += xa_audio_ring->len >> 1; /* Number of samples */
  5108.       }
  5109. #endif
  5110.  
  5111. #ifdef XA_HP_AUDIO
  5112.       write(streamSocket,xa_audio_ring->buf,xa_audio_ring->len);
  5113. /* Some way to flush streamsocket???? */
  5114. #endif
  5115.  
  5116. #ifdef XA_HPDEV_AUDIO
  5117.       write (devAudio, xa_audio_ring->buf, xa_audio_ring->len);
  5118. #endif
  5119.  
  5120. #ifdef XA_MMS_AUDIO
  5121.       /* As currently implemented, this copies the audio data into a separate
  5122.          shared memory buffer for communication with the multimedia server. We
  5123.          could actually work directly out of the audio ring buffer if it was
  5124.          allocated in shared memory, but this keeps things more independent of
  5125.          each other - tfm
  5126.       */
  5127.       {  
  5128.     MMRESULT    status;
  5129.     int        bytes,len;
  5130.     if (XAAUD->mute != xaTRUE) 
  5131.     {
  5132.       bytes = xa_audio_hard_buff * xa_audio_hard_bps;
  5133.       mms_lpWaveHeader->lpData = (LPSTR)(mms_audio_buffer
  5134.                         + mms_next_buffer * bytes);
  5135.       mms_lpWaveHeader->dwBufferLength = xa_audio_ring->len;
  5136.       if(xa_audio_ring->len > bytes) 
  5137.       {
  5138.         len = bytes;
  5139.         fprintf(stderr,"Audio chunk truncated to %d bytes\n",len);
  5140.       }
  5141.       else len = xa_audio_ring->len;
  5142.       memcpy( mms_lpWaveHeader->lpData, xa_audio_ring->buf, len);
  5143.       mms_next_buffer++;
  5144.       if(mms_next_buffer >= xa_audio_ring_size) mms_next_buffer = 0;
  5145.       status = waveOutWrite(mms_device_handle, mms_lpWaveHeader,
  5146.                             sizeof(WAVEHDR));
  5147.       if( status != MMSYSERR_NOERROR ) 
  5148.       {
  5149.         fprintf(stderr,"waveOutWrite failed - status = %d\n",status);
  5150.       }
  5151.       else { mms_buffers_outstanding++; }
  5152.     }
  5153.       }
  5154. #endif
  5155.  
  5156.       /* Don't adjust volume until after write. If we're behind
  5157.        * the extra delay could cause a pop. */
  5158.       if (XAAUD->newvol==xaTRUE)
  5159.       { xaULONG vol = (XAAUD->mute==xaTRUE)?(XA_AUDIO_MINVOL):(XAAUD->volume);
  5160.       XA_Adjust_Volume(vol);
  5161.       XAAUD->newvol = xaFALSE;
  5162.       }
  5163.       xa_time_audio   += xa_audio_ring->time;
  5164.       xa_timelo_audio += xa_audio_ring->timelo;
  5165.       if (xa_timelo_audio & 0xff000000)
  5166.         { xa_time_audio++; xa_timelo_audio &= 0x00ffffff; }
  5167.       xa_audio_ring->len = 0; 
  5168.       xa_audio_ring = xa_audio_ring->next;  /* move to next */
  5169.       if (xa_audio_status != XA_AUDIO_STARTED) { return;}
  5170.  
  5171.       if (xa_out_init) xa_out_init--;
  5172.       else XA_Update_Ring(2);  /* only allow two to be updated */
  5173. /* NOT HERE - loop first
  5174.       xa_interval_id = XtAppAddTimeOut(theAudContext,xa_interval_time,
  5175.         (XtTimerCallbackProc)New_Merged_Audio_Output,(XtPointer)(NULL));
  5176.       return;
  5177. */
  5178.     } 
  5179.     else  /* Audio Sample finished */
  5180.     { xa_time_now = XA_Read_AV_Time();
  5181.  
  5182.     /* Is audio still playing buffered samples? */
  5183.       if (xa_time_now < xa_time_audio) 
  5184.       { xaULONG diff = xa_time_audio - xa_time_now;
  5185.     /* POD note 50ms is arbitrarily chosen to be long, but not noticeable*/
  5186.         if (xa_audio_status != XA_AUDIO_STARTED) {return;}
  5187.     xa_interval_id = XtAppAddTimeOut(theAudContext,diff,
  5188.         (XtTimerCallbackProc)New_Merged_Audio_Output,(XtPointer)(NULL));
  5189.         return;
  5190.       }
  5191.       else 
  5192.       { XA_Audio_Off(0);
  5193.     return;
  5194.       }
  5195.     } /* end of ring_len */
  5196.   } /* end of while ring */
  5197.   xa_interval_id = XtAppAddTimeOut(theAudContext,xa_interval_time,
  5198.         (XtTimerCallbackProc)New_Merged_Audio_Output,(XtPointer)(NULL));
  5199.   return;
  5200. }  /* end of function */
  5201.  
  5202.