There won't be any intermediary lazy collections, yes.

it has been a long time since I've messaged with streaming video, but I believe that partial seeking behavior is a property of the video file itself, I vaguely recall having to add hints to mp4 files

It seems to me that you would never be able to convert such a large number to a float, as it's greater than the maximum value a float can have (~3.4 x 10^38)

Just to make it more obvious - @U0CAUAKCG, there's E in that number, which makes it quite huge.

You could check if the value you're converting is greater than the float limit, and then return the float limit if true.

(defn to-float [x]
  (if (> x Float/MAX_VALUE) Float/MAX_VALUE
    (if (< x Float/MIN_VALUE) Float/MIN_VALUE
      (float x))))

ahhh i see, good idea. I'm processing double float audio buffers from one jna to another, so a performance is also a factor. I'll check

thanks @U016UGGNXB3 this works! It's a good safety net, otoh, just realised that this is a positive exponent not negative, so this is a huge number, which does not fit in the context of normalized audio signal from -1 to 1. So I'm reading wrong memory 😛

I looked through the Google Groups archive and didn't see any responses from any of the core team on any thread where this has come up -- and it's come up in various forms half a dozen times since CLJ-200 originated (11 years ago).

I wonder if @alexmiller has any insight into this? (He commented last on that ticket, after it had been closed)

I think the general comment is that we don't agree those things are necessarily better or needed

but if you want them, then use better-cond

for me personally, I'd rather have less things in cond :)

I have commented a few times on similar proposals that I just don't find better-cond to actually be better -- I find it harder to read, but then I find doseq and for harder to read when they're full of :let / :when etc 🙂

ditto

less is more in this area for me

interesting, thanks 👍:skin-tone-2:

this would be the function I use to make the callback

(defn set-process-callback
  [^JackLibrary$_jack_client jack-client callback]
  (let [cb ^JackLibrary$JackProcessCallback
        (reify JackLibrary$JackProcessCallback
          (^int invoke [_ ^int nframes] (callback nframes)))]
    (.jack_set_process_callback ^JackLibraryDirect jack-lib jack-client cb nil)))

(def audio-callback (atom nil))

You might want to look into how this sort of issue is handled in libpython-clj: https://github.com/clj-python/libpython-clj

thanks a lot! this is perfect, thirsty for any suggestions!

you can create a strong reference by keeping a reference to it. The easiest way might be something like:

(def callback-refs (atom #{}))
(defn set-process-callback
  [^JackLibrary$_jack_client jack-client callback]
  (let [cb ^JackLibrary$JackProcessCallback
        (reify JackLibrary$JackProcessCallback
          (^int invoke [_ ^int nframes] (callback nframes)))]
    (swap! callback-refs conj cb )
    (.jack_set_process_callback ^JackLibraryDirect jack-lib jack-client cb nil)))

@U7RJTCH6J that I already tried, at least with the toplevel atom. I would consider that strong too. So I'm equally confused. But afaik from reading, java considers anything not "final" a soft reference, and will gc all of them if it needs memory.

this is usually fine, but with native pointers, this causes big problems

I was reading this here, https://blog.shiftleft.io/understanding-jvm-soft-references-for-great-good-and-building-a-cache-244a4f7bb85d also looking at cpython's bindings, entirely written in java, it seems I need to get java on this one

I use jna and a top level atom has worked every time

> But afaik from reading, java considers anything not "final" a soft reference, and will gc all of them if it needs memory. I think that only applies to java code. the garbage collector will not collect objects referenced in top level atoms or else that would break a ton of clojure code

I'm making another test with top-level atom. I'm not an jvm expert, but could it be that the jvm pointer can be thrown around while the native ones are constant? That could explain wild gc's behavior, but this is way above my knowledge on jvm

what's JackLibrary?

https://github.com/jaudiolibs/jnajack

I'm only using the lowlevel/* for now, some functions there which I need which haven't been wrapped, also don't like OOP style wrapping anyway 😛

yea, I might just use jna directly

i've been using https://github.com/Chouser/clojure-jna/

I think libpython-clj has their own associated jna wrapper

so it happened again

(def callbacks (atom #{}))

;;under let
        audio-callback (csound-process
                        csnd
                        jack-ports-in
                        jack-ports-out
                        ksmps-rate)
        on-registration (fn [_] (reset! status :running))
        on-unregistration (fn [_]
                            (stop @csnd)
                            (cleanup @csnd))
        client-reg-cb (jack/make-client-registration-callback
                       {:on-registration on-registration
                        :on-unregistration on-unregistration})
       
        ]
    (apply swap! callbacks conj [audio-callback on-registration on-unregistration client-reg-cb])

I think this is the audio-callback mainly, because it wont get called, just dies ....

hmmm

the other thing that's easy to mess up is passing the wrong type. jna will automatically convert types, but if you pass 42 , that will be long when it might be expecting a float or an int

I'm putting my life on (set! *warn-on-reflection* true) for that 🙂 hope it's enough

but you mean jna may be operating differently?

that is not enough

I don't think, anyway

good to know, I'll try being totally explicit

I've been using jna directly, which will definitely crash when passed the wrong number type. I'm not sure how it works if you're using jna through some java stuff

I believe I found the problem in the end!

now this is local scoped

audio-callback (reify JackLibrary$JackProcessCallback
                         (^int invoke [_ ^int nframes]
                          (loop [status (perform-ksmps @csnd)

(defn set-process-callback
  [^JackLibrary$_jack_client jack-client callback]
  (let [cb ^JackLibrary$JackProcessCallback
        (reify JackLibrary$JackProcessCallback
          (^int invoke [_ ^int nframes] (callback nframes)))]
    (.jack_set_process_callback ^JackLibraryDirect jack-lib jack-client cb nil)))

@U0CAUAKCG real quick and dirty solution

Just memoize that function

(def set-process-callback (memoize set-process-callback))

If there is no way for callbacks to be removed you don't have to worry about the semantics of repeated calls

that sounds like the kind of answer I was most looking for! thanks for chipping in!

I've started using clojure.zip for similar treewalking examples

i would like to avoid using zippers here

what the nested reduce look like?

(apply merge-with into
       (for [a [{:x  {:id "123"}
                 :ys [{:type "Bar"
                       :y    "42"}
                      {:type "Foo"}
                      {:type "Bar"
                       :y    "43"}]},
                {:x  {:id "456"}
                 :ys [{:type "Bar"
                       :y    "42"}
                      {:type "Foo"}
                      {:type "Bar"
                       :y    "43"}]}
                {:x  {:id "789"}
                 :ys [{:type "Bar"
                       :y    "99"}]}]
             b (:ys a)
             :when (:y b)]
         {(:y b) [(:id (:x a))]}))

hiredman, Comprehender of the List Comprehension

the nested reduce looked like shit

thanks @U0NCTKEV8

i was sort of kind of close before i switched to trying the nested reduce, but I missed the apply merge-with into