ONScripterLabel_sound.cpp

/* -*- C++ -*-
 *
 *  ONScripterLabel_sound.cpp - Methods for playing sound
 *
 *  Copyright (c) 2001-2009 Ogapee. All rights reserved.
 *
 *  ogapee@aqua.dti2.ne.jp
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

// Modified by Haeleth, Autumn 2006, to better support OS X/Linux packaging.

// Modified by Mion of Sonozaki Futago-tachi, April 2009, to update from
// Ogapee's 20090331 release source code.

#include "ONScripterLabel.h"
#ifdef LINUX
#include <signal.h>
#endif

#ifdef USE_AVIFILE
#include "AVIWrapper.h"
#endif

#if defined(WII)
#include "mad_decode.h"
#endif

struct WAVE_HEADER{
    char chunk_riff[4];
    char riff_length[4];
    char fmt_id[8];
    char fmt_size[4];
    char data_fmt[2];
    char channels[2];
    char frequency[4];
    char byte_size[4];
    char sample_byte_size[2];
    char sample_bit_size[2];

    char chunk_id[4];
    char data_length[4];
} header;

extern bool ext_music_play_once_flag;

extern "C"{
    extern void mp3callback( void *userdata, Uint8 *stream, int len );
    extern void oggcallback( void *userdata, Uint8 *stream, int len );
    extern Uint32 SDLCALL cdaudioCallback( Uint32 interval, void *param );
#if defined(MACOSX) && defined(INSANI)
	extern Uint32 SDLCALL midiSDLCallback( Uint32 interval, void *param );
#endif
}
extern void midiCallback( int sig );
extern void musicCallback( int sig );
extern SDL_TimerID timer_cdaudio_id;

#if defined(MACOSX) && defined(INSANI)
extern SDL_TimerID timer_midi_id;
#endif

#define TMP_MIDI_FILE "tmp.mid"
#define TMP_MUSIC_FILE "tmp.mus"

#define SWAP_SHORT_BYTES(sptr){          \
            Uint8 *bptr = (Uint8 *)sptr; \
            Uint8 tmpb = *bptr;          \
            *bptr = *(bptr+1);           \
            *(bptr+1) = tmpb;            \
        }

extern long decodeOggVorbis(ONScripterLabel::MusicStruct *music_struct, Uint8 *buf_dst, long len, bool do_rate_conversion)
{
    int current_section;
    long total_len = 0;

    OVInfo *ovi = music_struct->ovi;
    char *buf = (char*)buf_dst;
    if (do_rate_conversion && ovi->cvt.needed){
        len = len * ovi->mult1 / ovi->mult2;
        if (ovi->cvt_len < len*ovi->cvt.len_mult){
            if (ovi->cvt.buf) delete[] ovi->cvt.buf;
            ovi->cvt.buf = new Uint8[len*ovi->cvt.len_mult];
            ovi->cvt_len = len*ovi->cvt.len_mult;
        }
        buf = (char*)ovi->cvt.buf;
    }

#ifdef USE_OGG_VORBIS
    while(1){
#ifdef INTEGER_OGG_VORBIS
        long src_len = ov_read( &ovi->ovf, buf, len, &current_section);
#else
        long src_len = ov_read( &ovi->ovf, buf, len, 0, 2, 1, &current_section);
#endif
        if (src_len <= 0) break;

        long dst_len = src_len;
        if (do_rate_conversion && ovi->cvt.needed){
            ovi->cvt.len = src_len;
            SDL_ConvertAudio(&ovi->cvt);
            memcpy(buf_dst, ovi->cvt.buf, ovi->cvt.len_cvt);
            dst_len = ovi->cvt.len_cvt;

            if (music_struct->volume != DEFAULT_VOLUME){
                // volume change under SOUND_OGG_STREAMING
                for (int i=0 ; i<dst_len ; i+=2){
                    short a = *(short*)(buf_dst+i);
                    a = a*music_struct->volume/100;
                    *(short*)(buf_dst+i) = a;
                }
            }
            buf_dst += ovi->cvt.len_cvt;
        }
        else{
            if (do_rate_conversion && music_struct->volume != DEFAULT_VOLUME){ 
                // volume change under SOUND_OGG_STREAMING
                for (int i=0 ; i<dst_len ; i+=2){
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
                    SWAP_SHORT_BYTES( ((short*)(buf_dst+i)) )
#endif
                    short a = *(short*)(buf_dst+i);
                    a = a*music_struct->volume/100;
                    *(short*)(buf_dst+i) = a;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
                    SWAP_SHORT_BYTES( ((short*)(buf_dst+i)) )
#endif
                }
            }
            buf += dst_len;
            buf_dst += dst_len;
        }

        total_len += dst_len;
        if (src_len == len) break;
        len -= src_len;
    }
#endif

    return total_len;
}

int ONScripterLabel::playSound(const char *filename, int format, bool loop_flag, int channel)
{
    if ( !audio_open_flag ) return SOUND_NONE;

    long length = script_h.cBR->getFileLength( filename );
    if (length == 0) return SOUND_NONE;

    unsigned char *buffer;

    if (format & (SOUND_MP3 | SOUND_OGG_STREAMING) && 
        length == music_buffer_length &&
        music_buffer ){
        buffer = music_buffer;
    }
    else{
        buffer = new unsigned char[length];
        script_h.cBR->getFile( filename, buffer );
    }

    if (format & (SOUND_OGG | SOUND_OGG_STREAMING)){
        int ret = playOGG(format, buffer, length, loop_flag, channel);
        if (ret & (SOUND_OGG | SOUND_OGG_STREAMING)) return ret;
    }

    if (format & SOUND_WAVE){
        if (strncmp((char*) buffer, "RIFF", 4) != 0) {
            // bad (encrypted?) header; need to recreate
            // assume the first 64 bytes are bad (encrypted)
            int channels, rate, bits;
            unsigned char buffer2[10];
            char *fmtname = new char[strlen(filename) + strlen(".fmt") + 1];
            sprintf(fmtname, "%s.fmt", filename);
            if (script_h.cBR->getFileLength( fmtname ) > 0) {
                // a file called filename + ".fmt" exists; read fmt info
                script_h.cBR->getFile( fmtname, buffer2 );
                channels = buffer2[0];
                rate = 0;
                for (int i=5; i>1; i--) {
                    rate = (rate << 8) + buffer2[i];
                }
                bits = buffer2[6];
                for (int i=0; i<64; i++) {
                    buffer[i] = 0;
                }
                setupWaveHeader(buffer, channels, rate, bits,
                    length - sizeof(WAVE_HEADER));
            }
            delete[] fmtname;
        }
        Mix_Chunk *chunk = Mix_LoadWAV_RW(SDL_RWFromMem(buffer, length), 1);
        if (playWave(chunk, format, loop_flag, channel) == 0){
            delete[] buffer;
            return SOUND_WAVE;
        }
    }

    if (format & SOUND_MP3){
        if (music_cmd){
            FILE *fp;
            if ( (fp = fopen(TMP_MUSIC_FILE, "wb", true)) == NULL){
                fprintf(stderr, "can't open temporary Music file %s\n",
                        TMP_MUSIC_FILE);
            }
            else{
                if (fwrite(buffer, 1, length, fp) != (size_t)length)
                    fprintf(stderr, "can't write to temporary Music file %s\n",
                            TMP_MUSIC_FILE);
                fclose( fp );
                ext_music_play_once_flag = !loop_flag;
                if (playExternalMusic(loop_flag) == 0){
                    music_buffer = buffer;
                    music_buffer_length = length;
                    return SOUND_MP3;
                }
            }
        }
#if defined(WII)
	mp3_sample = MAD_CreateDecoder_RW(SDL_RWFromMem( buffer, length ), 4096, 1);
#else
        mp3_sample = SMPEG_new_rwops( SDL_RWFromMem( buffer, length ), NULL, 0 );
#endif
 #if defined(INSANI)
        /* music_struct.volume = 100; */
 #endif
        if (playMP3() == 0){
            music_buffer = buffer;
            music_buffer_length = length;
            return SOUND_MP3;
        }
    }

    /* check WMA */
    if ( buffer[0] == 0x30 && buffer[1] == 0x26 &&
         buffer[2] == 0xb2 && buffer[3] == 0x75 ){
        delete[] buffer;
        return SOUND_OTHER;
    }

    if (format & SOUND_MIDI){
        FILE *fp;
        if ( (fp = fopen(TMP_MIDI_FILE, "wb", true)) == NULL){
            fprintf(stderr, "can't open temporary MIDI file %s\n",
                    TMP_MIDI_FILE);
        }
        else{
            if (fwrite(buffer, 1, length, fp) != (size_t)length)
                fprintf(stderr, "can't write to temporary MIDI file %s\n",
                        TMP_MIDI_FILE);
            fclose( fp );
            ext_music_play_once_flag = !loop_flag;
            if (playMIDI(loop_flag) == 0){
                delete[] buffer;
                return SOUND_MIDI;
            }
        }
    }

    delete[] buffer;

    return SOUND_OTHER;
}

