(ns com.aurellem.run.final-cut

   (:use (com.aurellem.gb saves gb-driver util constants

                          items vbm characters money

                          rlm-assembly))

   (:use (com.aurellem.run util sound music title save-corruption

                           bootstrap-0 bootstrap-1

                           ram-display

                           ))

   (:require clojure.string)

   (:import [com.aurellem.gb.gb_driver SaveState])

   (:import java.awt.image.BufferedImage)

   (:import java.io.File)

   (:import com.aurellem.gb.WaveWriter))

 

 

 (def render-dir (File. user-home "proj/vba-clojure/render/test"))

 

 (defn write-move-image! [move target-file]

   (let [actual-keys (set move)

         keys [:a :b :start :select :u :d :l :r]

         button-on-name  ["-size" "5x5" "xc:red"]

         button-off-name ["-size" "5x5" "xc:white"]]

     (apply

      clojure.java.shell/sh

      (flatten 

       ["convert"

        "-size" "64x5" "xc:white"

        (map

         (fn [index]

           (let [position ["-geometry"

                           (str "+" (* index 8)

                                "+" "0") "-composite"]]

             (if (actual-keys (keys index))

               [button-on-name  position]

               [button-off-name position])))

         (range (count keys)))

        (.getCanonicalPath target-file)]))))

 

 (defn render-files!

   ([^File target-dir initial-state moves]

      (let [ram-map-dir (File. target-dir "ram-map")

            frames-dir (File. target-dir "frames")

            moves-dir (File. target-dir "moves")

            audio-file (File. target-dir "audio.wav")

            _ (.mkdir target-dir)

            _ (.mkdir ram-map-dir)

            _ (.mkdir frames-dir)

            _ (.mkdir moves-dir)

            wave-writer (WaveWriter. audio-file)

            moves (vec moves)

            desired-fps 60

            seconds-per-frame (/ 1.0 desired-fps)]

        (set-state! initial-state)

        ;; clear sound buffer

        (sound-bytes)

        (try 

          (dorun

           (reduce

            (fn [[total-audio-samples

                  total-video-samples] move]

              (run-moves @current-state (vector move))

              (let [sound (sound-bytes)

                    total-audio-samples (+ total-audio-samples

                                           (count sound))

                    total-audio-time

                    (*

                     (/ total-audio-samples 4)

                     (/ 44100))

                    

                    total-video-time (* total-video-samples

                                        seconds-per-frame)

 

                    av-diff (- total-audio-time

                               total-video-time)

                    write-video!

                    (fn [index]

                      ;; write screenshot

                      (write-move-image!

                       move

                       (File. moves-dir (format "%07d.png" index)))

                      

                      (write-png!

                       @current-state

                       (File. frames-dir (format "%07d.png" index)))

                      

                      ;; write ram-image

                      (write-ram-image!

                       @current-state

                       (File. ram-map-dir (format "%07d.png" index))))]

                ;;(println "audio-samples:" (count sound))

                

                ;; record audio

                (.process wave-writer sound gb-sound-format)

                

                ;; duplicate or drop frames depending on

                ;; desired-fps

                (if (> (Math/abs av-diff) (* 2 seconds-per-frame))

                  (if (<  0 av-diff)

                    ;; audio has gone past video, duplicate video.

                    (do (println

                         "duplicating frame, av-diff is" av-diff)

                        (write-video! (+ 1 total-video-samples))

                        (write-video! (+ 2 total-video-samples))

                        [total-audio-samples

                         (+ 2 total-video-samples)])

                    ;; video has gone past audio, drop frame.

                    (do (println

                         "dropping frame, av-diff is" av-diff)

                        [total-audio-samples

                         total-video-samples]))

                  ;; no frame dropping or duplication required.

                  (do ;;(println "all normal")

                      (write-video! (+ 1 total-video-samples))

                      [total-audio-samples

                       (+ 1 total-video-samples)]))))

            [0 0 0] moves))

          (finally

            (do

              (println "cleanup audio.")

              (.cleanup wave-writer))))))

      ([initial-state moves]

         (render-files! render-dir initial-state moves))

      ([moves]

         (render-files! (root) moves)))

 

 (defn file-names [#^File dir]

    (mapv #(.getCanonicalPath %) (next (sort (file-seq dir)))))

 

 (defn composite-frames-command

   [move-image screenshot ram-map target]

   ["convert"

    "-size" "318x276" "xc:white"

    move-image   "-geometry" "+30+225" "-composite"

    screenshot   "-geometry" "+10+10"  "-composite"

    ram-map      "-geometry" "+180+10" "-composite"

    target])

 

 (defn generate-composite-frames!

   [^File rendered-dir]

   (let [final-frames (File. rendered-dir "final")

         _ (.mkdir final-frames)

         move-images (file-names (File. rendered-dir "moves"))

         screenshots (file-names (File. rendered-dir "frames"))

         ram-maps    (file-names (File. rendered-dir "ram-map"))

         targets (map #(.getCanonicalPath

                        (File. final-frames (format "%07d.bmp" %)))

                      (range (count screenshots)))]

     (dorun

      (map

       (comp

        (partial apply clojure.java.shell/sh)

        flatten

        (partial apply composite-frames-command)

        (fn [a b c d] (println d) [a b c d]))

       move-images screenshots ram-maps targets))))

 

 

 ;; (defn final-cut! [^File render-dir]

 ;;   (let [movie (File. render-dir "final.ogg")

 ;;         final-audio (File. render-dir "final.wav")

 ;;         final (File. render-dir "final")]

 ;;     (.delete movie)

 ;;     (.delete final-audio)

 ;;     (clojure.java.shell/sh

 ;;      "sox" (.getCanonicalPath (File. render-dir "audio.wav"))

 ;;      (.getCanonicalPath final-audio))

 ;;     (clojure.java.shell/sh

 ;;      "ffmpeg" "-r" "60" ;; maybe 59.7 ???!

 ;;      "-i" (str (.getCanonicalPath final) "/" "%07d.bmp")

 ;;      "-i" (.getCanonicalPath final-audio)

 ;;      "-b:a" "128k"

 ;;      "-b:v" "9000k"

 ;;      "-c:a" "libvorbis"

 ;;      "-f"   "webm"

 ;;      "-g"   "200"

 ;;      (.getCanonicalPath movie)) nil))

 

 (defn final-cut! [^File render-dir]

   (let [movie (File. render-dir "final.ogg")

         final-audio (File. render-dir "final.wav")

         final (File. render-dir "final")]

     (.delete movie)

     (.delete final-audio)

     (clojure.java.shell/sh

      "sox" (.getCanonicalPath (File. render-dir "audio.wav"))

      (.getCanonicalPath final-audio))

     (clojure.java.shell/sh

      "ffmpeg"

      "-framerate" "60" 

      "-i" (str (.getCanonicalPath final) "/" "%07d.bmp")

      "-i" (.getCanonicalPath final-audio)

      "-b:a" "128k"

      "-b:v" "9000k"

      "-c:a" "libvorbis"

      "-c:v" "libtheora"

      "-r" "60"

      (.getCanonicalPath movie)) nil))

 

   

 (comment

 

   ;; step 1

   

   (render-files!

    render-dir (root)

    (take 9000 (first (control-checkpoint))))

 

   ;; step 2

   

   (generate-composite-frames!

    render-dir 

    (take 9000 (first (control-checkpoint))))

 

   ;; step 3

   (final-cut! render-dir)

   )