Code for reading and parsing video data in Parrot Video Encapsulated (PaVE) format, which is the format of the drone’s video stream.

Typically you will do something like the following to process drone video:

• Create a frame queue (make-frame-queue), a video input stream (video-input-stream), and a video decoder (see e.g. the turboshrimp-xuggler library).

• Create a thread that calls read-frame on the input stream and uses queue-frame to put frames in the queue.

• Create another thread that uses pull-frame to get a video frame from the queue and then uses the decoder to decode the frame into an image.

The following example code follows this pattern. It also puts the decoded images into an async channel, from which presumably another thread will get the images and display them on screen.

(let [queue (pave/make-frame-queue)
      input-stream (turboshrimp/video-input-stream my-drone)
      decoder (xuggler/decoder)
      ;; Create an async channel with a sliding buffer of size 1; If
      ;; our image rendering is slow this will drop frames, which is
      ;; good.
      image-channel (async/chan (async/sliding-buffer 1))]
  (doto (Thread.
         (fn []
           (loop [frame (pave/read-frame input-stream)]
             (when frame
               (pave/queue-frame queue frame))
             (recur (pave/read-frame input-stream)))))
    (.start))
  (doto (Thread.
         (fn []
           (loop [frame (pave/pull-frame queue 1000)]
             (when frame
               (let [^BufferedImage image (decoder frame)]
                 (a/go
                   (a/>! image-channel image))))
             (recur (pave/pull-frame queue 1000)))))
    (.start)))