audio-send: org/ear.org comparison

comparison org/ear.org @ 29:cdf320cb5949

updated test suite

author	Robert McIntyre <rlm@mit.edu>
date	Sat, 10 Dec 2011 21:42:50 -0600
parents	f4c7260d397a
children	32c69ba451d9

comparison

equal deleted inserted replaced

-:1fc162d84343
+:cdf320cb5949
 clojure.
 ** =send.c=
 ** Header
-#+srcname: send-header
+#+name: send-header
 #+begin_src C
 #include "config.h"
 #include <stdlib.h>
 #include "alMain.h"
 #include "AL/al.h"
 which are in the master context.
 - =limitContext()= and =unLimitContext()= make it possible to render
 only one context at a time.
 ** Necessary State
-#+srcname: send-state
+#+name: send-state
 #+begin_src C
 ////////////////////  State
 typedef struct context_data {
 ALfloat ClickRemoval[MAXCHANNELS];
 parallel. The solution is to create a copy of this normally global
 device state for each context, and copy it back and forth into and out
 of the actual device state whenever a context is rendered.
 ** Synchronization Macros
-#+srcname: sync-macros
+#+name: sync-macros
 #+begin_src C
 ////////////////////  Context Creation / Synchronization
 #define _MAKE_SYNC(NAME, INIT_EXPR, GET_EXPR, SET_EXPR)	\
 void NAME (ALuint sourceID1, ALuint sourceID2,	\
 completely synchronize two sources, it is necessary to use all of
 them. These macros help to condense the otherwise repetitive
 synchronization code involving these similar low-level =OpenAL= functions.
 ** Source Synchronization
-#+srcname: sync-sources
+#+name: sync-sources
 #+begin_src C
 void syncSources(ALsource *masterSource, ALsource *slaveSource,
 		 ALCcontext *masterCtx, ALCcontext *slaveCtx){
 ALuint master = masterSource->source;
 ALuint slave = slaveSource->source;
 same between the master and slave sources.  I'd like to take this
 moment to salute the [[http://connect.creativelabs.com/openal/Documentation/Forms/AllItems.aspx][=OpenAL= Reference Manual]], which provides a very
 good description of =OpenAL='s internals.
 ** Context Synchronization
-#+srcname: sync-contexts
+#+name: sync-contexts
 #+begin_src C
 void syncContexts(ALCcontext *master, ALCcontext *slave){
 /* If there aren't sufficient sources in slave to mirror
 the sources in master, create them. */
 ALCcontext *current = alcGetCurrentContext();
 =syncSources()=. The only thing that =syncContexts()= has to worry
 about is automatically creating new sources whenever a slave context
 does not have the same number of sources as the master context.
 ** Context Creation
-#+srcname: context-creation
+#+name: context-creation
 #+begin_src C
 static void addContext(ALCdevice *Device, ALCcontext *context){
 send_data *data = (send_data*)Device->ExtraData;
 // expand array if necessary
 if (data->numContexts >= data->maxContexts){
 device-wide =ExtraData= structure.  The =renderBuffer= that is created
 here is where the rendered sound samples for this slave context will
 eventually go.
 ** Context Switching
-#+srcname: context-switching
+#+name: context-switching
 #+begin_src C
 ////////////////////  Context Switching
 /* A device brings along with it two pieces of state
 * which have to be swapped in and out with each context.
 the Device's context list to put the desired context-to-be-rendered
 into position 0, we can get trick =OpenAL= into rendering each slave
 context separate from all the others.
 ** Main Device Loop
-#+srcname: main-loop
+#+name: main-loop
 #+begin_src C
 ////////////////////   Main Device Loop
 /* Establish the LWJGL context as the master context, which will
 * be synchronized to all the slave contexts
 a way to transport this information to Java, and also a way to drive
 this device from Java.  The following JNI interface code is inspired
 by the way LWJGL interfaces with =OpenAL=.
 *** step
-#+srcname: jni-step
+#+name: jni-step
 #+begin_src C
 ////////////////////   JNI Methods
 #include "com_aurellem_send_AudioSend.h"
 simulate 1 second of AI-time would miss almost all of the sound in
 its environment.
 *** getSamples
-#+srcname: jni-get-samples
+#+name: jni-get-samples
 #+begin_src C
 /*
 * Class:     com_aurellem_send_AudioSend
 * Method:    ngetSamples
 * Signature: (JLjava/nio/ByteBuffer;III)V
 =addListener=, =setNthListenerf=, and =setNthListener3f= are
 necessary to change the properties of any listener other than the
 master one, since only the listener of the current active context is
 affected by the normal =OpenAL= listener calls.
-#+srcname: listener-manage
+#+name: listener-manage
 #+begin_src C
 /*
 * Class:     com_aurellem_send_AudioSend
 * Method:    naddListener
 * Signature: (J)V
 =getAudioFormat= is a convenience function that uses JNI to build up a
 =javax.sound.sampled.AudioFormat= object from data in the Device. This
 way, there is no ambiguity about what the bits created by =step= and
 returned by =getSamples= mean.
-#+srcname: jni-init
+#+name: jni-init
 #+begin_src C
 /*
 * Class:     com_aurellem_send_AudioSend
 * Method:    ninitDevice
 * Signature: (J)V
 #+end_src
 ** Boring Device management stuff
 This code is more-or-less copied verbatim from the other =OpenAL=
 backends. It's the basis for =OpenAL='s primitive object system.
-#+srcname: device-init
+#+name: device-init
 #+begin_src C
 ////////////////////   Device Initialization / Management
 static const ALCchar sendDevice[] = "Multiple Audio Send";
 simple.  Just as there were =SceneProcessors= for vision, there are
 now =SoundProcessors= for hearing.
 #+include "../../jmeCapture/src/com/aurellem/capture/audio/SoundProcessor.java" src java
-#+srcname: ears
+#+name: ears
 #+begin_src clojure
 (ns cortex.hearing
 "Simulate the sense of hearing in jMonkeyEngine3. Enables multiple
 listeners at different positions in the same world. Passes vectors
 of floats in the range [-1.0 -- 1.0] in PCM format to any arbitrary
 listener))
 #+end_src
 * Example
-#+srcname: test-hearing
+#+name: test-hearing
 #+begin_src clojure :results silent
-(ns test.hearing
+(ns cortex.test.hearing
 (:use (cortex world util hearing))
 (:import (com.jme3.audio AudioNode Listener))
-(:import com.jme3.scene.Node))
+(:import com.jme3.scene.Node
+	   com.jme3.system.AppSettings))
 (defn setup-fn [world]
 (let [listener (Listener.)]
 (add-ear world listener #(println-repl (nth % 0)))))
 (if (not value)
 (do
 (.playSource (.getAudioRenderer world) node))))
 (defn test-basic-hearing []
-(.start
 (let [node1 (AudioNode. (asset-manager) "Sounds/pure.wav" false false)]
 (world
 (Node.)
 {"key-space" (partial play-sound node1)}
 setup-fn
-no-op))))
+no-op)))
+(defn test-advanced-hearing
+"Testing hearing:
+You should see a blue sphere flying around several
+cubes.  As the sphere approaches each cube, it turns
+green."
+[]
+(doto (com.aurellem.capture.examples.Advanced.)
+(.setSettings
+(doto (AppSettings. true)
+(.setAudioRenderer "Send")))
+(.setShowSettings false)
+(.setPauseOnLostFocus false)))
 #+end_src
 This extremely basic program prints out the first sample it encounters
-at every time stamp. You can see the rendered sound begin printed at
+at every time stamp. You can see the rendered sound being printed at
 the REPL.
 - As a bonus, this method of capturing audio for AI can also be used
 to capture perfect audio from a jMonkeyEngine application, for use
 in demos and the like.
 #+begin_src clojure :tangle ../../cortex/src/cortex/hearing.clj
 <<ears>>
 #+end_src
-#+begin_src clojure :tangle ../../cortex/src/test/hearing.clj
+#+begin_src clojure :tangle ../../cortex/src/cortex/test/hearing.clj
 <<test-hearing>>
 #+end_src
 #+begin_src C :tangle ../Alc/backends/send.c
 <<send-header>>
 <<send-state>>
 <<sync-macros>>

Mercurial > audio-send

comparison org/ear.org @ 29:cdf320cb5949