racket only ffmpeg backend. Now no racket-sound-libs are needed anymore.

private/cstruct-helper.rkt

@@ -0,0 +1,102 @@
+#lang racket/base
+
+(require ffi/unsafe
+         ffi/unsafe/define
+         ffi/unsafe/alloc
+         (for-syntax racket/base)
+         "utils.rkt"
+         )
+
+(provide make-offsets
+         def-cstruct
+         struct-helpers
+         )
+
+(define (make-offsets* defs)
+  (let ((name-store (make-hash)))
+
+    (define (expand-type n t)
+      (if (= n 0)
+          '()
+          (cons t (expand-type (- n 1) t))))
+
+    (define (make-types defs idx)
+      (if (null? defs)
+          '()
+          (let ((d (car defs)))
+            (let ((t (if (list? d)
+                         (if (symbol? (car d))
+                             (let ((name (car d)))
+                               (hash-set! name-store name (list idx (cadr d)))
+                               (list 1 (cadr d)))
+                              d)
+                         (list 1 d))))
+              (append (expand-type (car t) (cadr t))
+                      (make-types (cdr defs) (+ idx (car t))))))
+          ))
+
+    (let ((offsets (compute-offsets (make-types defs 0))))
+      (let ((keys (hash-keys name-store))
+            (offs (make-hash)))
+        (for-each (λ (key)
+                    (let* ((idx-t (hash-ref name-store key))
+                           (idx (car idx-t))
+                           (t (cadr idx-t)))
+                      (hash-set! offs key (list (list-ref offsets idx) t))
+                      )
+                    )
+                  keys)
+        offs))))
+
+
+(define-syntax (make-offset stx)
+  (syntax-case stx ()
+    ((_ (x t))
+     (cond
+       ((number? (syntax->datum #'x)) #'(list x t))
+       (else #'(list 'x t))
+       )
+     )
+    ((_ t)
+     #'(list 1 t))
+    )
+  )
+
+(define-syntax make-offsets
+  (syntax-rules ()
+    ((_ a ...)
+     (make-offsets* (list (make-offset a) ...)))))
+
+(define-syntax def-cstruct
+  (syntax-rules ()
+    ((_ name (t ...) offs)
+        (define-cstruct name
+          ([t (cadr (hash-ref offs 't)) #:offset (car (hash-ref offs 't))]
+           ...)))
+    )
+  )
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Internal structures for ffmpeg decoding
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define-syntax def-struct-helpers
+  (syntax-rules ()
+    ((_ (struct-get get struct-set set))
+     (begin
+       (define get struct-get)
+       (define set struct-set))
+     )
+    ((_ (struct-get get))
+     (define get struct-get)
+     )
+     )
+  )
+
+(define-syntax struct-helpers
+  (syntax-rules ()
+    ((_ a ...)
+     (begin
+       (def-struct-helpers a)
+       ...))))

private/utils.rkt

@@ -21,6 +21,17 @@
            sync-log-sound
            integer->int-bytes
            int-bytes->integer
+
+           let/assert
+           make-assert
+           a-eq? a-!eq?
+           a->? a-<=? a->=? a-<? a-=? a-!=?
+           a-nullptr? a-!nullptr?
+           a-true? a-false?
+           
+           define/return
+           return
+           
            )
 
   (sl-def-log racket-sound sound)
@@ -125,5 +136,103 @@
                 (- u #x1000000)
                 u))
           (integer-bytes->integer bs signed? big? start end))))
+
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;; let/assert
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+  (define-syntax make-assert
+    (syntax-rules ()
+      ((_ name not-name pred)
+       (begin
+         (define-syntax name
+           (syntax-rules ()
+             ((_ const)
+              (λ (x) (pred x const)))))
+         (define-syntax not-name
+           (syntax-rules ()
+             ((_ const)
+              (λ (x) (not (pred x const))))))
+         )
+       )
+      )
+    )
+
+  (make-assert a-eq? a-!eq? eq?)
+
+  (define a-nullptr? (a-eq? #f))
+  (define a-!nullptr? (a-!eq? #f))
+
+  (make-assert a->? a-<=? >)
+  (make-assert a->=? a-<? >=)
+  (make-assert a-=? a-!=? =)
+
+  (define a-true? (a-eq? #t))
+  (define a-false? (a-eq? #f))
+
+  (struct exn:let/assert exn (value) #:transparent)
+
+  (define (raise-let/assert v)
+    (raise (exn:let/assert "let/assert" (current-continuation-marks) v)))
+
+  (define (let/assert-value r)
+    (exn:let/assert-value r))
+
+  (define-syntax assert-expr
+    (syntax-rules ()
+      ((_ expr cond retval)
+       (let ((a expr)) (if (cond a) a (raise-let/assert retval))))
+      ((_ expr)
+       expr)
+      )
+    )
+
+  (define-syntax let/assert
+    (syntax-rules ()
+      ((_ ((v rest ...) ...) b1 ...)
+       (with-handlers ([exn:let/assert? let/assert-value])
+         (let* ((v (assert-expr rest ...))
+                ...)
+           b1
+           ...
+           )
+         )
+       )
+      )
+    )
+
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;; define/return
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  (struct exn:return exn (value) #:transparent)
+
+  (define (raise-return v)
+    (raise (exn:return "return" (current-continuation-marks) v)))
+
+  (define (return-value r)
+    (exn:return-value r))
+  
+  (define-syntax return
+    (syntax-rules ()
+      ((_ val)
+       (raise-return val))))
+
+  (define-syntax define/return
+    (syntax-rules ()
+      ((_ (name ...) b1 ...)
+       (define (name ...)
+         (with-handlers ([exn:return? return-value])
+           b1
+           ...
+           )
+         )
+       )
+      )
+    )
+            
+           
+       
   
 ) ; end of module