コード例 #1
0
ファイル: testcard.cpp プロジェクト: k4rtik/ultragrid
static int configure_audio(struct testcard_state *s)
{
        UNUSED(s);

#if defined HAVE_LIBSDL_MIXER && ! defined HAVE_MACOSX
        char filename[1024] = "";
        int fd;
        Mix_Music *music;
        ssize_t bytes_written = 0l;

        SDL_Init(SDL_INIT_AUDIO);

        if( Mix_OpenAudio( AUDIO_SAMPLE_RATE, AUDIO_S16LSB,
                        audio_capture_channels, 4096 ) == -1 ) {
                fprintf(stderr,"[testcard] error initalizing sound\n");
                return -1;
        }
        strncpy(filename, "/tmp/uv.midiXXXXXX", sizeof filename - 1);
        fd = mkstemp(filename);
        if (fd < 0) {
                perror("mkstemp");
                return -1;
        }

        do {
                ssize_t ret;
                ret = write(fd, song1 + bytes_written,
                                sizeof(song1) - bytes_written);
                if(ret < 0) return -1;
                bytes_written += ret;
        } while (bytes_written < (ssize_t) sizeof(song1));
        close(fd);
        music = Mix_LoadMUS(filename);

        s->audio_data = (char *) calloc(1, AUDIO_BUFFER_SIZE /* 1 sec */);
        s->audio_start = 0;
        s->audio_end = 0;
        s->audio.bps = AUDIO_BPS;
        s->audio.ch_count = audio_capture_channels;
        s->audio.sample_rate = AUDIO_SAMPLE_RATE;

        // register grab as a postmix processor
        if(!Mix_RegisterEffect(MIX_CHANNEL_POST, grab_audio, NULL, s)) {
                printf("[testcard] Mix_RegisterEffect: %s\n", Mix_GetError());
                return -1;
        }

        if(Mix_PlayMusic(music,-1)==-1){
                fprintf(stderr, "[testcard] error playing midi\n");
                return -1;
        }
        Mix_Volume(-1, 0);

        printf("[testcard] playing audio\n");

        return 0;
#else
        return -2;
#endif
}
コード例 #2
0
ファイル: sdlsound.cpp プロジェクト: ymber/Cataclysm-DDA
void sfx::play_ambient_variant_sound( const std::string &id, const std::string &variant, int volume,
                                      int channel, int duration, float pitch )
{
    if( !check_sound( volume ) ) {
        return;
    }

    const sound_effect *eff = find_random_effect( id, variant );
    if( eff == nullptr ) {
        return;
    }
    const sound_effect &selected_sound_effect = *eff;

    Mix_Chunk *effect_to_play = get_sfx_resource( selected_sound_effect.resource_id );
    Mix_Chunk *shifted_effect = do_pitch_shift( effect_to_play, pitch );
    Mix_VolumeChunk( shifted_effect,
                     selected_sound_effect.volume * get_option<int>( "AMBIENT_SOUND_VOLUME" ) * volume / ( 100 * 100 ) );
    if( duration ) {
        if( Mix_FadeInChannel( channel, shifted_effect, -1, duration ) == -1 ) {
            dbg( D_ERROR ) << "Failed to play sound effect: " << Mix_GetError();
        }
    } else {
        if( Mix_PlayChannel( channel, shifted_effect, -1 ) == -1 ) {
            dbg( D_ERROR ) << "Failed to play sound effect: " << Mix_GetError();
        }
    }

    Mix_RegisterEffect( channel, empty_effect, cleanup_when_channel_finished, shifted_effect );
}
コード例 #3
0
ファイル: sdl_mixer.cpp プロジェクト: soulik/LuaSDL-2.0
	static int lua_Mix_RegisterEffect(State & state){
		Stack * stack = state.stack;
		if (stack->is<LUA_TFUNCTION>(2)){
			lua_EffectWrapper * wrapper = new lua_EffectWrapper;
			
			wrapper->state = &state;
			
			stack->pushValue(2);
			wrapper->fnRef = stack->ref();

			if (stack->is<LUA_TFUNCTION>(3)){
				stack->pushValue(3);
				wrapper->fnRef = stack->ref();
			}
			else{
				wrapper->errFnRef = LUA_REFNIL;
			}

			int channel = stack->to<int>(1);

			Mix_RegisterEffect(channel, lua_Mix_EffectCallback, lua_Mix_EffectDoneCallback, wrapper);
			return 1;
		}
		else{
			return 0;
		}
	}
