;;;
;;; sdl-mixer-lib.stub - glue functions for SDL_mixer
;;;
;;;  Copyright(C) 2003 by Michael Vess (mvess@michaelvess.com)
;;;
;;;  Permission to use, copy, modify, distribute this software and
;;;  accompanying documentation for any purpose is hereby granted,
;;;  provided that existing copyright notices are retained in all
;;;  copies and that this notice is included verbatim in all
;;;  distributions.
;;;  This software is provided as is, without express or implied
;;;  warranty.  In no circumstances the author(s) shall be liable
;;;  for any damages arising out of the use of this software.
;;;
;;;  $Id: sdl-mixer-lib.stub,v 1.4 2003/02/25 02:21:07 mikiso Exp $
;;;

"
#include \"gauche-sdl-mixer.h\"
"

;;=============================================================
;; Miscellaneous
;;

(define-type <u8vector> "ScmU8Vector*" "u8vector"
  "SCM_U8VECTORP" "SCM_U8VECTOR")



;;=============================================================
;; Chunk
;;

(define-type <mix-chunk> "Mix_Chunk*" #f
  "SCM_MIX_CHUNK_P" "SCM_MIX_CHUNK")

(define-cproc mix-chunk? (obj)
  (return <boolean> "SCM_MIX_CHUNK_P"))


;;=============================================================
;; Music
;;

(define-type <mix-music> "Mix_Music*" #f
  "SCM_MIX_MUSIC_P" "SCM_MIX_MUSIC")

(define-cproc mix-music? (obj)
  (return <boolean> "SCM_MIX_MUSIC_P"))


;;=============================================================
;; RWops
;;

(define-type <sdl-rwops> "SDL_RWops*" #f
  "SCM_SDL_RWOPS_P" "SCM_SDL_RWOPS")

(define-type <sdl-rwops>-or-null "SDL_RWops*" #f
  "SCM_SDL_RWOPS_OR_NULL_P" "SCM_SDL_RWOPS_OR_NULL")

(define-cproc sdl-rwops? (obj)
  (return <boolean> "SCM_SDL_RWOPS_P"))


;;=============================================================
;; Functions
;;

(define-cproc mix-open-audio (frequency::<int> format::<uint> channels::<int>
                              chunksize::<int>)
  (return <int> "Mix_OpenAudio"))

(define-cproc mix-allocate-channels (numchans::<int>)
  (return <int> "Mix_AllocateChannels"))