void ONScripterLabel::playCDAudio()
{
    if ( cdaudio_flag ){
        if ( cdrom_info ){
            int length = cdrom_info->track[current_cd_track - 1].length / 75;
            SDL_CDPlayTracks( cdrom_info, current_cd_track - 1, 0, 1, 0 );
            timer_cdaudio_id = SDL_AddTimer( length * 1000, cdaudioCallback, NULL );
        }
    }
    else{
        char filename[256];
        sprintf( filename, "cd\\track%2.2d.mp3", current_cd_track );
 #if defined(INSANI)
        /* music_struct.volume = 100; */
 #endif
        int ret = playSound( filename, SOUND_MP3, cd_play_loop_flag );
        if (ret == SOUND_MP3) return;

        sprintf( filename, "cd\\track%2.2d.ogg", current_cd_track );
        ret = playSound( filename, SOUND_OGG_STREAMING, cd_play_loop_flag );
        if (ret == SOUND_OGG_STREAMING) return;

        sprintf( filename, "cd\\track%2.2d.wav", current_cd_track );
        ret = playSound( filename, SOUND_WAVE, cd_play_loop_flag, MIX_BGM_CHANNEL );
    }
}

int ONScripterLabel::playWave(Mix_Chunk *chunk, int format, bool loop_flag, int channel)
{
    if (!chunk) return -1;

    Mix_Pause( channel );
    if ( wave_sample[channel] ) Mix_FreeChunk( wave_sample[channel] );
    wave_sample[channel] = chunk;

    if      (channel < ONS_MIX_CHANNELS) Mix_Volume( channel, channelvolumes[channel] * 128 / 100 );
    else if (channel == MIX_CLICKVOICE_CHANNEL) Mix_Volume( channel, se_volume * 128 / 100 );
    else if (channel == MIX_BGM_CHANNEL) Mix_Volume( channel, music_volume * 128 / 100 );
    else                                 Mix_Volume( channel, DEFAULT_VOLUME * 128 / 100 );

    if ( !(format & SOUND_PRELOAD) )
        Mix_PlayChannel( channel, wave_sample[channel], loop_flag?-1:0 );

    return 0;
}