コード例 #4
0
ファイル: sound.cpp プロジェクト: piluke/BasicEventEngine
int BEE::Sound::effect_set_post(int se_mask) {
	if (se_mask & se_none) {
		Mix_UnregisterAllEffects(MIX_CHANNEL_POST);
		effect_reset_data();
	} else {
		if (se_mask & se_chorus) {
			Mix_RegisterEffect(MIX_CHANNEL_POST, sound_effect_chorus, sound_effect_chorus_cleanup, chorus_data);
		}
		if (se_mask & se_echo) {
			Mix_RegisterEffect(MIX_CHANNEL_POST, sound_effect_echo, sound_effect_echo_cleanup, echo_data);
		}
		if (se_mask & se_flanger) {
			Mix_RegisterEffect(MIX_CHANNEL_POST, sound_effect_flanger, sound_effect_flanger_cleanup, flanger_data);
		}
		if (se_mask & se_gargle) {
			game->messenger_send({"engine", "sound"}, BEE_MESSAGE_WARNING, "The gargle sound effect is currently unimplemented and will have no effect");
			Mix_RegisterEffect(MIX_CHANNEL_POST, sound_effect_gargle, sound_effect_gargle_cleanup, gargle_data);
		}
		if (se_mask & se_reverb) {
			game->messenger_send({"engine", "sound"}, BEE_MESSAGE_WARNING, "The reverb sound effect is currently unimplemented and will have no effect");
			Mix_RegisterEffect(MIX_CHANNEL_POST, sound_effect_reverb, sound_effect_reverb_cleanup, reverb_data);
		}
		if (se_mask & se_compressor) {
			game->messenger_send({"engine", "sound"}, BEE_MESSAGE_WARNING, "The compressor sound effect is currently unimplemented and will have no effect");
			Mix_RegisterEffect(MIX_CHANNEL_POST, sound_effect_compressor, sound_effect_compressor_cleanup, compressor_data);
		}
		if (se_mask & se_equalizer) {
			game->messenger_send({"engine", "sound"}, BEE_MESSAGE_WARNING, "The equalizer sound effect is currently unimplemented and will have no effect");
			Mix_RegisterEffect(MIX_CHANNEL_POST, sound_effect_equalizer, sound_effect_equalizer_cleanup, equalizer_data);
		}
	}

	return 0;
}
コード例 #5
0
ファイル: sounds.c プロジェクト: NSYXin/cdogs-sdl
static void SoundPlayAtPosition(
	SoundDevice *device, Mix_Chunk *data, int distance, int bearing,
	const bool isMuffled)
{
	if (data == NULL)
	{
		return;
	}
	// If distance is very close, don't place any panning on it
	if (distance < DISTANCE_CLOSE) bearing = 0;
	if (isMuffled)
	{
		distance += OUT_OF_SIGHT_DISTANCE_PLUS;
	}
	distance /= 2;
	// Don't play anything if it's too distant
	// This means we don't waste sound channels
	if (distance > 255)
	{
		return;
	}

	if (!device->isInitialised)
	{
		return;
	}

	LOG(LM_SOUND, LL_TRACE, "distance(%d) bearing(%d)", distance, bearing);

	int channel;
	for (;;)
	{
		channel = Mix_PlayChannel(-1, data, 0);
		if (channel >= 0 || device->channels > 128)
		{
			break;
		}
		// Check if we cannot play the sound; allocate more channels
		device->channels *= 2;
		if (Mix_AllocateChannels(device->channels) != device->channels)
		{
			printf("Couldn't allocate channels!\n");
			return;
		}
		// When allocating new channels, need to reset their volume
		Mix_Volume(-1, ConfigGetInt(&gConfig, "Sound.SoundVolume"));
	}
	Mix_SetPosition(channel, (Sint16)bearing, (Uint8)distance);
	if (isMuffled)
	{
		if (!Mix_RegisterEffect(channel, MuffleEffect, NULL, NULL))
		{
			fprintf(stderr, "Mix_RegisterEffect: %s\n", Mix_GetError());
		}
	}
}
コード例 #6
0
ファイル: driver_sdl.c プロジェクト: SilkyPantsDan/eduke32
int32_t SDLDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, void * initdata)
{
    int32_t err = 0;
    int32_t chunksize;
    uint16_t fmt;

    UNREFERENCED_PARAMETER(numchannels);
    UNREFERENCED_PARAMETER(initdata);

    if (Initialised) {
        SDLDrv_PCM_Shutdown();
    }

    chunksize = 512;
#ifdef __ANDROID__
    chunksize = droidinfo.audio_buffer_size;
#endif

    if (*mixrate >= 16000) chunksize *= 2;
    if (*mixrate >= 32000) chunksize *= 2;

    err = Mix_OpenAudio(*mixrate, AUDIO_S16SYS, *numchannels, chunksize);

    if (err < 0) {
        ErrorCode = SDLErr_OpenAudio;
        return SDLErr_Error;
    }


    if (Mix_QuerySpec(mixrate, &fmt, numchannels))
    {
        if (fmt == AUDIO_U8 || fmt == AUDIO_S8)
        {
            ErrorCode = SDLErr_OpenAudio;
            return SDLErr_Error;
        }
    }

    //Mix_SetPostMix(fillData, NULL);

    EffectFence = SDL_CreateMutex();

    // channel 0 and 1 are actual sounds
    // dummy channel 2 runs our fillData() callback as an effect
    Mix_RegisterEffect(2, fillData, NULL, NULL);

    DummyBuffer = (uint8_t *) calloc(1, chunksize);

    DummyChunk = Mix_QuickLoad_RAW(DummyBuffer, chunksize);

    Mix_PlayChannel(2, DummyChunk, -1);

    Initialised = 1;

    return SDLErr_Ok;
}
コード例 #7
0
ファイル: sdlsound.cpp プロジェクト: ymber/Cataclysm-DDA
void sfx::play_variant_sound_pitch( const std::string &id, const std::string &variant, int volume,
                                    int angle,
                                    float pitch )
{
    if( !check_sound( volume ) ) {
        return;
    }

    const sound_effect *eff = find_random_effect( id, variant );
    if( eff == nullptr ) {
        return;
    }
    const sound_effect &selected_sound_effect = *eff;

    Mix_Chunk *effect_to_play = get_sfx_resource( selected_sound_effect.resource_id );
    Mix_Chunk *shifted_effect = do_pitch_shift( effect_to_play, pitch );
    Mix_VolumeChunk( shifted_effect,
                     selected_sound_effect.volume * get_option<int>( "SOUND_EFFECT_VOLUME" ) * volume / ( 100 * 100 ) );
    int channel = Mix_PlayChannel( -1, shifted_effect, 0 );
    Mix_RegisterEffect( channel, empty_effect, cleanup_when_channel_finished, shifted_effect );
    Mix_SetPosition( channel, angle, 1 );
}
コード例 #8
0
ファイル: th_movie.cpp プロジェクト: J-Shep/CorsixTH
void THMovie::play(const SDL_Rect &destination_rect, int iChannel)
{
    m_destination_rect = SDL_Rect{ destination_rect.x, destination_rect.y, destination_rect.w, destination_rect.h };

    if(!m_pRenderer)
    {
        m_sLastError = std::string("Cannot play before setting the renderer");
        return;
    }

    m_pVideoQueue = new THAVPacketQueue();
    m_pMoviePictureBuffer->reset();
    m_pMoviePictureBuffer->allocate(m_pRenderer, m_pVideoCodecContext->width, m_pVideoCodecContext->height);

    m_pAudioPacket = nullptr;
    m_iAudioPacketSize = 0;
    m_pbAudioPacketData = nullptr;

    m_iAudioBufferSize = 0;
    m_iAudioBufferIndex = 0;
    m_iAudioBufferMaxSize = 0;

    m_pAudioQueue = new THAVPacketQueue();
    m_iCurSyncPts = 0;
    m_iCurSyncPtsSystemTime = SDL_GetTicks();

    if(m_iAudioStream >= 0)
    {
        Mix_QuerySpec(&m_iMixerFrequency, nullptr, &m_iMixerChannels);
#ifdef CORSIX_TH_USE_FFMPEG
        m_pAudioResampleContext = swr_alloc_set_opts(
            m_pAudioResampleContext,
            m_iMixerChannels==1?AV_CH_LAYOUT_MONO:AV_CH_LAYOUT_STEREO,
            AV_SAMPLE_FMT_S16,
            m_iMixerFrequency,
            m_pAudioCodecContext->channel_layout,
            m_pAudioCodecContext->sample_fmt,
            m_pAudioCodecContext->sample_rate,
            0,
            nullptr);
        swr_init(m_pAudioResampleContext);
#elif defined(CORSIX_TH_USE_LIBAV)
        m_pAudioResampleContext = avresample_alloc_context();
        av_opt_set_int(m_pAudioResampleContext, "in_channel_layout", m_pAudioCodecContext->channel_layout, 0);
        av_opt_set_int(m_pAudioResampleContext, "out_channel_layout", m_iMixerChannels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO, 0);
        av_opt_set_int(m_pAudioResampleContext, "in_sample_rate", m_pAudioCodecContext->sample_rate, 0);
        av_opt_set_int(m_pAudioResampleContext, "out_sample_rate", m_iMixerFrequency, 0);
        av_opt_set_int(m_pAudioResampleContext, "in_sample_fmt", m_pAudioCodecContext->sample_fmt, 0);
        av_opt_set_int(m_pAudioResampleContext, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
        avresample_open(m_pAudioResampleContext);
#endif
        m_pChunk = Mix_QuickLoad_RAW(m_pbChunkBuffer, ms_audioBufferSize);

        m_iChannel = Mix_PlayChannel(iChannel, m_pChunk, -1);
        if(m_iChannel < 0)
        {
            m_iChannel = -1;
            m_sLastError = std::string(Mix_GetError());
        }
        else
        {
            Mix_RegisterEffect(m_iChannel, th_movie_audio_callback, nullptr, this);
        }
    }

    m_pStreamThread = SDL_CreateThread(th_movie_stream_reader_thread, "Stream", this);
    m_pVideoThread = SDL_CreateThread(th_movie_video_thread, "Video", this);
}
コード例 #9
0
ファイル: th_movie.cpp プロジェクト: CorsixTH/CorsixTH
void movie_player::play(int iChannel)
{
    if(!renderer)
    {
        last_error = std::string("Cannot play before setting the renderer");
        return;
    }

    video_queue = new av_packet_queue();
    movie_picture_buffer->reset();
    movie_picture_buffer->allocate(renderer, video_codec_context->width, video_codec_context->height);

    audio_packet = nullptr;
    audio_packet_size = 0;
    audio_packet_data = nullptr;

    audio_buffer_size = 0;
    audio_buffer_index = 0;
    audio_buffer_max_size = 0;

    audio_queue = new av_packet_queue();
    current_sync_pts = 0;
    current_sync_pts_system_time = SDL_GetTicks();

    if(audio_stream_index >= 0)
    {
        Mix_QuerySpec(&mixer_frequency, nullptr, &mixer_channels);
#ifdef CORSIX_TH_USE_FFMPEG
        audio_resample_context = swr_alloc_set_opts(
            audio_resample_context,
            mixer_channels==1?AV_CH_LAYOUT_MONO:AV_CH_LAYOUT_STEREO,
            AV_SAMPLE_FMT_S16,
            mixer_frequency,
            audio_codec_context->channel_layout,
            audio_codec_context->sample_fmt,
            audio_codec_context->sample_rate,
            0,
            nullptr);
        swr_init(audio_resample_context);
#elif defined(CORSIX_TH_USE_LIBAV)
        audio_resample_context = avresample_alloc_context();
        av_opt_set_int(audio_resample_context, "in_channel_layout", audio_codec_context->channel_layout, 0);
        av_opt_set_int(audio_resample_context, "out_channel_layout", mixer_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO, 0);
        av_opt_set_int(audio_resample_context, "in_sample_rate", audio_codec_context->sample_rate, 0);
        av_opt_set_int(audio_resample_context, "out_sample_rate", mixer_frequency, 0);
        av_opt_set_int(audio_resample_context, "in_sample_fmt", audio_codec_context->sample_fmt, 0);
        av_opt_set_int(audio_resample_context, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
        avresample_open(audio_resample_context);
#endif
        empty_audio_chunk = Mix_QuickLoad_RAW(audio_chunk_buffer, audio_chunk_buffer_capacity);

        audio_channel = Mix_PlayChannel(iChannel, empty_audio_chunk, -1);
        if(audio_channel < 0)
        {
            audio_channel = -1;
            last_error = std::string(Mix_GetError());
            Mix_FreeChunk(empty_audio_chunk);
        }
        else
        {
            Mix_RegisterEffect(audio_channel, th_movie_audio_callback, nullptr, this);
        }
    }

    stream_thread = std::thread(&movie_player::read_streams, this);
    video_thread = std::thread(&movie_player::run_video, this);
}
コード例 #10
0
ファイル: dsl.c プロジェクト: JohnnyonFlame/RoTT
int   DSL_BeginBufferedPlayback( char *BufferStart,
      int BufferSize, int NumDivisions, unsigned SampleRate,
      int MixMode, void ( *CallBackFunc )( void ) )
{
	Uint16 format;
	Uint8 *tmp;
	int channels;
	int chunksize;
		
	if (mixer_initialized) {
		DSL_SetErrorCode(DSL_MixerActive);
		
		return DSL_Error;
	}
	
	_CallBackFunc = CallBackFunc;
	_BufferStart = BufferStart;
	_BufferSize = (BufferSize / NumDivisions);
	_NumDivisions = NumDivisions;
	_SampleRate = SampleRate;

	_remainder = 0;
	
	format = (MixMode & SIXTEEN_BIT) ? AUDIO_S16SYS : AUDIO_U8;
	channels = (MixMode & STEREO) ? 2 : 1;

/*
	23ms is typically ideal (11025,22050,44100)
	46ms isn't bad
*/
	
	chunksize = 512;
	
	if (SampleRate >= 16000) chunksize *= 2;
	if (SampleRate >= 32000) chunksize *= 2;
	
/*	
// SDL mixer does this already
	if (MixMode & SIXTEEN_BIT) chunksize *= 2;
	if (MixMode & STEREO) chunksize *= 2;
*/
	
	if (Mix_OpenAudio(SampleRate, format, channels, chunksize) < 0) {
		DSL_SetErrorCode(DSL_MixerInitFailure);
		
		return DSL_Error;
	}

/*
	Mix_SetPostMix(mixer_callback, NULL);
*/
	/* have to use a channel because postmix will overwrite the music... */
	Mix_RegisterEffect(0, mixer_callback, NULL, NULL);
	
	/* create a dummy sample just to allocate that channel */
	blank_buf = (Uint8 *)malloc(4096);
	memset(blank_buf, 0, 4096);
	
	blank = Mix_QuickLoad_RAW(blank_buf, 4096);
		
	Mix_PlayChannel(0, blank, -1);
	
	mixer_initialized = 1;
	
	return DSL_Ok;
}
コード例 #11
0
LRESULT MusPlayer_WinAPI::MainWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
        case WM_HSCROLL:
        {
            if(m_self->m_volume == (HWND)lParam)
            {
                switch(LOWORD(wParam))
                {
                case TB_ENDTRACK:
                case TB_THUMBPOSITION:
                case TB_THUMBTRACK:
                case SB_LEFT:
                case SB_RIGHT:
                    DWORD dwPos;// current position of slider
                    dwPos = SendMessageW(m_self->m_volume, TBM_GETPOS, 0, 0);
                    SendMessageW(m_self->m_volume, TBM_SETPOS,
                                (WPARAM)TRUE,               //redraw flag
                                (LPARAM)dwPos);
                    m_self->on_volume_valueChanged(dwPos);
                    break;
                default:
                    break;
                }
            }
            break;
        }
        case WM_COMMAND:
        {
            switch(HIWORD(wParam))
            {
                case BN_CLICKED:
                {
                    switch( LOWORD(wParam) )
                    {
                    case CMD_Open:
                        m_self->on_open_clicked();
                        break;
                    case CMD_Play:
                        m_self->on_play_clicked();
                        break;
                    case CMD_Stop:
                        m_self->on_stop_clicked();
                        break;
                    case CMD_SetDefault:
                        m_self->on_resetDefaultADLMIDI_clicked();
                        break;
                    case CMD_RecordWave:
                    {
                        BOOL checked = IsDlgButtonChecked(hWnd, CMD_RecordWave);
                        if (checked)
                        {
                            CheckDlgButton(hWnd, CMD_RecordWave, BST_UNCHECKED);
                            m_self->on_recordWav_clicked(false);
                        } else {
                            CheckDlgButton(hWnd, CMD_RecordWave, BST_CHECKED);
                            m_self->on_recordWav_clicked(true);
                        }
                        break;
                    }
                    case CMD_Reverb:
                    {
                        if (PGE_MusicPlayer::reverbEnabled)
                        {
                            CheckMenuItem(m_self->m_contextMenu, CMD_Reverb, MF_UNCHECKED);
                            Mix_UnregisterEffect(MIX_CHANNEL_POST, reverbEffect);
                            PGE_MusicPlayer::reverbEnabled = false;
                        } else {
                            CheckMenuItem(m_self->m_contextMenu, CMD_Reverb, MF_CHECKED);
                            Mix_RegisterEffect(MIX_CHANNEL_POST, reverbEffect, reverbEffectDone, NULL);
                            PGE_MusicPlayer::reverbEnabled = true;
                        }
                        break;
                    }
                    case CMD_ShowLicense:
                    {
                        ShellExecuteW(0, 0, L"http://www.gnu.org/licenses/gpl", 0, 0 , SW_SHOW);
                        break;
                    }
                    case CMD_ShowSource:
                    {
                        ShellExecuteW(0, 0, L"https://github.com/WohlSoft/PGE-Project", 0, 0 , SW_SHOW);
                        break;
                    }
                    default:
                        break;
                    }
                    break;
                }
            }
            break;
        }
        case WM_DROPFILES:
        {
            HDROP hDropInfo = (HDROP)wParam;
            wchar_t sItem[MAX_PATH];
            memset(sItem, 0, MAX_PATH*sizeof(wchar_t));
            if(DragQueryFileW(hDropInfo, 0, (LPWSTR)sItem, sizeof(sItem)))
            {
                m_self->openMusicByArg(Wstr2Str(sItem));
            }
            DragFinish(hDropInfo);
            break;
        }
        case WM_CONTEXTMENU:
        {
            SetForegroundWindow(hWnd);
            TrackPopupMenu(m_self->m_contextMenu,TPM_RIGHTBUTTON|TPM_TOPALIGN|TPM_LEFTALIGN,
                           LOWORD( lParam ),
                           HIWORD( lParam ), 0, hWnd, NULL);
            break;
        }
        //Инфо о минимальном и максимальном размере окна
        case WM_GETMINMAXINFO:
        {
            MINMAXINFO *minMax = (MINMAXINFO*)lParam;
            minMax->ptMinTrackSize.x = 350;
            minMax->ptMinTrackSize.y = m_self->m_height;
            break;
        }
        case WM_CREATE:
        {
            m_self->initUI(hWnd);
            break;
        }
        //Окно было закрыто
        case WM_DESTROY:
        {
            PostQuitMessage(0);
            return 0;
        }
    }
    return DefWindowProc(hWnd, msg, wParam, lParam);
}
コード例 #12
0
ファイル: sound-main.c プロジェクト: InvertedBit/6502_emu
int main(int argc, char* argv[]){
  foutp=fopen("data.out", "w");
  close(foutp);
  //smpls = gen_triangle_buffer();
  //  smpls = gen_sawtooth_buffer();
  smpls = snd_load("/media/c5bcf67f-e9eb-4e12-be75-d8b6e09e27ba/olivier/hti/ginf/cpu-emu/cpu-emu/sin.table");
  

  /* //sound_buffer = malloc(sizeof(SNDFMT)*512); */
  /* 	//	mem[0] = malloc(sizeof(SNDFMT)*mem0size); */
  /* 	//	mem[1] = malloc(sizeof(SNDFMT)*mem1size); */
  
  /* // init without mixer        init_sdl ();  */

  /* // start SDL with audio support */
  
  if (SDL_Init (SDL_INIT_VIDEO|SDL_INIT_AUDIO) < 0)
    exit (-1);

  atexit (SDL_Quit);
  screen = SDL_SetVideoMode (640, 480, 16, SDL_HWSURFACE);

  if (screen == NULL)
    exit (-1);

  // open SMPFREQ, signed 8bit, system byte order,
  //      stereo audio, using 1024 byte chunks
  if(Mix_OpenAudio(SMPFREQ, AUDIO_S8, 1, WAVEFORM_LENGTH)==-1) {
    printf("Mix_OpenAudio: %s\n", Mix_GetError());
    exit(2);
  }

  Mix_Chunk *sound = NULL; 
  
  sound = Mix_QuickLoad_RAW(smpls,WAVEFORM_LENGTH);

  if(sound == NULL) {
    fprintf(stderr, "Unable to load WAV file: %s\n", Mix_GetError());
  }
  
   int channel;
  
  channel = Mix_PlayChannel(-1, sound, -1);
  if(channel == -1) {
    fprintf(stderr, "Unable to play WAV file: %s\n", Mix_GetError());
  }
  //while(Mix_Playing(channel) != 0);

  int len = WAVEFORM_LENGTH;
  smpls = gen_sin_buffer();
  save("sin.out",smpls,len);
  smpls = gen_triangle_buffer();
  save("triangle.out",smpls,len);
  smpls = gen_sawtooth_buffer();
  save("sawtooth.out",smpls,len);
  smpls = gen_square_buffer();
  save("square.out",smpls,len);
  smpls = gen_pwm_buffer(0.2);
  save("pwm.out",smpls,len);
  
  
 // violine
  int attack = 500;
  int decay = 300;
  int sustain = 10;
  int sustainlength0 = (attack / 1000.0) * SMPFREQ;
  int sustain_max = 15; // 4 Bit 0-15
  float sustain0 = (float) sustain * ((float)1.0)/(float)sustain_max;
  float sustain_level = sustain0;
  int release = 750; 
  int release0 = (release / 1000.0) * SMPFREQ;
  int attack0 = (attack / 1000.0) * SMPFREQ;
  int decay0  = (decay  / 1000.0) * SMPFREQ;
  int t1 = attack0;
  int t2 = t1 + decay0;
  int t3 = t2 + sustainlength0;
  int t4 = t3 + release0;

 instrument[0].a_attack = ((float)1.0/(float)attack0);
  instrument[0].a_decay  =  ((float) ( 1.0 - sustain0)) / (float) ( t1-t2) ;
  instrument[0].b_decay = (float)1.0 - ((float)instrument[0].a_decay*(float)attack0);
  instrument[0].a_release = sustain_level / (float) (t3-t4) ;
  instrument[0].b_release = sustain_level - (float)instrument[0].a_release * (float)t3;
  instrument[0].adsr_counter = 0;
  instrument[0].gate=0;
  adsr_length = gen_adsr_buffer(&adsr_buffer);

  saveadsr("data.out",adsr_buffer,adsr_length);
  savebuffer = malloc(sizeof(float)*adsr_length);
  //  register adsrEffect as a mix processor

  if(!Mix_RegisterEffect(channel, adsrEffect, NULL, &(instrument[0]) )) {
    printf("Mix_RegisterEffect: %s\n", Mix_GetError());
  }
	

  /* Mix_VolumeChunk(sound, volume); */
  /* printf("volume: %d\n", volume); */


  /* 	Hz=440; */

  /* 	//	main_synthesiser(1, NULL); */
  /* 	printf("start play\n"); */

  /* 	//        play (); */

  /* 	//	SDL_MixAudio(stream, waveptr, len, SDL_MIX_MAXVOLUME);  */

	int i=0;
	SDL_Event event;
	int done=0;
	int hzinc=0,amplitudeinc;
	


	/*

	float* adsrptr;
	int len;
	saveadsr("data.out",adsrptr,len);
	if(smp_index < WAVEFORM_LENGTH){
	  for(i = 0; i < len; i++){
            adsrptr[i] = adsrptr[i] * smpls[(int)smp_index];
	    //            smp_index +=freq;
	    smp_index++;
            if(smp_index >= WAVEFORM_LENGTH)
                smp_index = 0;
	  }
	}
	Mix_CloseAudio();
	SDL_Quit();
        return 0; 
	*/

	while(!done) {
	  while(SDL_PollEvent(&event)) {
	    
 switch(event.type) {
	    case SDL_KEYDOWN:	
      switch(event.key.keysym.sym){
	      case SDLK_LEFT:
		volume-=10;
		Mix_VolumeChunk(sound, volume);
		//		Mix_VolumeChunk(sound, (volume>MIX_MAX_VOLUME-10) ?  (volume = MIX_MAX_VOLUME):(volume-=10) );
		printf("SDLK_LEFT volume: %i\n",volume);
		amplitudeinc = -1;
		break;
	      case SDLK_RIGHT:
		volume+=10;
		Mix_VolumeChunk(sound, volume );
		//		Mix_VolumeChunk(sound, (volume<10) ?  (volume = 0): (volume+=10) );
		printf("SDLK_RIGHT volume: %i\n",volume);
		amplitudeinc = +1;;
		break;
	      case SDLK_UP:
		hzinc = 1;
		printf("up active\n");
		break;
	      case SDLK_DOWN:
		hzinc = -1;
		printf("down active\n");
		break;
	      default:
		handleKey(event.key);
		break;
	      }
	      break;
	    case SDL_KEYUP:
	      switch(event.key.keysym.sym){
	      case SDLK_LEFT:
		amplitudeinc = 0;
		break;
	      case SDLK_RIGHT:
		amplitudeinc = 0;
		break;
	      case SDLK_UP:
		tonstufe++;
		hzinc = 0;
		printf("up in-active\n");
		break;
	      case SDLK_DOWN:
		tonstufe--;
		hzinc = 0;
		printf("down in-active\n");
		break;
	      default:
		handleKey(event.key);
		break;
	      }
	      break;
	    case SDL_QUIT:
	      done = 1;
	      printf("SDL_QUIT\n");
	      break;
	    case SDL_MOUSEBUTTONUP:
	      switch(event.button.button){
		case SDL_BUTTON_WHEELUP:
		  Hz += 1;
		  break;
		case SDL_BUTTON_WHEELDOWN:
		  Hz -= 1;
		  break;
		}
	      break;
	    default:
	      /* do nothing */
	      break;
	    }
	  }
	  
	  freq += hzinc;

	  //Hz= 2*Hz;
	  Hz = Hz + hzinc;
	  amplitude = amplitude + amplitudeinc;
	  //	  printf("Hz: %f\n",Hz);
	  //% Hz = frequency(music[i++%10]);
	  int y;
	  //	  SDL_Flip(screen);
	  SDL_Delay (50);
	}
	//	save("sndout6.snd");
	saveadsr("adsr.out",savebuffer,adsr_length);

	
	Mix_FreeChunk(sound);
	
	Mix_CloseAudio();
	SDL_Quit();
        return 0; 
	

	
} 
コード例 #13
0
int main(int argc, char* argv[]){


  SNDFMT* smpls = gen_sin_buffer();
  //  smpls = snd_load("/media/c5bcf67f-e9eb-4e12-be75-d8b6e09e27ba/olivier/hti/ginf/cpu-emu/cpu-emu/sin.table");
  

  /* // start SDL with audio support */
  
  if (SDL_Init (SDL_INIT_VIDEO|SDL_INIT_AUDIO) < 0)
    exit (-1);

  atexit (SDL_Quit);
  screen = SDL_SetVideoMode (640, 480, 16, SDL_HWSURFACE);

  if (screen == NULL)
    exit (-1);

  // open SMPFREQ, signed 8bit, system byte order,
  //      stereo audio, using 1024 byte chunks
  if(Mix_OpenAudio(SMPFREQ, AUDIO_S8, 1, WAVEFORM_LENGTH)==-1) {
    printf("Mix_OpenAudio: %s\n", Mix_GetError());
    exit(2);
  }
  
  Mix_AllocateChannels(SID_VOICES_NR);

  Mix_Chunk *sound = NULL; 
	
  sound = Mix_QuickLoad_RAW(smpls,WAVEFORM_LENGTH);

  if(sound == NULL) { 
     fprintf(stderr, "Unable to load WAV file: %s\n", Mix_GetError()); 
   } 
  
  int channel;
  int channel2;
  channel = Mix_PlayChannel(-1, sound, -1);
  //  channel2 = Mix_PlayChannel(-1, sound, -1);
  if(channel == -1) {
    fprintf(stderr, "Unable to play WAV file: %s\n", Mix_GetError());
  }

  

  init_SID(&sid);
  
  
  
  if(!Mix_RegisterEffect(channel, adsrEffect0, NULL, sid.voicea )) {
    printf("Mix_RegisterEffect: %s\n", Mix_GetError());
  }
  /*
  if(!Mix_RegisterEffect(channel, adsrEffect0, NULL, sid.voiceb )) {
	printf("Mix_RegisterEffect: %s\n", Mix_GetError());
  }
  if(!Mix_RegisterEffect(channel, adsrEffect0, NULL, sid.voicec )) {
	printf("Mix_RegisterEffect: %s\n", Mix_GetError());
  }
  */ 

  /*

	play time

  */
  struct sid_6581_voice  *voicea = sid.voicea;
  struct sid_6581_voice  *voiceb = sid.voiceb;
  struct sid_6581_voice  *voicec = sid.voicec;

  int i=0,j=0;
  for(i=0;i<3;i++){
	voicea->frequency = 23436;
	voicea->control =  voicea->control | SID_GATE ;
	SDL_Delay (50);
	voicea->frequency = 7382;
	voicea->attack=200;
	voicea->decay=20;
	voicea->sustain = 8;
	voicea->release=20;
	voicea->attack = 200;
	voicea->control =  voicea->control & ~SID_GATE ;
	SDL_Delay (500);

	voicea->frequency = 14764;
	voicea->attack=200;
	voicea->decay=20;
	voicea->sustain = 6;
	voicea->release=1000;
	voicea->control =  voicea->control | SID_GATE ;
	for(j=0;j<10;j++){
	  SDL_Delay (10);
	  voicea->frequency = 14764+14764*j*1/100;
	}
	voicea->control =  voicea->control & ~SID_GATE ;	
	voicea->control =  voicea->control | SID_GATE ;
	SDL_Delay (50);
	voicea->control =  voicea->control & ~SID_GATE ;
	SDL_Delay (50);
	voicea->frequency = 10440;
	voicea->control =  voicea->control | SID_GATE ;
	SDL_Delay (50);
	voicea->control =  ((((voicea->control & ~SID_GATE) | SID_SAWT ) & ~SID_PULS )  & ~SID_TRIA ) & ~SID_NOIS ;
	SDL_Delay (50);
	voicea->frequency = 7382;
	voicea->control =  voicea->control | SID_GATE ;
	SDL_Delay (50);
	voicea->control =  voicea->control & ~SID_GATE ;
	SDL_Delay (50);
  }
  /*
	two voices
  */
    
  voicea->frequency = 7382;
  voicea->attack=200;
  voicea->decay=200;
  voicea->sustain = 6;
  voicea->release=1000;

  voiceb->frequency = 9301;
  voiceb->attack=120;
  voiceb->decay=20;
  voiceb->sustain = 6;
  voiceb->release=1000;

  voicea->control =  voicea->control | SID_GATE | SID_PULS ;
  voiceb->control =  voiceb->control | SID_GATE | SID_SAWT ;
  SDL_Delay(400);
  voicea->control =  voicea->control & ~SID_GATE ;
  voiceb->control =  voiceb->control & ~SID_GATE ;
  SDL_Delay(300);

  sid.voicea->frequency = 7382;
  sid.voiceb->frequency = 8286;
  sid.voicea->control =  voicea->control | SID_GATE ;
  sid.voiceb->control =  voiceb->control | SID_GATE ;
  SDL_Delay(400);
  sid.voicea->control =  voicea->control & ~SID_GATE ;
  sid.voiceb->control =  voiceb->control & ~SID_GATE ;
  SDL_Delay(300);

  sid.voicea->frequency = 7382;
  sid.voiceb->frequency = 8779;
  sid.voicea->control =  voicea->control | SID_GATE ;
  sid.voiceb->control =  voiceb->control | SID_GATE ;
  SDL_Delay(400);
  sid.voicea->control =  voicea->control & ~SID_GATE ;
  sid.voiceb->control =  voiceb->control & ~SID_GATE ;
  SDL_Delay(300);

  sid.voicea->frequency = 7382;
  sid.voiceb->frequency = 9301;
  sid.voicea->control =  voicea->control | SID_GATE ;
  sid.voiceb->control =  voiceb->control | SID_GATE ;
  SDL_Delay(400);
  sid.voicea->control =  voicea->control & ~SID_GATE ;
  sid.voiceb->control =  voiceb->control & ~SID_GATE ;
  SDL_Delay(300);


  SDL_Event event;
  int done=0;

  interface_voice = sid.voicea;

  while(!done) {
	while(SDL_PollEvent(&event)) {
	    
	  switch(event.type) {
	  case SDL_KEYDOWN:	
		switch(event.key.keysym.sym){
		case SDLK_LEFT:
		  (sid.filter->volume - 1) < 0 ? 0 : sid.filter->volume--;
		  volume-=10;
		  Mix_VolumeChunk(sound, volume);
		  //		Mix_VolumeChunk(sound, (volume>MIX_MAX_VOLUME-10) ?  (volume = MIX_MAX_VOLUME):(volume-=10) );
		  printf("SDLK_LEFT volume: %i\n",volume);
		  break;
		case SDLK_RIGHT:
		  (sid.filter->volume + 1) >16 ? 15 : sid.filter->volume++;
		  volume+=10;
		  Mix_VolumeChunk(sound, volume );
		  //		Mix_VolumeChunk(sound, (volume<10) ?  (volume = 0): (volume+=10) );
		  printf("SDLK_RIGHT volume: %i\n",volume);
		  break;
		case SDLK_UP:
		  printf("up active\n");
		  break;
		case SDLK_DOWN:
		  printf("down active\n");
		  break;
		default:
		  handleKey(event.key);
		  break;
		}
		break;
	  case SDL_KEYUP:
		switch(event.key.keysym.sym){
		case SDLK_LEFT:

		  break;
		case SDLK_RIGHT:

		  break;
		case SDLK_UP:
		  interface_voice->frequency = interface_voice->frequency + interface_voice->frequency*1/100;
		  printf("up in-active\n");
		  break;
		case SDLK_DOWN:
		  interface_voice->frequency = interface_voice->frequency - interface_voice->frequency*1/100;
		  printf("down in-active\n");
		  break;
		default:
		  handleKey(event.key);
		  break;
		}
		break;
	  case SDL_QUIT:
		done = 1;
		printf("SDL_QUIT\n");
		break;
	  case SDL_MOUSEBUTTONUP:
		switch(event.button.button){
		case SDL_BUTTON_WHEELUP:
		  interface_voice->frequency = interface_voice->frequency + interface_voice->frequency*1/100;
		  break;
		case SDL_BUTTON_WHEELDOWN:
		  interface_voice->frequency = interface_voice->frequency - interface_voice->frequency*1/100;
		  break;
		}
		break;
	  default:
		/* do nothing */
		break;
	  }
	}
	  

	//	  SDL_Flip(screen);
	SDL_Delay (50);
  }

	
  Mix_FreeChunk(sound);
	
  Mix_CloseAudio();
  SDL_Quit();
  return 0; 
	

	
}