cl-xine.lisp

cl-xine.lisp

;;;;
;;;; cl-xine.lisp
;;;;
;;;; Time-stamp: <2008-11-09 11:23:11 danlei>
;;;;

(defpackage #:cl-xine
  (:use #:common-lisp
	#:cffi))

(in-package #:cl-xine)

(define-foreign-library libxine
  (:linux (:or "libxine.so.1" "libxine"))
  (t (:default "libxine")))

(defctype xine :pointer)
(defctype xine-audio-port :pointer)
(defctype xine-video-port :pointer)
(defctype xine-stream :pointer)

;; audio-only
(defconstant +xine-visual-type-none+ 0)

;; xine stream parameters
(defconstant +xine-param-audio-volume+ 6)
(defconstant +xine-param-audio-mute+ 7)

(defparameter *libxine* nil)
(defparameter *engine* nil)
(defparameter *audio-port* nil)
(defparameter *video-port* nil)
(defparameter *stream* nil)

(defcfun "xine_new" xine)

(defcfun "xine_init" :int
  (engine xine))

(defcfun "xine_open_audio_driver" xine-audio-port
  (engine xine)
  (id :pointer)
  (data :pointer))

(defcfun "xine_open_video_driver" xine-video-port
  (engine xine)
  (id :pointer)
  (visual :int)
  (data :pointer))

(defcfun "xine_stream_new" xine-stream
  (engine xine)
  (audio-port xine-audio-port)
  (video-port xine-video-port))

(defcfun "xine_open" :int
  (stream xine-stream)
  (mrl :string))

(defcfun "xine_play" :int
  (stream xine-stream)
  (position :int)
  (time :int))

(defcfun "xine_stop" :void
  (stream xine-stream))

(defcfun "xine_dispose" :void
  "Stops playback, disposes all stream-related resources.
xine-stream is no longer valid after this."
  (stream xine-stream))

(defcfun "xine_set_param" :void
  (stream xine-stream)
  (param :int)
  (value :int))

(defcfun "xine_get_param" :int
  (stream xine-stream)
  (param :int))

(defcfun "xine_close" :int
  (stream xine-stream))

(defcfun "xine_close_video_driver" :int
  (engine xine)
  (video-port xine-video-port))

(defcfun "xine_close_audio_driver" :int
  (engine xine)
  (audio-port xine-audio-port))

(defcfun "xine_exit" :int
  (engine xine))

(defun open-mrl (mrl)
  (xine-open *stream* mrl))

(defun play (start &optional (start-time 0))
  (xine-play *stream* start start-time))

(defun stop ()
  (xine-stop *stream*))

(defun volume (&optional volume)
  (if volume
      (xine-set-param *stream* +xine-param-audio-volume+ volume)
      (xine-get-param *stream* +xine-param-audio-volume+)))

;; buggy
(defun mute ()
  (if (= (xine-get-param *stream* +xine-param-audio-mute+)
	 0)
      (xine-set-param *stream* +xine-param-audio-mute+ 1)
      (xine-set-param *stream* +xine-param-audio-mute+ 0)))

(defun xine-initialize-audio-only ()
  (setq *libxine* (use-foreign-library libxine))
  (setq *engine* (xine-new))
  (xine-init *engine*)
  (setq *audio-port* (xine-open-audio-driver *engine*
					     (null-pointer)
					     (null-pointer)))
  (setq *video-port* (xine-open-video-driver *engine*
					     (null-pointer)
					     +xine-visual-type-none+
					     (null-pointer)))
  (setq *stream* (xine-stream-new *engine* *audio-port* *video-port*)))

(defun xine-clean-up ()
  (xine-close *stream*)
  (xine-close-video-driver *engine* *video-port*)
  (xine-close-audio-driver *engine* *audio-port*)
  (xine-exit *engine*)
  (close-foreign-library *libxine*))