int ONScripterLabel::playMP3()
{
#if defined(WII)
    if (mp3_sample == NULL)
        return -1;

    MAD_setvolume( mp3_sample, music_volume );
    Mix_HookMusic( mp3callback, mp3_sample );
    MAD_play( mp3_sample );
#else
    if ( SMPEG_error( mp3_sample ) ){
        //printf(" failed. [%s]\n",SMPEG_error( mp3_sample ));
        // The line below fails. ?????
        //SMPEG_delete( mp3_sample );
        mp3_sample = NULL;
        return -1;
    }

#ifndef MP3_MAD
    SMPEG_enableaudio( mp3_sample, 0 );
    SMPEG_actualSpec( mp3_sample, &audio_format );
    SMPEG_enableaudio( mp3_sample, 1 );
#endif
    SMPEG_setvolume( mp3_sample, music_volume );
    Mix_HookMusic( mp3callback, mp3_sample );
    SMPEG_play( mp3_sample );
#endif
    return 0;
}

int ONScripterLabel::playOGG(int format, unsigned char *buffer, long length, bool loop_flag, int channel)
{
    int channels, rate;
    OVInfo *ovi = openOggVorbis(buffer, length, channels, rate);
    if (ovi == NULL) return SOUND_OTHER;

    if (format & SOUND_OGG){
        unsigned char *buffer2 = new unsigned char[sizeof(WAVE_HEADER)+ovi->decoded_length];
        
        MusicStruct ms;
        ms.ovi = ovi;
        ms.volume = channelvolumes[channel];
        decodeOggVorbis(&ms, (Uint8*)(buffer2+sizeof(WAVE_HEADER)), ovi->decoded_length, false);
        setupWaveHeader(buffer2, channels, rate, 16, ovi->decoded_length);
        Mix_Chunk *chunk = Mix_LoadWAV_RW(SDL_RWFromMem(buffer2, sizeof(WAVE_HEADER)+ovi->decoded_length), 1);
        delete[] buffer2;
        closeOggVorbis(ovi);
        delete[] buffer;

        playWave(chunk, format, loop_flag, channel);

        return SOUND_OGG;
    }

    music_struct.ovi = ovi;
    music_struct.volume = music_volume;
    Mix_HookMusic(oggcallback, &music_struct);

    music_buffer = buffer;
    music_buffer_length = length;

    return SOUND_OGG_STREAMING;
}

int ONScripterLabel::playExternalMusic(bool loop_flag)
{
    int music_looping = loop_flag ? -1 : 0;
#ifdef LINUX
    signal(SIGCHLD, musicCallback);
    if (music_cmd) music_looping = 0;
#endif

    Mix_SetMusicCMD(music_cmd);

    char music_filename[256];
    sprintf(music_filename, "%s%s", script_h.save_path, TMP_MUSIC_FILE);
    if ((music_info = Mix_LoadMUS(music_filename)) == NULL){
        fprintf( stderr, "can't load Music file %s\n", music_filename );
        return -1;
    }

    // Mix_VolumeMusic( music_volume );
    Mix_PlayMusic(music_info, music_looping);

    return 0;
}

int ONScripterLabel::playMIDI(bool loop_flag)
{
    Mix_SetMusicCMD(midi_cmd);

    char midi_filename[256];
    sprintf(midi_filename, "%s%s", script_h.save_path, TMP_MIDI_FILE);
    midi_info = Mix_LoadMUS(midi_filename);
    if (midi_info == NULL) {
        fprintf(stderr, "MIDI error: %s\n", Mix_GetError());
        return -1;
    }

    int midi_looping = loop_flag ? -1 : 0;

#ifdef LINUX
    signal(SIGCHLD, midiCallback);
    if (midi_cmd) midi_looping = 0;
#endif

    Mix_VolumeMusic(music_volume);
#if defined(MACOSX) && defined(INSANI)
    // Emulate looping on MacOS ourselves to work around bug in SDL_Mixer
    midi_looping = 0;
    Mix_PlayMusic(midi_info, midi_looping);
    timer_midi_id = SDL_AddTimer(1000, midiSDLCallback, NULL);
#else
    Mix_PlayMusic(midi_info, midi_looping);
#endif
    current_cd_track = -2;

    return 0;
}

int ONScripterLabel::playingMusic()
{
    if ((Mix_GetMusicHookData() != NULL) || (Mix_Playing(MIX_BGM_CHANNEL) == 1)
        || (Mix_PlayingMusic() == 1))
        return 1;
    else
        return 0;
}

int ONScripterLabel::setCurMusicVolume( int volume )
{
    if (Mix_GetMusicHookData() != NULL) { // for streamed MP3 & OGG
#if defined(WII)
        if ( mp3_sample ) MAD_setvolume( mp3_sample, volume ); // mp3
#else
        if ( mp3_sample ) SMPEG_setvolume( mp3_sample, volume ); // mp3
#endif
        else music_struct.volume = volume; // ogg
    } else if (Mix_Playing(MIX_BGM_CHANNEL) == 1) { // wave
        Mix_Volume( MIX_BGM_CHANNEL, volume * 128 / 100 );
    } else if (Mix_PlayingMusic() == 1) { // midi
        Mix_VolumeMusic( volume * 128 / 100 );
    }

    return 0;
}

int ONScripterLabel::playMPEG( const char *filename, bool async_flag, bool use_pos, int xpos, int ypos, int width, int height )
{
    int ret = 0;
#ifndef MP3_MAD
    bool different_spec = false;
    unsigned long length = script_h.cBR->getFileLength( filename );
    if (movie_buffer) delete[] movie_buffer;
    movie_buffer = new unsigned char[length];
    if (async_movie) stopMovie(async_movie);
    async_movie = NULL;
    if (surround_rects) delete[] surround_rects;
    surround_rects = new SDL_Rect[4];
    for (int i=0; i<4; ++i) {
        surround_rects[i].x = surround_rects[i].y = 0;
        surround_rects[i].w = surround_rects[i].h = 0;
    }
    script_h.cBR->getFile( filename, movie_buffer );
    SMPEG *mpeg_sample = SMPEG_new_rwops( SDL_RWFromMem( movie_buffer, length ), NULL, 0 );

    if ( !SMPEG_error( mpeg_sample ) ){
        SMPEG_enableaudio( mpeg_sample, 0 );

        if ( audio_open_flag ){
            //Mion - SMPEG doesn't handle different audio spec well, so
            // let's redo the SDL mixer just for this video playback
            SDL_AudioSpec wanted;
            SMPEG_wantedSpec( mpeg_sample, &wanted );
            //printf("SMPEG wants audio: %d Hz %d bit %s\n", wanted.freq,
            //       (wanted.format&0xFF),
            //       (wanted.channels > 1) ? "stereo" : "mono");
            if ((wanted.format != audio_format.format) ||
                (wanted.freq != audio_format.freq)) {
                different_spec = true;
                Mix_CloseAudio();
                openAudio(wanted.freq, wanted.format, wanted.channels);
                if (!audio_open_flag) {
                    // didn't work, use the old settings
                    openAudio();
                    different_spec = false;
                }
            }
            SMPEG_actualSpec( mpeg_sample, &audio_format );
            SMPEG_enableaudio( mpeg_sample, 1 );
        }
        SMPEG_enablevideo( mpeg_sample, 1 );
        SMPEG_setdisplay( mpeg_sample, screen_surface, NULL, NULL );
        if (use_pos) {
            SMPEG_scaleXY( mpeg_sample, width, height );
            SMPEG_move( mpeg_sample, xpos, ypos );
        }
        SMPEG_setvolume( mpeg_sample, music_volume );

        Mix_HookMusic( mp3callback, mpeg_sample );

        if (use_pos) {
            async_movie_rect.x = xpos;
            async_movie_rect.y = ypos;
            async_movie_rect.w = width;
            async_movie_rect.h = height;

            //sur_rect[0] = { 0, 0, screen_width, ypos };
            //sur_rect[1] = { 0, ypos, xpos, height };
            //sur_rect[2] = { xpos + width, ypos, screen_width - (xpos + width), height };
            //sur_rect[3] = { 0, ypos + height, screen_width, screen_height - (ypos + height) };
            surround_rects[0].w = surround_rects[3].w = screen_width;
            surround_rects[0].h = surround_rects[1].y = surround_rects[2].y = ypos;
            surround_rects[1].w = xpos;
            surround_rects[1].h = surround_rects[2].h = height;
            surround_rects[2].x = xpos + width;
            surround_rects[2].w = screen_width - (xpos + width);
            surround_rects[3].y = ypos + height;
            surround_rects[3].h = screen_height - (ypos + height);
        } else {
            async_movie_rect.x = 0;
            async_movie_rect.y = 0;
            async_movie_rect.w = screen_width;
            async_movie_rect.h = screen_height;
        }

        if (movie_loop_flag)
            SMPEG_loop( mpeg_sample, -1 );
        SMPEG_play( mpeg_sample );

        if (async_flag){
            async_movie = mpeg_sample;
            return 0;
        }

        bool done_flag = false;
        while( !done_flag ){
            if (SMPEG_status(mpeg_sample) != SMPEG_PLAYING){
                if (movie_loop_flag)
                    SMPEG_play( mpeg_sample );
                else
                    break;
            }

            SDL_Event event;

            while( SDL_PollEvent( &event ) ){
                switch (event.type){
                  case SDL_KEYDOWN:
                    if ( ((SDL_KeyboardEvent *)&event)->keysym.sym == SDLK_RETURN ||
                         ((SDL_KeyboardEvent *)&event)->keysym.sym == SDLK_SPACE ||
                         ((SDL_KeyboardEvent *)&event)->keysym.sym == SDLK_ESCAPE )
                        done_flag = movie_click_flag;
                    break;
                  case SDL_KEYUP:
                    // need to catch CTRL keyups
                    keyUpEvent( (SDL_KeyboardEvent*)&event );
                    break;
                  case SDL_QUIT:
                    ret = 1;
                    done_flag = true;
                    break;
                  case SDL_MOUSEBUTTONDOWN:
                    done_flag = movie_click_flag;
                    break;
                  default:
                    break;
                }
            }
            SDL_Delay( 10 );
        }

        stopMovie(mpeg_sample);

        if (different_spec) {
            //restart mixer with the old audio spec
            Mix_CloseAudio();
            openAudio();
        }
    }

#else
    fprintf( stderr, "mpegplay command is disabled.\n" );
#endif

    return ret;
}

void ONScripterLabel::playAVI( const char *filename, bool click_flag )
{
#ifdef USE_AVIFILE
    char *absolute_filename = new char[ strlen(archive_path) + strlen(filename) + 1 ];
    sprintf( absolute_filename, "%s%s", archive_path, filename );
    for ( unsigned int i=0 ; i<strlen( absolute_filename ) ; i++ )
        if ( absolute_filename[i] == '/' ||
             absolute_filename[i] == '\\' )
            absolute_filename[i] = DELIMITER;

    if ( audio_open_flag ) Mix_CloseAudio();

    AVIWrapper *avi = new AVIWrapper();
    if ( avi->init( absolute_filename, false ) == 0 &&
         avi->initAV( screen_surface, audio_open_flag ) == 0 ){
        if (avi->play( click_flag )) endCommand();
    }
    delete avi;
    delete[] absolute_filename;

    if ( audio_open_flag ){
        Mix_CloseAudio();
        openAudio();
    }
#else
    fprintf( stderr, "avi command is disabled.\n" );
#endif
}

void ONScripterLabel::stopMovie(SMPEG *mpeg)
{
    if (mpeg) {
        SMPEG_stop( mpeg );
        Mix_HookMusic( NULL, NULL );
        SMPEG_delete( mpeg );

        dirty_rect.add( async_movie_rect );
    }

    if (movie_buffer) delete[] movie_buffer;
    movie_buffer = NULL;
    if (surround_rects) delete[] surround_rects;
    surround_rects = NULL;
}

void ONScripterLabel::stopBGM( bool continue_flag )
{
    if ( cdaudio_flag && cdrom_info ){
        extern SDL_TimerID timer_cdaudio_id;

        if ( timer_cdaudio_id ){
            SDL_RemoveTimer( timer_cdaudio_id );
            timer_cdaudio_id = NULL;
        }
        if (SDL_CDStatus( cdrom_info ) >= CD_PLAYING )
            SDL_CDStop( cdrom_info );
    }

    if ( mp3_sample ){
#if defined(WII)
        MAD_stop( mp3_sample );
        Mix_HookMusic( NULL, NULL );
	MAD_Free(mp3_sample);
#else
        SMPEG_stop( mp3_sample );
        Mix_HookMusic( NULL, NULL );
        SMPEG_delete( mp3_sample );
#endif
        mp3_sample = NULL;
    }

    if (music_struct.ovi){
        Mix_HaltMusic();
        Mix_HookMusic( NULL, NULL );
        closeOggVorbis(music_struct.ovi);
        music_struct.ovi = NULL;
    }

    if ( wave_sample[MIX_BGM_CHANNEL] ){
        Mix_Pause( MIX_BGM_CHANNEL );
        Mix_FreeChunk( wave_sample[MIX_BGM_CHANNEL] );
        wave_sample[MIX_BGM_CHANNEL] = NULL;
    }

    if ( !continue_flag ){
        setStr( &music_file_name, NULL );
        music_play_loop_flag = false;
        if ( music_buffer ){
            delete[] music_buffer;
            music_buffer = NULL;
        }
    }

    if ( midi_info ){

#if defined(MACOSX) && defined(INSANI)
        if ( timer_midi_id ){
            SDL_RemoveTimer( timer_midi_id );
            timer_midi_id = NULL;
        }
#endif

        ext_music_play_once_flag = true;
        Mix_HaltMusic();
        Mix_FreeMusic( midi_info );
        midi_info = NULL;
    }
    if ( !continue_flag ){
        setStr( &midi_file_name, NULL );
        midi_play_loop_flag = false;
    }

    if ( music_info ){
        ext_music_play_once_flag = true;
        Mix_HaltMusic();
        Mix_FreeMusic( music_info );
        music_info = NULL;
    }

    if ( !continue_flag ) current_cd_track = -1;
}

//Mion - ogapee2008
void ONScripterLabel::stopAllDWAVE()
{
    for (int ch=0; ch<ONS_MIX_CHANNELS ; ch++)
        if ( wave_sample[ch] ){
            Mix_Pause( ch );
            Mix_FreeChunk( wave_sample[ch] );
            wave_sample[ch] = NULL;
        }
}

void ONScripterLabel::playClickVoice()
{
    if      ( clickstr_state == CLICK_NEWPAGE ){
        if ( clickvoice_file_name[CLICKVOICE_NEWPAGE] )
            playSound(clickvoice_file_name[CLICKVOICE_NEWPAGE],
                      SOUND_WAVE|SOUND_OGG, false, MIX_CLICKVOICE_CHANNEL);
    }
    else if ( clickstr_state == CLICK_WAIT ){
        if ( clickvoice_file_name[CLICKVOICE_NORMAL] )
            playSound(clickvoice_file_name[CLICKVOICE_NORMAL],
                      SOUND_WAVE|SOUND_OGG, false, MIX_CLICKVOICE_CHANNEL);
    }
}

void ONScripterLabel::setupWaveHeader( unsigned char *buffer, int channels, int rate, int bits, unsigned long data_length )
{
    memcpy( header.chunk_riff, "RIFF", 4 );
    int riff_length = sizeof(WAVE_HEADER) + data_length - 8;
    header.riff_length[0] = riff_length & 0xff;
    header.riff_length[1] = (riff_length >> 8) & 0xff;
    header.riff_length[2] = (riff_length >> 16) & 0xff;
    header.riff_length[3] = (riff_length >> 24) & 0xff;
    memcpy( header.fmt_id, "WAVEfmt ", 8 );
    header.fmt_size[0] = 0x10;
    header.fmt_size[1] = header.fmt_size[2] = header.fmt_size[3] = 0;
    header.data_fmt[0] = 1; header.data_fmt[1] = 0; // PCM format
    header.channels[0] = channels; header.channels[1] = 0;
    header.frequency[0] = rate & 0xff;
    header.frequency[1] = (rate >> 8) & 0xff;
    header.frequency[2] = (rate >> 16) & 0xff;
    header.frequency[3] = (rate >> 24) & 0xff;

    int sample_byte_size = channels * bits / 8;
    int byte_size = sample_byte_size * rate;
    header.byte_size[0] = byte_size & 0xff;
    header.byte_size[1] = (byte_size >> 8) & 0xff;
    header.byte_size[2] = (byte_size >> 16) & 0xff;
    header.byte_size[3] = (byte_size >> 24) & 0xff;
    header.sample_byte_size[0] = sample_byte_size;
    header.sample_byte_size[1] = 0;
    header.sample_bit_size[0] = bits;
    header.sample_bit_size[1] = 0;

    memcpy( header.chunk_id, "data", 4 );
    header.data_length[0] = (char)(data_length & 0xff);
    header.data_length[1] = (char)((data_length >> 8) & 0xff);
    header.data_length[2] = (char)((data_length >> 16) & 0xff);
    header.data_length[3] = (char)((data_length >> 24) & 0xff);

    memcpy( buffer, &header, sizeof(header) );
}
#ifdef USE_OGG_VORBIS
static size_t oc_read_func(void *ptr, size_t size, size_t nmemb, void *datasource)
{
    OVInfo *ogg_vorbis_info = (OVInfo*)datasource;

    size_t len = size*nmemb;
    if ((size_t)ogg_vorbis_info->pos+len > (size_t)ogg_vorbis_info->length) 
        len = (size_t)(ogg_vorbis_info->length - ogg_vorbis_info->pos);
    memcpy(ptr, ogg_vorbis_info->buf+ogg_vorbis_info->pos, len);
    ogg_vorbis_info->pos += len;

    return len;
}