(define-cproc mix-query-spec ()
  "int freq, channels;
   Uint16 format;

   int result = Mix_QuerySpec(&freq, &format, &channels);

   if (result == 0) SCM_RETURN(SCM_UNDEFINED);

   SCM_RETURN(SCM_LIST3(SCM_MAKE_INT(freq), SCM_MAKE_INT(format),
                        SCM_MAKE_INT(channels)));")

(define-cproc mix-load-wav-rw (src::<sdl-rwops>)
  "ScmMixChunk *s = SCM_NEW(ScmMixChunk);
   SCM_SET_CLASS(s, SCM_CLASS_MIX_CHUNK);
   s->chunk = Mix_LoadWAV_RW(src, 0);
   Scm_RegisterFinalizer(SCM_OBJ(s), mix_chunk_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc mix-load-wav (file::<string>)
  "ScmMixChunk *s = SCM_NEW(ScmMixChunk);
   SCM_SET_CLASS(s, SCM_CLASS_MIX_CHUNK);
   s->chunk = Mix_LoadWAV(Scm_GetStringConst(file));
   Scm_RegisterFinalizer(SCM_OBJ(s), mix_chunk_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc mix-load-mus (file::<string>)
  "ScmMixMusic *s = SCM_NEW(ScmMixMusic);
   SCM_SET_CLASS(s, SCM_CLASS_MIX_MUSIC);
   s->music = Mix_LoadMUS(Scm_GetStringConst(file));
   Scm_RegisterFinalizer(SCM_OBJ(s), mix_music_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc mix-quick-load-wav (mem::<u8vector>)
  "ScmMixChunk *s = SCM_NEW(ScmMixChunk);
   SCM_SET_CLASS(s, SCM_CLASS_MIX_CHUNK);
   s->chunk = Mix_QuickLoad_WAV(SCM_U8VECTOR_ELEMENTS(mem));
   Scm_RegisterFinalizer(SCM_OBJ(s), mix_chunk_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc mix-quick-load-RAW (mem::<u8vector>)
  "ScmMixChunk *s = SCM_NEW(ScmMixChunk);
   SCM_SET_CLASS(s, SCM_CLASS_MIX_CHUNK);
   s->chunk = Mix_QuickLoad_RAW(SCM_U8VECTOR_ELEMENTS(mem), SCM_U8VECTOR_SIZE(mem));
   Scm_RegisterFinalizer(SCM_OBJ(s), mix_chunk_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc mix-get-music-type (music::<mix-music>)
  (return <int> "Mix_GetMusicType"))

;; MISSING:
;; MISSING: Mix_SetPostMix
;; MISSING:

;; MISSING:
;; MISSING: Mix_HookMusic
;; MISSING:

;; MISSING:
;; MISSING: Mix_HookMusicFinished
;; MISSING:

;; MISSING:
;; MISSING: Mix_GetMusicHookData
;; MISSING:

;; MISSING:
;; MISSING: Mix_ChannelFinished
;; MISSING:

;; MISSING:
;; MISSING: Mix_RegisterEffect
;; MISSING:

;; MISSING:
;; MISSING: Mix_UnregisterEffect
;; MISSING:

(define-cproc mix-unregister-all-effects (channel::<int>)
  (return <int> "Mix_UnregisterAllEffects"))

(define-cproc mix-set-panning (channel::<int> left::<uint> right::<uint>)
  (return <int> "Mix_SetPanning"))

(define-cproc mix-set-position (channel::<int> angle::<int> distance::<uint>)
  (return <int> "Mix_SetPosition"))

(define-cproc mix-set-distance (channel::<int> distance::<uint>)
  (return <int> "Mix_SetDistance"))

(define-cproc mix-set-reverse-stereo (channel::<int> flip::<int>)
  (return <int> "Mix_SetReverseStereo"))

(define-cproc mix-reserve-channels (num::<int>)
  (return <int> "Mix_ReserveChannels"))

(define-cproc mix-group-channel (which::<int> tag::<int>)
  (return <int> "Mix_GroupChannel"))

(define-cproc mix-group-channels (from::<int> to::<int> tag::<int>)
  (return <int> "Mix_GroupChannels"))

(define-cproc mix-group-available (tag::<int>)
  (return <int> "Mix_GroupAvailable"))

(define-cproc mix-group-count (tag::<int>)
  (return <int> "Mix_GroupCount"))

(define-cproc mix-group-oldest (tag::<int>)
  (return <int> "Mix_GroupOldest"))

(define-cproc mix-group-newer (tag::<int>)
  (return <int> "Mix_GroupNewer"))

(define-cproc mix-play-channel (channel::<int> chunk::<mix-chunk>
                                loops::<int>)
  (return <int> "Mix_PlayChannel"))

(define-cproc mix-play-channel-timed (channel::<int> chunk::<mix-chunk>
                                      loops::<int> ticks::<int>)
  (return <int> "Mix_PlayChannelTimed"))

(define-cproc mix-play-music (music::<mix-music> loops::<int>)
  (return <int> "Mix_PlayMusic"))

(define-cproc mix-fade-in-music (music::<mix-music> loops::<int> ms::<int>)
  (return <int> "Mix_FadeInMusic"))

(define-cproc mix-fade-in-music-pos (music::<mix-music> loops::<int> ms::<int>
                                     position::<float>)
  (return <int> "Mix_FadeInMusicPos"))

(define-cproc mix-fade-in-channel (channel::<int> chunk::<mix-chunk>
                                   loops::<int> ms::<int>)
  (return <int> "Mix_FadeInChannel"))

(define-cproc mix-fade-in-channel-timed (channel::<int> chunk::<mix-chunk>
                                         loops::<int> ms::<int> ticks::<int>)
  (return <int> "Mix_FadeInChannelTimed"))

(define-cproc mix-volume (channel::<int> volume::<int>)
  (return <int> "Mix_Volume"))

(define-cproc mix-volume-chunk (chunk::<mix-chunk> volume::<int>)
  (return <int> "Mix_VolumeChunk"))

(define-cproc mix-volume-music (volume::<int>)
  (return <int> "Mix_VolumeMusic"))

(define-cproc mix-halt-channel (channel::<int>)
  (return <int> "Mix_HaltChannel"))

(define-cproc mix-halt-group (tag::<int>)
  (return <int> "Mix_HaltGroup"))

(define-cproc mix-halt-music ()
  (return <int> "Mix_HaltMusic"))

(define-cproc mix-expire-channel (channel::<int> ticks::<int>)
  (return <int> "Mix_ExpireChannel"))

(define-cproc mix-fade-out-channel (which::<int> ms::<int>)
  (return <int> "Mix_FadeOutChannel"))

(define-cproc mix-fade-out-group (tag::<int> ms::<int>)
  (return <int> "Mix_FadeOutGroup"))

(define-cproc mix-fade-out-music (ms::<int>)
  (return <int> "Mix_FadeOutMusic"))

(define-cproc mix-fading-music ()
  (return <int> "Mix_FadingMusic"))

(define-cproc mix-fading-channel (which::<int>)
  (return <int> "Mix_FadingChannel"))

(define-cproc mix-pause (channel::<int>)
  (return <void> "Mix_Pause"))

(define-cproc mix-resume (channel::<int>)
  (return <void> "Mix_Resume"))

(define-cproc mix-paused (channel::<int>)
  (return <int> "Mix_Paused"))

(define-cproc mix-pause-music ()
  (return <void> "Mix_PauseMusic"))

(define-cproc mix-resume-music ()
  (return <void> "Mix_ResumeMusic"))

(define-cproc mix-rewind-music ()
  (return <void> "Mix_RewindMusic"))

(define-cproc mix-paused-music ()
  (return <int> "Mix_PausedMusic"))

(define-cproc mix-set-music-postion (position::<real>)
  (return <int> "Mix_SetMusicPosition"))

(define-cproc mix-playing (channel::<int>)
  (return <int> "Mix_Playing"))

(define-cproc mix-playing-music ()
  (return <int> "Mix_PlayingMusic"))

(define-cproc mix-set-music-cmd (command::<string>)
  "SCM_RETURN(SCM_MAKE_INT(Mix_SetMusicCMD(Scm_GetStringConst(command))));")

(define-cproc mix-set-synchro-value (value::<int>)
  (return <int> "Mix_SetSynchroValue"))

(define-cproc mix-get-synchro-value ()
  (return <int> "Mix_GetSynchroValue"))

(define-cproc mix-get-chunk (channel::<int>)
  "ScmMixChunk *s = SCM_NEW(ScmMixChunk);
   SCM_SET_CLASS(s, SCM_CLASS_MIX_CHUNK);
   s->chunk = Mix_GetChunk(channel);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc mix-close-audio ()
  (return <void> "Mix_CloseAudio"))

(define-cproc mix-get-error ()
  "SCM_RETURN(SCM_MAKE_STR(Mix_GetError()));")

;; Local variables:
;; mode: scheme
;; end: