(ns clojureDemo.VideoParse)

   

  

 

 ;this file is not used anymore, except for the (display %) function.

 

 

 

 (import '(java.awt Rectangle Robot Toolkit) )

 (import '(java.awt.image BufferedImage) )

 (import '(java.awt Graphics2D Panel))

 (import '(java.io File) )

 (import '(javax.imageio ImageIO) )

 (import '(com.xuggle.mediatool ToolFactory))

 (import '(com.xuggle.mediatool IMediaDebugListener IMediaDebugListener$Event))

 (import '(com.xuggle.mediatool MediaToolAdapter))

 (import '(com.xuggle.xuggler IContainer IContainer$Type IPacket))

 (import '(javax.swing JFrame))

 

 (import clojure.lang.LazySeq)

 

 (import '(name.audet.samuel.javacv.jna highgui cv cxcore))

 

 (import '(name.audet.samuel.javacv CanvasFrame))

 

 (import '(name.audet.samuel.javacv.jna cxcore$IplImage))

 

 (import '(name.audet.samuel.javacv.jna highgui$CvCapture$PointerByReference))

 (import '(name.audet.samuel.javacv.jna highgui$CvVideoWriter$PointerByReference))

 

 ;definitions

 

 (def -inf Double/NEGATIVE_INFINITY)

 (def inf  Double/POSITIVE_INFINITY)

 

 (use 'clojure.contrib.repl-utils)

 

 

 ;minor functions

 

 (defn converge

   "recursively runs update until prior passes accept, then returns"

   [prior update accept]

   (if (accept prior) prior (recur (update prior) update accept)))

 

 (defn interval-width [interval] (- (last interval) (first interval)))

 

 (defn midpoint [interval] 

   (let [a (first interval) b (last interval)]

     (if (and (= a -inf) (= b inf)) 0

     (if (= a -inf) (midpoint [(- b 200000) b])

 	(if (= b inf) (midpoint [a (+ a 200000)])

 	    (int (/ (+ a b) 2)))))))

 

 (defn cart2

   "calculates the cartesian product in 2 dimensions"

   [point] 

   (let [[x y] point] (for [abscissa (range x) ordinate (range y)] [abscissa ordinate])))

 

 (defn closeCapture

   [capture]

   (highgui/cvReleaseCapture (highgui$CvCapture$PointerByReference. capture)))

 

 (defn- makePanel [image] (proxy [Panel] [] (paint [g]  (.drawImage g image 0 0 nil))))

 

 (defn screenshot "grab screenshot" [] 

   

   (ImageIO/write

    (.createScreenCapture (Robot.) (Rectangle. (.getScreenSize (Toolkit/getDefaultToolkit))))

    "JPG"

    (File. "/home/r/Desktop/screenie.jpg")))

 

 (defn- readerRecurse

   "calls .readPacket until there's nothing left to do"

   [reader]

   (if (not (nil? (.readPacket reader))) ; here .readPacket actually does the processing as a side-effect.

     nil                                   ; it returns null when it has MORE to process, and signals an error when done... 

     (recur reader)))

 

 (defmacro times

   "perform multiple timed tests on a form"

   [n form]

   `(dotimes [_# ~n] (time ~form)))

   

 (defmacro me-1

   "does macroexpand-1 without having to quote the form"

   [form]

   (list 'macroexpand-1 (list 'quote form)))

 

 ;Major Functions

 

 (defmulti  display "Creates a JFrame and displays a buffered image"  class)

 

 (defmethod display 

   BufferedImage  [image] 

   (let [panel (makePanel image)

 	frame (JFrame. "Oh Yeah!")]

     (.add frame panel) 

     (.pack frame) 

     (.setVisible frame true ) 

     (.setSize frame(.getWidth image) (.getHeight image))))

 

 (defmethod display

   cxcore$IplImage [image]

   ( display (.getBufferedImage image)))

   

 (defmethod display

   String [image]

   (display (highgui/cvLoadImage image highgui/CV_LOAD_IMAGE_COLOR)))

 

 (defmethod display

   LazySeq [s]

   (display (first s)))

 

 

 (defn convert

   "takes video and converts it to a new type of video"

   [videoInput videoOutput]

   (let [reader (ToolFactory/makeReader videoInput)]

     (doto reader

       (.addListener (ToolFactory/makeWriter videoOutput reader))

       (.addListener (ToolFactory/makeDebugListener (into-array [IMediaDebugListener$Event/META_DATA]))))

     (readerRecurse reader)))

 

 

 

 (defn video-frame

   ":("

   [video frame]

   (lazy-seq

    (try 

     (let [capture (highgui/cvCreateFileCapture video)]

       (highgui/cvSetCaptureProperty capture highgui/CV_CAP_PROP_POS_FRAMES frame)

       (println (str "Wanted frame <" frame "> but went to keyFrame " (highgui/cvGetCaptureProperty capture highgui/CV_CAP_PROP_POS_FRAMES)))

       (let [out (highgui/cvQueryFrame capture)

 	    image (.clone  out)]

 	(highgui/cvReleaseCapture (highgui$CvCapture$PointerByReference. capture))

 	[image]))

     (catch java.lang.NullPointerException _ nil))))

 

 

   

 

 (defn save-frame

   "takes an opencv image and saves it to disk"

   [frame filename]

   (highgui/cvSaveImage filename frame))

 

 

 (defn video-len

   "finds out the real length of a video in log time."

   [video]

   (letfn

       [

        (accept [interval] (= 0 (interval-width interval)))

        (update [interval]

 	       (let [[a b] interval]

 		 (if (> (interval-width interval) 2)

 		   (let [

 			 middle (midpoint interval)

 			 frame (first (video-frame video middle))

 			 ]

 		     (if (nil? frame) [a middle] [middle b]))

 		   [a a])))

        ]

        

    (first (converge [-inf inf] update accept))))

 (def video-len (memoize video-len))

 

 

 

 (defn getData

   "returns a bunch of stuff about a video"

   [video]

   (let

       [capture (highgui/cvCreateFileCapture video)

        info {:frames      (video-len video)

 	     :width       (highgui/cvGetCaptureProperty capture highgui/CV_CAP_PROP_FRAME_WIDTH)

 	     :height      (highgui/cvGetCaptureProperty capture highgui/CV_CAP_PROP_FRAME_HEIGHT)

 	     :fps         (highgui/cvGetCaptureProperty capture highgui/CV_CAP_PROP_FPS)

 	     :codec       (highgui/cvGetCaptureProperty capture highgui/CV_CAP_PROP_FOURCC)}]

       

     (closeCapture capture)

     info))

 (def getData (memoize getData))

   

 

 (defn sajitify-linear

   "oh yeah!"

   [video string]

   (let [ capture (highgui/cvCreateFileCapture video)

 	frames (:frames (getData video))]

        (dotimes [n frames]

 	 (highgui/cvSaveImage (str string  (format "%06d" n) ".jpg") (highgui/cvQueryFrame capture)))

        (highgui/cvReleaseCapture (highgui$CvCapture$PointerByReference. capture))))

 

 (defn getFrame

   "gets the frame of a video at the specified time in seconds.

   this works with the simplest interpolation --- just piecewise steps"

   [video time]

   (lazy-seq

   [time  (video-frame video (int (* time (:fps (getData video)))))]))

 

 (defn video-seq-times

   "it's the new and improved version of videoSeq, now using OpenCv.

   we expect a sequence of times in seconds"

   [times video]

   (map #(getFrame video %) times))

 

 (defn video-seq

   "get's ALL the frames of a video as a lazy sequence of (IplImages)"

   [video] 

   (take (:frames (getData video))   (map #(video-frame video %) (iterate inc 0))))

 

 (defn trans-Writer

   "uses data about the video to make a writer"

   [video fileTarget]

   (let [data (getData video)]

   (highgui/cvCreateVideoWriter fileTarget (highgui/CV_FOURCC "F" "L" "V" "1") (:fps data) (cxcore/cvSize (:width data) (:height data)) 1)))

 

 (def naturals (iterate inc 0))

 

 (defn sajitify-seq

   [video string]

   (dorun (map #(highgui/cvSaveImage (str string  (format "%06d" %2) ".jpg") (first %1)) (video-seq video) naturals)))