mac os x instructions

libao-async-ffi-racket.rkt

@@ -28,6 +28,7 @@
          ao_pause_async
          ao_set_volume_async
          ao_volume_async
+         ao_reuse_buf_len
          make-buffer-info
          make-BufferInfo_t
          )
@@ -144,6 +145,8 @@
    volume-in-10000
 
    valid
+
+   bufs
    )
   #:mutable
   )
@@ -202,6 +205,36 @@
   (let ((le-a (is-little-endian? a))
         (le-b (is-little-endian? b)))
     (eq? le-a le-b)))
+
+
+(define (alloc-buf h size)
+  (let ((entry #f))
+    (letrec ((f (λ (entries)
+                  (if (null? entries)
+                      '()
+                      (let ((e (car entries)))
+                        (if (< size (car e))
+                            (begin
+                              (set! entry e)
+                              (cdr entries))
+                            (begin
+                              (cons e (f (cdr entries))))
+                            )
+                        )
+                      )
+                  )
+                ))
+      (set-ao-handle-bufs! h (f (ao-handle-bufs h)))
+      (if (eq? entry #f)
+          (list size (make-bytes size))
+          entry)
+      )
+    )
+  )
+
+(define (reuse-buf h buf size)
+  (set-ao-handle-bufs! h (cons (list size buf) (ao-handle-bufs h)))
+  )
          
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Converters
@@ -209,8 +242,6 @@
 
 ;;; Volume
 
-
-
 (define (adjust-volume h bs buf-size volume-in-10000)
   ;; bs: bytes
   ;; buf-size: aantal geldige bytes in bs
@@ -237,7 +268,7 @@
 ;;; planar -> intereleaved
 
 
-(define (planar-to-interleaved mem buf-size info)
+(define (planar-to-interleaved h mem buf-size info)
   ;; mem: bytes
   ;; result: (list bytes output-size)
 
@@ -246,7 +277,8 @@
          [channels   (buffer-info-channels info)]
          [bytes      (arithmetic-shift bits -3)]
          [out-size   buf-size]
-         [out        (make-bytes out-size)])
+         [out        (cadr (alloc-buf h out-size))]
+         )
 
     (unless (or (eq? type 'planar) (eq? type 'flac))
       (error (format "expected planar buffer, got: ~a" type)))
@@ -272,7 +304,7 @@
 ;;; requested bits to device bits
 
 
-(define (convert-bits buf buf-size in-bits in-endianness out-bits out-endianness)
+(define (convert-bits h buf buf-size in-bits in-endianness out-bits out-endianness)
   ;; buf: bytes
   ;; returns: (list out-bytes out-size)
 
@@ -280,7 +312,7 @@
          [out-bytes (arithmetic-shift out-bits -3)]
          [samples   (quotient buf-size in-bytes)]
          [out-size  (* samples out-bytes)]
-         [out       (make-bytes out-size)]
+         [out       (cadr (alloc-buf h out-size))]
          [shift     (- out-bits in-bits)]
          [in-big?   (is-big-endian? in-endianness)]
          [out-big?  (is-big-endian? out-endianness)])
@@ -292,13 +324,13 @@
              [converted (arithmetic-shift sample shift)])
         (integer->int-bytes converted out-bytes #t out-big? out out-pos)))
     
-    (list out out-size)))
+    (list out out-size #t)))
 
 (define (convert-req-bits-to-dev-bits h mem buf-size info)
   (if (and (= (buffer-info-sample-bits info) (ao-handle-dev-bits-per-sample h))
                (endian-eq? (buffer-info-endianness info) (ao-handle-dev-endianness h)))
-      (list mem buf-size)
-      (convert-bits mem buf-size
+      (list mem buf-size #f)
+      (convert-bits h mem buf-size
                     (buffer-info-sample-bits info)
                     (buffer-info-endianness info)
                     (ao-handle-dev-bits-per-sample h)
@@ -442,6 +474,7 @@
                  10000                   ; volume-in-10000
 
                  #t                      ; valid handle
+                 '()                     ; reuse buffer
                  )))
       
     (let ((ao-dev-bits (try-open-device bits rate channels byte-format wav-output-file)))
@@ -495,6 +528,7 @@
     (when (or (eq? type 'planar) (eq? type 'flac))
       (dbg-sound "Converting from planar to interleaved")
       (let ((m (planar-to-interleaved mem buf-size info)))
+        (reuse-buf h mem buf-size)
         (set! mem (car m))
         (set! buf-size (cadr m)))
       )
@@ -502,8 +536,10 @@
     (let ((ao-size buf-size)
           (ao-mem mem))
       (let ((m (convert-req-bits-to-dev-bits h mem buf-size info)))
-        (set! ao-mem (car m))
-        (set! ao-size (cadr m)))
+        (when (eq? (caddr m) #t)
+          (reuse-buf h mem buf-size)
+          (set! ao-mem (car m))
+          (set! ao-size (cadr m))))
 
       (unless (bytes? ao-mem)
         (error "Hey! this was unexpected!"))
@@ -560,3 +596,5 @@
 (define (ao_real_output_bits_async h)
   (ao-handle-dev-bits-per-sample h))
 
+(define (ao_reuse_buf_len h)
+  (length (ao-handle-bufs h)))