;*********************************************************************
|
; OM-SoX, (c) 2011-2014 Marlon Schumacher (CIRMMT/McGill University) *
|
; http://sourceforge.net/projects/omsox/ *
|
; *
|
; Multichannel Audio Manipulation and Functional Batch Processing. *
|
; DSP based on SoX - (c) C.Bagwell and Contributors *
|
; http://sox.sourceforge.net/ *
|
;*********************************************************************
|
;
|
;This program is free software; you can redistribute it and/or
|
;modify it under the terms of the GNU General Public License
|
;as published by the Free Software Foundation; either version 2
|
;of the License, or (at your option) any later version.
|
;
|
;See file LICENSE for further informations on licensing terms.
|
;
|
;This program is distributed in the hope that it will be useful,
|
;but WITHOUT ANY WARRANTY; without even the implied warranty of
|
;MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
;GNU General Public License for more details.
|
;
|
;You should have received a copy of the GNU General Public License
|
;along with this program; if not, write to the Free Software
|
;Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,10 USA.
|
;
|
;Authors: M. Schumacher, J. Bresson
|
|
(in-package :om)
|
|
(print "loading OM-SoX player for OM version >= 6.7")
|
|
; player specific controls
|
; I need a 'record' button - including a choice of channels I guess
|
; Might have a 'spread' numbox later
|
; Where are things like selection (region) and loop etc. set?
|
|
(defmethod make-player-specific-controls ((self (eql :soxplayer)) control-view)
|
(let ((snd (object (editor control-view))))
|
; ------------------------------------------
|
(list
|
(om-make-dialog-item 'om-static-text
|
(om-make-point 405 8)
|
(om-make-point 40 20) "Gain" ;level
|
:font *om-default-font1*)
|
|
(om-make-dialog-item 'edit-numBox
|
(om-make-point 360 8)
|
(om-make-point 45 18) (format nil " ~4f" (om-round (sox-vol-convert (vol snd)) 3))
|
:min-val -76 :max-val 12
|
;:incr 0.01
|
:font *om-default-font1*
|
:bg-color *om-white-color*
|
:value (sox-vol-convert (vol snd))
|
:afterfun #'(lambda (item)
|
|
(setf (vol snd) (sox-convert-vol (value item)))
|
(om-set-dialog-item-text item (format () " ~4f" (om-round (value item) 3))) ; not sure this is needed
|
))
|
|
|
(om-make-dialog-item 'om-static-text (om-make-point 480 8)
|
(om-make-point 70 20) "Panning"
|
:font *om-default-font1*)
|
;PAN
|
(om-make-dialog-item 'edit-numBox
|
(om-make-point 440 8)
|
(om-make-point 40 20)
|
(format nil " ~4f" (sox-pan-convert (pan snd) (tracknum snd)))
|
:font *om-default-font1*
|
;:incr 0.1
|
:min-val 0.0 :max-val 64.0 ; the minvalue is '0' which means "no panning"
|
:fg-color (if (>= (tracknum snd) 1.0) *om-black-color* *om-gray-color*)
|
:bg-color *om-white-color*
|
:value (sox-pan-convert (pan snd) (tracknum snd))
|
:afterfun #'(lambda (item)
|
(om-set-dialog-item-text item (format () " ~4f" (value item)))
|
(setf (pan snd) (second (sox-convert-pan (value item))))
|
(setf (tracknum snd) (first (sox-convert-pan (value item))))
|
)
|
)
|
#|
|
(om-make-dialog-item 'numbox
|
(om-make-point 70 pos)
|
(om-make-point 36 18)
|
(format nil " ~2f" (nth (micid self) (micexps (mic-array self))))
|
:value (nth (micid self) (micexps (mic-array self)))
|
:font *om-default-font1*
|
:incr 0.01
|
:min-val 0.0 :max-val 2.0
|
:afterfun #'(lambda (box)
|
(setf (nth (micid self) (micexps (mic-array self))) (value box))
|
(setf (bpcs (mic-array self)) (gen-bpcs (mic-array self)))
|
(report-modifications (om-view-container self)))
|
)
|
|#
|
(om-make-dialog-item 'om-check-box (om-make-point 100 8)
|
(om-make-point 100 20) "Sonagram"
|
:font *om-default-font1*
|
:di-action
|
#'(lambda (item)
|
(let* ((editor (editor control-view))
|
(thesound (object editor)))
|
(when (om-checked-p item)
|
(unless (pict-spectre thesound)
|
(setf (pict-spectre thesound)
|
(sox-spectrogram thesound nil nil :mode "negativ-monochrome" :legend nil))))
|
(setf (pict-spectre? thesound) (om-checked-p item))
|
(om-invalidate-view (panel editor))))
|
:checked-p (pict-spectre? (object (editor control-view)))
|
)
|
))
|
)
|
|
|
|
; needs a menu for the 'mode' of the sonagram in the player panel settings perhaps
|
|
|
;(defmethod player-special-action ((self (eql :soxplayer))) (launch-multiplayer-app))
|
;(defmethod player-type ((player (eql :soxplayer))) :UDP)
|
|
;(defun init-soxplayer-app ()
|
;; enable soxplayer-engine for sound class:
|
; (pushnew :soxplayer *enabled-players*)
|
; (add-player-for-object sound :soxplayer))
|
|
;;(init-soxplayer-app)
|
;(om-add-init-func 'init-soxplayer-app)
|
|
(enable-player :soxplayer)
|
|
(defmethod player-name ((self (eql :soxplayer))) "OM-SoX player")
|
(defmethod player-desc ((self (eql :soxplayer))) "external SoX player, requires OM-SoX library.")
|
;(defmethod player-special-action ((self (eql :multiplayer))) (launch-multiplayer-app))
|
;(defmethod player-type ((player (eql :multiplayer))) :UDP)
|
(add-player-for-object 'sound :soxplayer)
|
|
;==================
|
; APP
|
;==================
|
|
(defvar *sox-play-list* nil)
|
(defvar *sox-play-temp* "sox-play.aiff")
|
(defvar *sox-temp-recorded-file* nil)
|
|
(defun init-soxplayer-app ()
|
(unless (probe-file *sox-path*)
|
(sox-not-found)))
|
|
(om-add-init-func 'init-soxplayer-app)
|
|
#|
|
(defmethod InitPlayingSeq ((player (eql 'soxplayer)) dur &key (port nil))
|
(setf *sox-play-list* nil)
|
(unless (probe-file *sox-path*)
|
(om-beep-msg "SoX-executable not found!")
|
))
|
|#
|
|
;================
|
; PROTOCOL
|
;================
|
|
;(defvar *multiplayer-file-to-play* (defmethod Pause-Player ((self (eql 'soxplayer))) (om-beep)) ;there's currently no good method for Pause-Player
|
;(defmethod Continue-Player ((self (eql 'soxplayer))) nil)
|
|
(defmethod Reset-Player ((self (eql :soxplayer)) &optional view)
|
(declare (ignore view))
|
(print "resetting player")
|
(when (probe-file (outfile *sox-play-temp*)) (delete-file (outfile *sox-play-temp*)))
|
(setf *sox-play-list* nil)
|
t)
|
|
|
; (defmethod InitPlayingSeq ((player (eql 'multiplayer)) dur &key (port nil)) t)
|
; (defmethod FinalizePlayingSeq ((player (eql 'multiplayer)) dur &key (port nil)) t)
|
|
; sequence is prepare-to-play and then player-start
|
(defmethod prepare-to-play ((engine (eql :soxplayer)) (player omplayer) object at interval)
|
(call-next-method)
|
)
|
; (declare (ignore approx))
|
; (push (list object at interval) *sox-play-list*))
|
|
(defmethod player-start ((engine (eql :soxplayer)) &optional play-list) (call-next-method))
|
|
(defmethod player-play-object ((engine (eql :soxplayer)) (object sound) &key interval)
|
; (print "soxplayer play")
|
(sox-play object))
|
|
(defmethod player-stop ((engine (eql :soxplayer)) &optional play-list)
|
;(print "soxplayer stop")
|
(declare (ignore view))
|
(sox-kill nil))
|
|
|
|
#|
|
; currently no scheme for player-pause and player-continue
|
(defmethod player-pause ((engine (eql :soxplayer)) &optional play-list)
|
(sox-kill nil))
|
(defmethod player-continue ((engine (eql :soxplayer)) &optional play-list)
|
nil)
|
|#
|
|
#|
|
(defmethod Reset-Player ((self (eql 'soxplayer)) &optional view)
|
(declare (ignore view))
|
(print "resetting player")
|
(when (probe-file (outfile *sox-play-temp*)) (delete-file (outfile *sox-play-temp*)))
|
(setf *sox-play-list* nil)
|
t)
|
|#
|
|
#|
|
(defmethod player-record ((engine (eql :soxplayer)))
|
(setf *sox-temp-recorded-file*
|
(om-choose-new-file-dialog :prompt "Choose a name and location for the recorded audio file."
|
:directory (outfile nil)))
|
(when *sox-temp-recorded-file*
|
(sox-rec *sox-temp-recorded-file*)))
|
|
;;; must return the recorded object
|
(defmethod player-record-stop ((engine (eql :soxplayer)))
|
(sox-kill nil)
|
(probe-file *sox-temp-recorded-file*))
|
|
|
(defmethod audio-record-start ((self (eql 'soxplayer)))
|
(setf *sox-temp-recorded-file*
|
(om-choose-new-file-dialog :prompt "Choose a name and location for the recorded audio file."
|
:directory (outfile nil)))
|
(when *sox-temp-recorded-file*
|
(sox-rec *sox-temp-recorded-file*)))
|
|
(defmethod audio-record-stop ((self (eql 'soxplayer)))
|
(sox-kill nil)
|
(probe-file *sox-temp-recorded-file*))
|
|#
|
|
#|
|
(defmethod audio-record-start ((self (eql 'soxplayer)))
|
(setf *sox-temp-recorded-file*
|
(om-choose-new-file-dialog :prompt "Choose a name and location for the recorded audio file."
|
:directory (outfile nil)))
|
(when *sox-temp-recorded-file*
|
(sox-rec *sox-temp-recorded-file*)))
|
|
(defmethod audio-record-stop ((self (eql 'soxplayer)))
|
(sox-kill nil)
|
(probe-file *sox-temp-recorded-file*))
|
|#
|
|
; this needs to be redefined
|
|
#|
|
;;;;;
|
;;; SPECIFIES SOMETHING TO BE PLAYED ATHER A GIVEN DELAY (<at>) PAST THE CALL TO PLAYER-START
|
;;; THE DEFAULT BEHAVIOUR IS TO SCHEDULE 'player-play' AT DELAY
|
(defmethod prepare-to-play ((engine t) (player omplayer) object at interval)
|
(schedule-task player
|
#'(lambda ()
|
;(print (list object engine at interval))
|
(player-play-object engine object :interval interval))
|
at))
|
|
;;; PLAY (NOW)
|
(defmethod player-play-object ((engine t) object &key interval)
|
;(print (format nil "~A : play ~A - ~A" engine object interval))
|
t)
|
|
;;; START (PLAY WHAT IS SCHEDULED)
|
(defmethod player-start ((engine t) &optional play-list)
|
;(print (format nil "~A : start" engine))
|
t)
|
|
;;; PAUSE (all)
|
(defmethod player-pause ((engine t) &optional play-list)
|
;(print (format nil "~A : pause" engine))
|
t)
|
|
;;; CONTINUE (all)
|
(defmethod player-continue ((engine t) &optional play-list)
|
;(print (format nil "~A : continue" engine))
|
t)
|
|
;;; STOP (all)
|
(defmethod player-stop ((engine t) &optional play-list)
|
;(print (format nil "~A : stop" engine))
|
t)
|
|
;;; SET LOOP (called before play)
|
(defmethod player-set-loop ((engine t) &optional start end)
|
;(print (format nil "~A : set loop" engine))
|
t)
|
|
(defmethod player-loop ((engine t) &optional play-list)
|
;(print (format nil "~A : loop" engine))
|
t)
|
|
(defmethod player-record ((engine t))
|
;(print (format nil "~A : record" engine))
|
t)
|
|
;;; must return the recorded object
|
(defmethod player-record-stop ((engine t))
|
;(print (format nil "~A : record stop" engine))
|
nil)
|
|#
|
|
;######## METHODS FOR SOX-PLAY ###########
|
|
(defvar *sox-running-processes* nil "keeps a list of process-ids of currently running sox-processes")
|
|
; Q What is it that makes sox-play back only a subsection of a sound (selection) ... it's not 'clipping'
|
; This way we could implement pause & continue methods.
|
|
(defmethod! sox-play ((self string) &key clipping samplerate bitdepth gain pan)
|
:icon 07
|
:initvals '(nil nil nil nil nil nil)
|
:doc "Play back a sound using the OM-SoX library"
|
:numouts 1
|
(sox-play-print self)
|
(if (probe-file *sox-path*)
|
(let* ((inpath self))
|
(setf thestring (format nil "~s ~a ~s -q" (namestring *sox-path*) *sox-options* (namestring inpath)))
|
(setf thestring (sox-samplebits thestring bitdepth samplerate *sox-audio-device*))
|
(when clipping (setf thestring (string+ thestring
|
(format nil " trim ~d ~d " (first clipping) (- (second clipping) (first clipping))))))
|
|
; pan means that a sound is going to be panned between the two adjacent channels determined by the scalar.
|
; E.g. a value of 4.5 means between ch4 and ch5 (producing a 5-channel file) --> like the mix-console
|
|
(if pan
|
(progn
|
(sox-print "sox-play: Panning a sound")
|
(sox-play (sox-pan->sox-remix self gain pan) ;if both pan and gain it should go into the function directly, otherwise only gain
|
:clipping clipping :samplerate samplerate :bitdepth bitdepth)
|
)
|
|
(progn
|
(when gain (setf thestring (string+ thestring (format nil " gain ~d " gain))))
|
;(when *normalize* (setf thestring (string+ thestring " norm " (makestring *normalize-level*))))
|
|
(setf localpid (om-cmd-line thestring nil nil))
|
;(print thestring)
|
;(print localpid)
|
(setf *sox-running-processes* (x-append *sox-running-processes* localpid))
|
(om-run-process "remove-terminated-pid" #'sox-remove-pid
|
(if clipping (- (cadr clipping) (car clipping)) (sox-sound-duration self))
|
localpid)
|
)))
|
(sox-not-found))
|
self
|
)
|
|
(defmethod! sox-play ((self pathname) &key clipping samplerate bitdepth gain pan)
|
(sox-play (namestring self) :clipping clipping :samplerate samplerate :bitdepth bitdepth :gain gain :pan pan)
|
)
|
|
(defmethod! sox-play ((self list) &key clipping samplerate bitdepth gain pan)
|
(sox-play-print self)
|
(mapcar (lambda (thesound)
|
(sox-play thesound :clipping clipping :samplerate samplerate :bitdepth bitdepth :gain gain :pan pan)) self))
|
; (sox-play thesound :clipping clipping :samplerate samplerate :bitdepth bitdepth :gain gain :pan pan)) self))
|
|
(defmethod! sox-play ((self sound) &key clipping samplerate bitdepth gain pan)
|
(sox-play-print self)
|
(if (sound-path self)
|
(let ((gain (or gain (sox-vol-convert (vol self)))))
|
(if (equal (tracknum self) 0)
|
(sox-play (pathname (sound-path self))
|
:clipping clipping ;(or clipping (markers self))
|
:samplerate samplerate
|
:bitdepth bitdepth
|
:gain gain
|
:pan pan)
|
(sox-play (make-instance 'sox-pan
|
:sound self
|
:gains gain
|
:panning (or pan (+ (tracknum self) (* 0.01 (pan self))))
|
:clipping clipping
|
:samplerate samplerate
|
:bitdepth bitdepth)
|
)
|
)
|
)
|
(om-beep-msg (format nil "OM-SoX: Cannot play sound with path \"~s\"" (sound-path self)))
|
)
|
)
|
|
; ###### sox-mix #####
|
(defmethod! sox-play ((self sox-mix) &key clipping samplerate bitdepth gain pan)
|
(sox-play-print self)
|
(if (probe-file *sox-path*)
|
(let* ((pathlist (sound self))
|
(gainlist (db->lin (gains self))))
|
(setf thestring (format nil "~s ~a -m " (namestring *sox-path*) *sox-options*))
|
(loop for path in pathlist
|
for gain in gainlist do
|
(setf thestring (string+ thestring (format nil " -v~d ~s" gain (namestring path))))) ; could also be a pipe
|
(setf thestring (sox-samplebits thestring bitdepth samplerate *sox-audio-device*))
|
(when clipping (setf thestring (string+ thestring
|
(format nil " trim ~d ~d " (first clipping) (- (second clipping) (first clipping))))))
|
; (when *normalize* (setf thestring (string+ thestring " norm " (makestring *normalize-level*))))
|
(setf localpid (om-cmd-line thestring nil nil))
|
;(print thestring)
|
;(print localpid)
|
(setf *sox-running-processes* (x-append *sox-running-processes* localpid))
|
(om-run-process "remove-terminated-pid" #'sox-remove-pid
|
(if clipping (- (cadr clipping) (car clipping)) (list-max (sox-sound-duration (sound self))))
|
localpid)
|
)
|
(sox-not-found))
|
self
|
)
|
|
; ###### sox-merge #####
|
(defmethod! sox-play ((self sox-merge) &key clipping samplerate bitdepth gain pan)
|
(sox-play-print self)
|
(if (probe-file *sox-path*)
|
(let* ((pathlist (sound self))
|
(gainlist (db->lin (gains self))))
|
(setf thestring (format nil "~s ~a -M " (namestring *sox-path*) *sox-options*))
|
(loop for path in pathlist
|
for gain in gainlist do
|
(setf thestring (string+ thestring (format nil " -v~d ~s" gain (namestring path))))) ; could also be a pipe
|
(setf thestring (sox-samplebits thestring bitdepth samplerate *sox-audio-device*))
|
(when clipping (setf thestring (string+ thestring
|
(format nil " trim ~d ~d " (first clipping) (- (second clipping) (first clipping))))))
|
(setf localpid (om-cmd-line thestring nil nil))
|
;(print thestring)
|
;(print localpid)
|
(setf *sox-running-processes* (x-append *sox-running-processes* localpid))
|
(om-run-process "remove-terminated-pid" #'sox-remove-pid
|
(if clipping (- (cadr clipping) (car clipping)) (list-max (sox-sound-duration (sound self))))
|
localpid)
|
)
|
(sox-not-found))
|
self
|
)
|
|
; ###### sox-concatenate #####
|
(defmethod! sox-play ((self sox-concatenate) &key clipping samplerate bitdepth gain pan)
|
(sox-play-print self)
|
(if (probe-file *sox-path*)
|
(let* ((pathlist (sound self))
|
(gainlist (db->lin (gains self))))
|
(setf thestring (format nil "~s ~a " (namestring *sox-path*) *sox-options*))
|
(loop for path in pathlist
|
for gain in gainlist do
|
(setf thestring (string+ thestring (format nil " -v~d ~s" gain (namestring path)))))
|
(setf thestring (sox-samplebits thestring bitdepth samplerate *sox-audio-device*))
|
(when clipping (setf thestring (string+ thestring
|
(format nil " trim ~d ~d " (first clipping) (- (second clipping) (first clipping))))))
|
(setf localpid (om-cmd-line thestring nil nil))
|
;(print thestring)
|
(print localpid)
|
(setf *sox-running-processes* (x-append *sox-running-processes* localpid))
|
(om-run-process "remove-terminated-pid" #'sox-remove-pid
|
(if clipping (- (cadr clipping) (car clipping)) (list-max (sox-sound-duration (sound self))))
|
localpid)
|
)
|
(sox-not-found))
|
self
|
)
|
|
; ###### sox-splice #####
|
(defmethod! sox-play ((self sox-splice) &key clipping samplerate bitdepth gain pan)
|
(sox-play-print self)
|
(if (probe-file *sox-path*)
|
(let* ((pathlist (sound self))
|
(gainlist (db->lin (gains self))))
|
(setf thestring (format nil "~s ~a " (namestring *sox-path*) *sox-options*))
|
(loop for path in pathlist
|
for gain in gainlist do
|
(setf thestring (string+ thestring (format nil " -v~d ~s" gain (namestring path)))))
|
(setf thestring (sox-samplebits thestring bitdepth samplerate *sox-audio-device*))
|
(when clipping (setf thestring (string+ thestring
|
(format nil " trim ~d ~d " (first clipping) (- (second clipping) (first clipping))))))
|
(setf localpid (om-cmd-line thestring nil nil))
|
;(print thestring)
|
(print localpid)
|
(setf *sox-running-processes* (x-append *sox-running-processes* localpid))
|
(om-run-process "remove-terminated-pid" #'sox-remove-pid
|
(if clipping (- (cadr clipping) (car clipping)) (list-max (sox-sound-duration (sound self))))
|
localpid)
|
)
|
(sox-not-found))
|
self
|
)
|
|
; ###### sox-pan #####
|
(defmethod! sox-play ((self sox-pan) &key clipping samplerate bitdepth gain pan)
|
(sox-play-print self)
|
(sox-play (sox-pan->sox-remix (sound self) (car (list! (gains self))) (car (list! (panning self))) (numchannels self))
|
:clipping clipping
|
:samplerate samplerate
|
:bitdepth bitdepth
|
))
|
|
; ###### sox-remix #####
|
(defmethod! sox-play ((self sox-remix) &key clipping samplerate bitdepth gain pan)
|
(sox-play-print self)
|
(if (probe-file *sox-path*)
|
(let* ((inpath (sound self)))
|
(setf thestring (format nil "~s ~a ~s -q" (namestring *sox-path*) *sox-options* (namestring inpath)))
|
(setf thestring (sox-samplebits thestring bitdepth samplerate *sox-audio-device*))
|
(setf thestring (string+ thestring (format nil " remix ~a"
|
(sox-remixconc-no-norm (gain-matrix self) (channel-matrix self))
|
)))
|
|
(when clipping (setf thestring (string+ thestring
|
(format nil " trim ~d ~d " (first clipping) (- (second clipping) (first clipping))))))
|
; (when *normalize* (setf thestring (string+ thestring " norm " (makestring *normalize-level*))))
|
|
(setf localpid (om-cmd-line thestring nil nil))
|
;(print thestring)
|
;(print localpid)
|
(setf *sox-running-processes* (x-append *sox-running-processes* localpid))
|
(om-run-process "remove-terminated-pid" #'sox-remove-pid
|
(if clipping (- (cadr clipping) (car clipping)) (sox-sound-duration (sound self)))
|
localpid)
|
)
|
(sox-not-found))
|
self
|
)
|
|
; ###### sox-mix-console #####
|
(defmethod! sox-play ((self sox-mix-console) &key clipping samplerate bitdepth gain pan)
|
(sox-play-print self)
|
(if (probe-file *sox-path*)
|
(sox-play (make-instance 'sox-mix
|
:sound (sox-process (sox-pan->sox-remix (sound self) (gains self) (panning self)) ;(numchannels self))
|
""
|
:output "pipe")
|
)
|
:clipping clipping :samplerate samplerate :bitdepth bitdepth)
|
(sox-not-found))
|
self
|
)
|
|
;##### helper functions ################## -> probably better in utilities.
|
|
; basically, when connecting sox-record to a sox-input class it should allow for doing this.
|
|
;; recording function
|
(defmethod! sox-rec (filepath &key duration filetype samplerate bitdepth gain channel) ;better call it fileformat? or audioformat?
|
:icon 07
|
:initvals '(nil nil nil nil)
|
:menuins '((2 (("aif" "aif") ("wav" "wav") ("flac" "flac") ("ogg" "ogg"))))
|
:doc "records incoming audio through sox into a file"
|
:numouts 1
|
(if (probe-file *sox-path*)
|
(let* ((outpath (or filepath (om-choose-new-file-dialog :prompt "Choose a name and location for the recorded audio file"
|
:directory (outfile nil)))))
|
(when outpath
|
(setf outpath (om-make-pathname :directory (pathname-directory outpath)
|
:name (pathname-name outpath)
|
:type (or filetype (pathname-type outpath))));)
|
(setf thestring (format nil "~s -d" (namestring *sox-path*)))
|
(setf thestring (sox-samplebits thestring bitdepth samplerate outpath))
|
|
(when duration (setf thestring (string+ thestring (format nil " trim 0 ~d" duration))))
|
(when gain (setf thestring (string+ thestring (format nil " gain ~d " gain))))
|
(when channel (setf thestring (string+ thestring (format nil " remix ~a" channel))))
|
|
(setf localpid (om-cmd-line thestring nil nil))
|
;(print thestring)
|
(setf *sox-running-processes* (x-append *sox-running-processes* localpid))
|
(when duration (om-run-process "remove-terminated-pid" #'sox-remove-pid duration localpid))
|
; NB the soundobject throws an error if the soundfile is not there yet
|
outpath
|
))
|
(sox-not-found))
|
)
|
|
; ######### command-line functions ##########
|
; sox-kill terminates running sox play/rec processes
|
(defmethod! sox-kill (process-ids)
|
:icon 01
|
:initvals '(nil)
|
:numouts 1
|
#+win32(sys::call-system "taskkill /F /IM \"sox.exe\"")
|
#| some experiments to retrieve the pid from Windows DOS console
|
(sys::call-system "tasklist /v | find \"sox.exe\"")
|
(sys::call-system "tasklist /v | find \"sox.exe\" | taskkill /F /IM")
|
(om-cmd-line "tasklist /F /IM \"sox.exe\"" nil nil)
|
|#
|
#+(or macosx linux) (let ((pid-list (list! (or process-ids *sox-running-processes*))))
|
(loop for pid in pid-list do (om-cmd-line (format nil "kill ~d" pid) *sys-console*))
|
(setf *sox-running-processes* nil)
|
;(print (format nil "killed pids ~s" pid-list))
|
(when (om-find-process "remove-terminated-pid") (om-kill-process (om-find-process "remove-terminated-pid")))
|
)
|
)
|
|
(defun sox-remove-pid (wait-time localpid)
|
(sleep wait-time)
|
(sox-play-print (string+ "auto remove " (number-to-string localpid)))
|
(delete localpid *sox-running-processes*))
|
