Work-in-progress repo for ambisonics extensions for OM-SoX
Marlon Schumacher
4 days ago 4020656850c3f64875a927ae9687127c163d9099
sources/sox-process.lisp
@@ -187,91 +187,32 @@
; in that case a 3DC would have to be used by using points (point-pairs) in a loop 
    (if (probe-file *sox-path*)
        (progn
          ;(unless (listp (sound sox-input)) (setf (positions sox-input) (list (positions sox-input)))) ; quick hack to prevent having to provide position arg as list of lists
          #|
 (when
              (not
               (or
                (subtypep (type-of (positions sox-input)) '3dc)
                (and (subtypep (type-of (positions sox-input)) 'list)
                     (> (length (positions sox-input)) 0)
                     )
                    ; (subtypep (type-of (first (positions sox-input))) 'list)
                    ; (> (length (first (positions sox-input))) 1))
                )
               )
            (om-message-abort "positions must be of type 3dc, or a list of lists.")
            )
|#
          (let* ((sound (list! (sound sox-input)))
                 (positions-ae (list (azimuth sox-input) (elevation sox-input))))
        (progn
          (let* ((sound (list! (sound sox-input))))
            (when (and (find-if 'stringp sound) (equal output "pipe")) 
              (om-message-abort "Pipe output not possible with this type of input."))
            
            (let* ((filenames (loop for soundfile in sound collect (namestring soundfile)))
            (let* ((filenames (loop for soundfile in sound collect (namestring soundfile))) ; not needed - soundfile should be an atom
                   (outfile (create-path nil output filetype)))
              
              (setf str (format nil " ~s ~a" (namestring *sox-path*) *sox-options*))
              (if (= (length filenames) 1)
                        ; case: one file 
                  (let* ((filename (first filenames))
                         (position positions-ae))
                  (let* ((filename (first filenames)))
                       ;  (position positions-ae))
                    (if (= (order sox-input) 0) 
                     ; case: order = 0
                        (setf str (string+ str (format nil " ~s" filename)))
                     ; case: order > 0
                      (progn ; here it would be more redundant to call sox-merge with the given params
                        (setf str (string+ str " -M"))
                        (loop for gain in (sox-hoaencode-gains-up-to-order (order sox-input) (first position) (second position))
                        (loop for gain in (sox-hoaencode-gains-up-to-order (order sox-input) (azimuth sox-input) (elevation sox-input))
                              do (setf str (string+ str (format nil " -v~d ~s" gain filename))))
                        )
                      )
                    )
                      ; case: multiple files
                #|
                (if (= (order sox-input) 0)
                 ; case: order = 0
                    (progn
                      (setf str (string+ str " -m")) ; this is the mixer. e.g. sox-mix
                                (loop for filename in filenames
                                      do (setf str (string+ str (format nil " ~s" filename))))
                                )
                 ; case: order > 0
                  (progn
                    (setf str (string+ str " -m"))
                                ; Create components
                    (setf component_idx 0)
                    (loop
                       for filename in filenames
                       for position in positions-ae
                       do
                                                                   ; in Object-Oriented Programming we would call-next-method i.e. set a sox-merge input class with the corresponding params.
                                                                   ; e.g. (make-instance 'sox-merge ... (more redundancy and compactness, less error-prone) ... possible?
                                                                   ; for multiple sound inputs if possible we would then call a sox-mix to mix the sox merge pipes. everything
                         (progn
                           (setf str_component (format nil " ~s ~a -M" (namestring *sox-path*) *sox-options*))
                           (loop for gain in (sox-hoaencode-gains-up-to-order (order sox-input) (first position) (second position))
                                 do (setf str_component (string+ str_component (format nil " -v~d ~s" gain filename))))
                           (setf outfile_tmp (format nil "~a~a-~d.~a" (directory-namestring outfile) (pathname-name outfile) component_idx (pathname-type outfile)))
                           (setf str_component (sox-samplebits str_component bitdepth samplerate outfile_tmp))
                           (sox-out str_component filename "new file" outfile_tmp nil)
                           (setf component_idx (1+ component_idx))
                                        ; Add component path to <str>
                           (setf str (string+ str (format nil " ~s" outfile_tmp)))
                           )
                       )
                    )
                  )
|#
                )
                    ))
              (setf str 
                    (cond 
                     ((equal output "realtime")