static int oc_seek_func(void *datasource, ogg_int64_t offset, int whence)
{
    OVInfo *ogg_vorbis_info = (OVInfo*)datasource;

    ogg_int64_t pos = 0;
    if (whence == 0)
        pos = offset;
    else if (whence == 1)
        pos = ogg_vorbis_info->pos + offset;
    else if (whence == 2)
        pos = ogg_vorbis_info->length + offset;

    if (pos < 0 || pos > ogg_vorbis_info->length) return -1;

    ogg_vorbis_info->pos = pos;

    return 0;
}

static int oc_close_func(void *datasource)
{
    return 0;
}

static long oc_tell_func(void *datasource)
{
    OVInfo *ogg_vorbis_info = (OVInfo*)datasource;

    return (long)ogg_vorbis_info->pos;
}
#endif
OVInfo *ONScripterLabel::openOggVorbis( unsigned char *buf, long len, int &channels, int &rate )
{
    OVInfo *ovi = NULL;

#ifdef USE_OGG_VORBIS
    ovi = new OVInfo();

    ovi->buf = buf;
    ovi->decoded_length = 0;
    ovi->length = len;
    ovi->pos = 0;

    ov_callbacks oc;
    oc.read_func  = oc_read_func;
    oc.seek_func  = oc_seek_func;
    oc.close_func = oc_close_func;
    oc.tell_func  = oc_tell_func;
    if (ov_open_callbacks(ovi, &ovi->ovf, NULL, 0, oc) < 0){
        delete ovi;
        return NULL;
    }

    vorbis_info *vi = ov_info( &ovi->ovf, -1 );
    if (vi == NULL){
        ov_clear(&ovi->ovf);
        delete ovi;
        return NULL;
    }

    channels = vi->channels;
    rate = vi->rate;

    ovi->cvt.buf = NULL;
    ovi->cvt_len = 0;
    SDL_BuildAudioCVT(&ovi->cvt,
                      AUDIO_S16, channels, rate,
                      audio_format.format, audio_format.channels, audio_format.freq);
    ovi->mult1 = 10;
    ovi->mult2 = (int)(ovi->cvt.len_ratio*10.0);

    ovi->decoded_length = (long)(ov_pcm_total(&ovi->ovf, -1) * channels * 2);
#endif

    return ovi;
}

int ONScripterLabel::closeOggVorbis(OVInfo *ovi)
{
    if (ovi->buf){
        ovi->buf = NULL;
#ifdef USE_OGG_VORBIS
        ovi->length = 0;
        ovi->pos = 0;
        ov_clear(&ovi->ovf);
#endif
    }
    if (ovi->cvt.buf){
        delete[] ovi->cvt.buf;
        ovi->cvt.buf = NULL;
        ovi->cvt_len = 0;
    }
    delete ovi;

    return 0;
}