engine/e_sound_sdl.inc

   1 (* Copyright (C)  Doom 2D: Forever Developers
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, version 3 of the License ONLY.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  14  *)
  15 interface
  16
  17 uses
  18   {$IFDEF USE_MEMPOOL}mempool,{$ENDIF}
  19   SDL2, SDL2_mixer, envvars,
  20   e_log, SysUtils;
  21
  22 type
  23   TSoundRec = record
  24     Data: Pointer;
  25     Sound: PMix_Chunk;
  26     Music: PMix_Music;
  27     isMusic: Boolean;
  28     Loops: Boolean;
  29     nRefs: Integer;
  30   end;
  31
  32   TBasicSound = class{$IFDEF USE_MEMPOOL}(TPoolObject){$ENDIF}
  33   private
  34     FChanNum: Integer; // <0: no channel allocated
  35
  36   protected
  37     FID: DWORD;
  38     FMusic: Boolean;
  39     FPosition: DWORD;
  40     FPriority: Integer;
  41
  42     function RawPlay(Pan: Single; Volume: Single; aPos: DWORD): Boolean;
  43     function GetChan (): Integer;
  44
  45     property Channel: Integer read GetChan;
  46
  47   public
  48     constructor Create();
  49     destructor Destroy(); override;
  50     procedure SetID(ID: DWORD);
  51     procedure FreeSound();
  52     function IsPlaying(): Boolean;
  53     procedure Stop();
  54     function IsPaused(): Boolean;
  55     procedure Pause(Enable: Boolean);
  56     function GetVolume(): Single;
  57     procedure SetVolume(Volume: Single);
  58     function GetPan(): Single;
  59     procedure SetPan(Pan: Single);
  60     function IsMuted(): Boolean;
  61     procedure Mute(Enable: Boolean);
  62     function GetPosition(): DWORD;
  63     procedure SetPosition(aPos: DWORD);
  64     procedure SetPriority(priority: Integer);
  65   end;
  66
  67 const
  68   NO_SOUND_ID = DWORD(-1);
  69
  70 function e_InitSoundSystem(NoOutput: Boolean = False): Boolean;
  71
  72 function e_LoadSound(FileName: string; var ID: DWORD; isMusic: Boolean; ForceNoLoop: Boolean = False): Boolean;
  73 function e_LoadSoundMem(pData: Pointer; Length: Integer; var ID: DWORD; isMusic: Boolean; ForceNoLoop: Boolean = False): Boolean;
  74
  75 // returns channel number or -1
  76 function e_PlaySound(ID: DWORD): Integer;
  77 function e_PlaySoundPan(ID: DWORD; Pan: Single): Integer;
  78 function e_PlaySoundVolume(ID: DWORD; Volume: Single): Integer;
  79 function e_PlaySoundPanVolume(ID: DWORD; Pan, Volume: Single): Integer;
  80
  81 procedure e_ModifyChannelsVolumes(SoundMod: Single; setMode: Boolean);
  82 procedure e_MuteChannels(Enable: Boolean);
  83 procedure e_StopChannels();
  84
  85 procedure e_DeleteSound(ID: DWORD);
  86 procedure e_RemoveAllSounds();
  87 procedure e_ReleaseSoundSystem();
  88 procedure e_SoundUpdate();
  89
  90 var
  91   e_SoundsArray: array of TSoundRec = nil;
  92
  93 implementation
  94
  95 uses
  96   g_window, g_options;
  97
  98 const
  99   N_CHANNELS = 512;
 100   N_MUSCHAN = N_CHANNELS+42;
 101
 102 type
 103   TChanInfo = record
 104     id: DWORD; // sound id
 105     muted: Boolean;
 106     oldvol: Integer; // for muted
 107     pan: Single;
 108   end;
 109
 110 var
 111   SoundMuted: Boolean = False;
 112   SoundInitialized: Boolean = False;
 113   ChanSIds: array[0..N_CHANNELS] of TChanInfo;
 114   MusVolume: Integer = MIX_MAX_VOLUME;
 115
 116
 117 procedure chanFinished (chan: Integer); cdecl;
 118 begin
 119   //e_WriteLog(Format('chanFinished: %d', [chan]), TMsgType.Notify);
 120   if (chan >= 0) and (chan < N_CHANNELS) then
 121   begin
 122     if ChanSIds[chan].id <> NO_SOUND_ID then
 123     begin
 124       if (ChanSIds[chan].id <= High(e_SoundsArray)) and (e_SoundsArray[ChanSIds[chan].id].nRefs > 0) then
 125       begin
 126         Dec(e_SoundsArray[ChanSIds[chan].id].nRefs);
 127       end;
 128       ChanSIds[chan].id := NO_SOUND_ID;
 129     end;
 130   end;
 131 end;
 132
 133
 134 procedure dumpMusicType (ms: PMix_Music);
 135 begin
 136   if ms = nil then
 137   begin
 138     e_WriteLog('MUSIC FORMAT: NONE', TMsgType.Notify);
 139   end
 140   else
 141   begin
 142     case Mix_GetMusicType(ms^) of
 143       TMix_MusicType.MUS_NONE:
 144         e_WriteLog('MUSIC FORMAT: NONE', TMsgType.Notify);
 145       TMix_MusicType.MUS_CMD:
 146         e_WriteLog('MUSIC FORMAT: CMD', TMsgType.Notify);
 147       TMix_MusicType.MUS_WAV:
 148         e_WriteLog('MUSIC FORMAT: WAV', TMsgType.Notify);
 149       TMix_MusicType.MUS_MOD:
 150         e_WriteLog('MUSIC FORMAT: MOD', TMsgType.Notify);
 151       TMix_MusicType.MUS_MID:
 152         e_WriteLog('MUSIC FORMAT: MID', TMsgType.Notify);
 153       TMix_MusicType.MUS_OGG:
 154         e_WriteLog('MUSIC FORMAT: OGG', TMsgType.Notify);
 155       TMix_MusicType.MUS_MP3:
 156         e_WriteLog('MUSIC FORMAT: MP3', TMsgType.Notify);
 157       TMix_MusicType.MUS_MP3_MAD:
 158         e_WriteLog('MUSIC FORMAT: MP3_MAD', TMsgType.Notify);
 159       TMix_MusicType.MUS_FLAC:
 160         e_WriteLog('MUSIC FORMAT: FLAC', TMsgType.Notify);
 161       TMix_MusicType.MUS_MODPLUG:
 162         e_WriteLog('MUSIC FORMAT: MODPLUG', TMsgType.Notify);
 163       otherwise
 164         e_WriteLog('MUSIC FORMAT: UNKNOWN', TMsgType.Notify);
 165     end;
 166   end;
 167 end;
 168
 169 function e_InitSoundSystem(NoOutput: Boolean = False): Boolean;
 170 var
 171   res, i: Integer;
 172   rfreq: Integer;
 173   rformat: UInt16;
 174   rchans: Integer;
 175 begin
 176   if SoundInitialized then begin Result := true; Exit end;
 177
 178   Result := False;
 179   SoundInitialized := False;
 180
 181   {$IFDEF HEADLESS}
 182     // HACK: shit this into env and hope for the best
 183     SetEnvVar('SDL_AUDIODRIVER', 'dummy');
 184   {$ENDIF}
 185
 186   if NoOutput then begin Result := true; Exit end;
 187
 188   // wow, this is actually MIDI player!
 189   // we need module player
 190   res := Mix_Init(MIX_INIT_FLAC or MIX_INIT_MOD or MIX_INIT_MODPLUG or MIX_INIT_MP3 or MIX_INIT_OGG or MIX_INIT_FLUIDSYNTH);
 191   e_WriteLog(Format('SDL: res=0x%x', [res]), TMsgType.Notify);
 192   if (res and MIX_INIT_FLAC) <> 0 then e_WriteLog('SDL: FLAC playback is active', TMsgType.Notify);
 193   if (res and MIX_INIT_MOD) <> 0 then e_WriteLog('SDL: MOD playback is active', TMsgType.Notify);
 194   if (res and MIX_INIT_MODPLUG) <> 0 then e_WriteLog('SDL: MODPLUG playback is active', TMsgType.Notify);
 195   if (res and MIX_INIT_MP3) <> 0 then e_WriteLog('SDL: MP3 playback is active', TMsgType.Notify);
 196   if (res and MIX_INIT_OGG) <> 0 then e_WriteLog('SDL: OGG playback is active', TMsgType.Notify);
 197   if (res and MIX_INIT_FLUIDSYNTH) <> 0 then e_WriteLog('SDL: FLUIDSYNTH playback is active', TMsgType.Notify);
 198
 199   e_WriteLog(Format('SDL: initializing mixer at %d with buffer %d', [gsSDLSampleRate, gsSDLBufferSize]), TMsgType.Notify);
 200   res := Mix_OpenAudio(gsSDLSampleRate, AUDIO_S16LSB, 2, gsSDLBufferSize);
 201   if res = -1 then
 202   begin
 203     e_WriteLog('Error initializing SDL mixer:', TMsgType.Fatal);
 204     e_WriteLog(Mix_GetError(), TMsgType.Fatal);
 205     Exit;
 206   end;
 207
 208   if Mix_QuerySpec(@rfreq, @rformat, @rchans) > 0 then
 209   begin
 210     e_WriteLog(Format('SDL: frequency=%d; format=%u; channels=%d', [rfreq, rformat, rchans]), TMsgType.Notify);
 211   end;
 212
 213   for i := 0 to Mix_GetNumChunkDecoders()-1 do
 214   begin
 215     e_WriteLog(Format('SDL: chunk decoder %s is avalable', [Mix_GetChunkDecoder(i)]), TMsgType.Notify);
 216   end;
 217   for i := 0 to Mix_GetNumMusicDecoders()-1 do
 218   begin
 219     e_WriteLog(Format('SDL: music decoder %s is avalable', [Mix_GetMusicDecoder(i)]), TMsgType.Notify);
 220   end;
 221
 222   Mix_AllocateChannels(N_CHANNELS);
 223   Mix_ChannelFinished(chanFinished);
 224
 225   for i := 0 to N_CHANNELS-1 do
 226   begin
 227     ChanSIds[i].id := NO_SOUND_ID;
 228     ChanSIds[i].muted := SoundMuted;
 229     ChanSIds[i].oldvol := MIX_MAX_VOLUME;
 230     ChanSIds[i].pan := 1.0;
 231   end;
 232   MusVolume := MIX_MAX_VOLUME;
 233
 234   SoundInitialized := True;
 235   Result := True;
 236 end;
 237
 238 function e_isMusic (id: DWORD): Boolean;
 239 begin
 240   Result := False;
 241   if (e_SoundsArray <> nil) and (id <= High(e_SoundsArray)) then
 242   begin
 243     Result := (e_SoundsArray[id].Music <> nil);
 244   end;
 245 end;
 246
 247 function e_isSound (id: DWORD): Boolean;
 248 begin
 249   Result := False;
 250   if (e_SoundsArray <> nil) and (id <= High(e_SoundsArray)) then
 251   begin
 252     Result := (e_SoundsArray[id].Sound <> nil);
 253   end;
 254 end;
 255
 256 function FindESound(): DWORD;
 257 var
 258   i: Integer;
 259 begin
 260   if e_SoundsArray <> nil then
 261   begin
 262     for i := 0 to High(e_SoundsArray) do
 263       if (e_SoundsArray[i].Sound = nil) and (e_SoundsArray[i].Music = nil) then
 264       begin
 265         Result := i;
 266         Exit;
 267       end;
 268   end;
 269   if e_SoundsArray = nil then
 270   begin
 271     SetLength(e_SoundsArray, 16);
 272     Result := 0;
 273   end
 274   else
 275   begin
 276     Result := High(e_SoundsArray) + 1;
 277     SetLength(e_SoundsArray, Length(e_SoundsArray) + 16);
 278   end;
 279   for i := Result to High(e_SoundsArray) do
 280   begin
 281     e_SoundsArray[i].Sound := nil;
 282     e_SoundsArray[i].Music := nil;
 283     e_SoundsArray[i].Data := nil;
 284     e_SoundsArray[i].isMusic := False;
 285     e_SoundsArray[i].nRefs := 0;
 286   end;
 287 end;
 288
 289 function e_LoadSound(FileName: String; var ID: DWORD; isMusic: Boolean; ForceNoLoop: Boolean = False): Boolean;
 290 var
 291   find_id: DWORD;
 292 begin
 293   ID := NO_SOUND_ID;
 294   Result := False;
 295   if not SoundInitialized then Exit;
 296
 297   if isMusic then e_WriteLog('Loading music '+FileName+'...', TMsgType.Notify)
 298   else e_WriteLog('Loading sound '+FileName+'...', TMsgType.Notify);
 299
 300   {
 301   if isMusic then
 302   begin
 303     e_WriteLog('IGNORING MUSIC FROM FILE', TMsgType.Warning);
 304     Exit;
 305   end;
 306   }
 307
 308   find_id := FindESound();
 309
 310   e_SoundsArray[find_id].Data := nil;
 311   e_SoundsArray[find_id].isMusic := isMusic;
 312   e_SoundsArray[find_id].Loops := isMusic and not ForceNoLoop;
 313   e_SoundsArray[find_id].nRefs := 0;
 314
 315   if isMusic then
 316   begin
 317     e_WriteLog(Format('  MUSIC SLOT: %u', [find_id]), TMsgType.Notify);
 318     e_SoundsArray[find_id].Music := Mix_LoadMUS(PAnsiChar(FileName));
 319     if e_SoundsArray[find_id].Music = nil then
 320     begin
 321       e_WriteLog(Format('ERROR LOADING MUSIC:', [find_id]), TMsgType.Warning);
 322       e_WriteLog(Mix_GetError(), TMsgType.Warning);
 323       Exit;
 324     end;
 325     dumpMusicType(e_SoundsArray[find_id].Music);
 326   end
 327   else
 328   begin
 329     e_SoundsArray[find_id].Sound := Mix_LoadWAV(PAnsiChar(FileName));
 330     if e_SoundsArray[find_id].Sound = nil then Exit;
 331   end;
 332
 333   ID := find_id;
 334
 335   Result := True;
 336 end;
 337
 338 function e_LoadSoundMem(pData: Pointer; Length: Integer; var ID: DWORD; isMusic: Boolean; ForceNoLoop: Boolean = False): Boolean;
 339 var
 340   find_id: DWORD;
 341   rw: PSDL_RWops;
 342   //pc: PChar;
 343   isid3: Boolean;
 344 begin
 345   ID := NO_SOUND_ID;
 346   Result := False;
 347   if not SoundInitialized then Exit;
 348   isid3 := False;
 349
 350   {
 351   if isMusic then
 352   begin
 353     e_WriteLog('IGNORING MUSIC FROM MEMORY', TMsgType.Warning);
 354     Exit;
 355   end;
 356   }
 357
 358   //FIXME: correctly skip ID3
 359   {
 360   pc := PChar(pData);
 361   if (Length > $400) and (pc[0] = 'I') and (pc[1] = 'D') and (pc[2] = '3') then
 362   begin
 363     isid3 := True;
 364     Inc(pc, $400);
 365     pData := Pointer(pc);
 366     Dec(Length, $400);
 367     e_WriteLog('MUSIC: MP3 ID3 WORKAROUND APPLIED!', TMsgType.Warning);
 368   end;
 369   }
 370
 371   rw := SDL_RWFromConstMem(pData, Length);
 372   if rw = nil then Exit;
 373
 374   find_id := FindESound();
 375
 376   e_SoundsArray[find_id].Data := pData;
 377   if isid3 then e_SoundsArray[find_id].Data := nil;
 378   e_SoundsArray[find_id].isMusic := isMusic;
 379   e_SoundsArray[find_id].Loops := isMusic and not ForceNoLoop;
 380   e_SoundsArray[find_id].nRefs := 0;
 381
 382   if isMusic then
 383   begin
 384     e_WriteLog(Format('  MUSIC SLOT: %u', [find_id]), TMsgType.Notify);
 385     e_SoundsArray[find_id].Music := Mix_LoadMUS_RW(rw, 0);
 386     if e_SoundsArray[find_id].Music = nil then
 387     begin
 388       e_WriteLog(Format('ERROR LOADING MUSIC:', [find_id]), TMsgType.Warning);
 389       e_WriteLog(Mix_GetError(), TMsgType.Warning);
 390     end
 391     else
 392     begin
 393       dumpMusicType(e_SoundsArray[find_id].Music);
 394     end;
 395     //SDL_FreeRW(rw);
 396     {
 397     if e_SoundsArray[find_id].Music <> nil then
 398     begin
 399       Mix_FreeMusic(e_SoundsArray[find_id].Music);
 400     end;
 401     e_SoundsArray[find_id].Music := nil;
 402     Exit;
 403     }
 404   end
 405   else
 406   begin
 407     e_SoundsArray[find_id].Sound := Mix_LoadWAV_RW(rw, 0);
 408   end;
 409   //SDL_FreeRW(rw); // somehow it segfaults...
 410   if (e_SoundsArray[find_id].Sound = nil) and (e_SoundsArray[find_id].Music = nil) then
 411   begin
 412     e_SoundsArray[find_id].Data := nil;
 413     Exit;
 414   end;
 415
 416   ID := find_id;
 417
 418   Result := True;
 419 end;
 420
 421 function e_PlaySound (ID: DWORD): Integer;
 422 var
 423   res: Integer = -1;
 424   loops: Integer = 0;
 425 begin
 426   Result := -1;
 427   if not SoundInitialized then Exit;
 428
 429   if e_isSound(ID) then
 430   begin
 431     if e_SoundsArray[ID].nRefs >= gMaxSimSounds then Exit;
 432     Inc(e_SoundsArray[ID].nRefs);
 433     if e_SoundsArray[ID].Loops then loops := -1;
 434     res := Mix_PlayChannel(-1, e_SoundsArray[ID].Sound, loops);
 435     if res >= 0 then
 436     begin
 437       ChanSIds[res].id := ID;
 438       ChanSIds[res].muted := SoundMuted;
 439       if SoundMuted then Mix_Volume(res, 0) else Mix_Volume(res, ChanSIds[res].oldvol);
 440       {
 441       if e_SoundsArray[ID].isMusic then
 442         res := Mix_PlayChannel(-1, e_SoundsArray[ID].Sound, -1)
 443       else
 444         res := Mix_PlayChannel(-1, e_SoundsArray[ID].Sound, 0);
 445       }
 446     end;
 447   end
 448   else
 449   begin
 450     if not e_isMusic(ID) then Exit;
 451     Mix_HaltMusic();
 452     if e_SoundsArray[ID].Loops then loops := -1;
 453     res := Mix_PlayMusic(e_SoundsArray[ID].Music, loops);
 454     if res >= 0 then res := N_MUSCHAN;
 455     if SoundMuted then Mix_VolumeMusic(0) else Mix_VolumeMusic(MusVolume);
 456     Result := res;
 457   end;
 458
 459   Result := res;
 460 end;
 461
 462 function e_chanSetPan (chan: Integer; Pan: Single): Boolean;
 463 var
 464   l, r: UInt8;
 465 begin
 466   Result := True;
 467   if chan = N_MUSCHAN then
 468   begin
 469     // no panning for music
 470   end
 471   else if chan >= 0 then
 472   begin
 473     if Pan < -1.0 then Pan := -1.0 else if Pan > 1.0 then Pan := 1.0;
 474     Pan := Pan+1.0; // 0..2
 475     l := trunc(127.0*(2.0-Pan));
 476     r := trunc(127.0*Pan);
 477     Mix_SetPanning(chan, l, r);
 478     ChanSIds[chan].pan := Pan;
 479   end
 480   else
 481   begin
 482     Result := False;
 483   end;
 484 end;
 485
 486 function e_chanSetVol (chan: Integer; Volume: Single): Boolean;
 487 var
 488   vol: Integer;
 489 begin
 490   Result := True;
 491   if Volume < 0 then Volume := 0 else if Volume > 1 then Volume := 1;
 492   vol := trunc(Volume*MIX_MAX_VOLUME);
 493   if chan = N_MUSCHAN then
 494   begin
 495     MusVolume := vol;
 496     if SoundMuted then Mix_VolumeMusic(0) else Mix_VolumeMusic(vol);
 497   end
 498   else if chan >= 0 then
 499   begin
 500     ChanSIds[chan].oldvol := vol;
 501     if ChanSIds[chan].muted then Mix_Volume(chan, 0) else Mix_Volume(chan, vol);
 502   end
 503   else
 504   begin
 505     Result := False;
 506   end;
 507 end;
 508
 509 function e_PlaySoundPan(ID: DWORD; Pan: Single): Integer;
 510 var
 511   chan: Integer;
 512 begin
 513   Result := -1;
 514   chan := e_PlaySound(ID);
 515   e_chanSetPan(chan, Pan);
 516   Result := chan;
 517 end;
 518
 519 function e_PlaySoundVolume(ID: DWORD; Volume: Single): Integer;
 520 var
 521   chan: Integer;
 522 begin
 523   Result := -1;
 524   chan := e_PlaySound(ID);
 525   e_chanSetVol(chan, Volume);
 526   Result := chan;
 527 end;
 528
 529 function e_PlaySoundPanVolume(ID: DWORD; Pan, Volume: Single): Integer;
 530 var
 531   chan: Integer;
 532 begin
 533   Result := -1;
 534   chan := e_PlaySound(ID);
 535   e_chanSetPan(chan, Pan);
 536   e_chanSetVol(chan, Volume);
 537   Result := chan;
 538 end;
 539
 540 procedure e_DeleteSound(ID: DWORD);
 541 var
 542   i: Integer;
 543 begin
 544   if ID > High(e_SoundsArray) then Exit;
 545   if (e_SoundsArray[ID].Sound = nil) and (e_SoundsArray[ID].Music = nil) then Exit;
 546
 547   for i := 0 to N_CHANNELS-1 do
 548   begin
 549     if ChanSIds[i].id = ID then
 550     begin
 551       ChanSIds[i].id := NO_SOUND_ID;
 552       Mix_HaltChannel(i);
 553     end;
 554   end;
 555
 556   if e_SoundsArray[ID].Sound <> nil then Mix_FreeChunk(e_SoundsArray[ID].Sound);
 557   if e_SoundsArray[ID].Music <> nil then Mix_FreeMusic(e_SoundsArray[ID].Music);
 558   if e_SoundsArray[ID].Data <> nil then FreeMem(e_SoundsArray[ID].Data);
 559
 560   e_SoundsArray[ID].Sound := nil;
 561   e_SoundsArray[ID].Music := nil;
 562   e_SoundsArray[ID].Data := nil;
 563   e_SoundsArray[ID].nRefs := 0;
 564 end;
 565
 566 procedure e_ModifyChannelsVolumes(SoundMod: Single; setMode: Boolean);
 567 var
 568   i: Integer;
 569   vol: Single;
 570   ovol: Integer;
 571 begin
 572   for i := 0 to N_CHANNELS-1 do
 573   begin
 574     ovol := ChanSIds[i].oldvol;
 575     if setMode then
 576     begin
 577       vol := SoundMod;
 578     end
 579     else
 580     begin
 581       vol := (MIX_MAX_VOLUME+0.0)/ovol;
 582       vol := vol*SoundMod;
 583     end;
 584     if vol < 0 then vol := 0 else if vol > 1 then vol := 1;
 585     ChanSIds[i].oldvol := trunc(vol*MIX_MAX_VOLUME);
 586     //if i = 0 then e_WriteLog(Format('modifying volumes: vol=%f; newvol=%d', [vol, ChanSIds[i].oldvol]), TMsgType.Warning);
 587     if ChanSIds[i].muted then Mix_Volume(i, 0) else Mix_Volume(i, ChanSIds[i].oldvol);
 588   end;
 589   ovol := Mix_VolumeMusic(-1);
 590   if ovol >= 0 then
 591   begin
 592     if setMode then
 593     begin
 594       vol := SoundMod;
 595     end
 596     else
 597     begin
 598       vol := (MIX_MAX_VOLUME+0.0)/ovol;
 599       vol := vol * SoundMod;
 600     end;
 601     if vol < 0 then vol := 0 else if vol > 1 then vol := 1;
 602     MusVolume := trunc(vol*MIX_MAX_VOLUME);
 603     if SoundMuted then Mix_VolumeMusic(0) else Mix_VolumeMusic(MusVolume);
 604   end;
 605 end;
 606
 607 procedure e_MuteChannels(Enable: Boolean);
 608 var
 609   i: Integer;
 610 begin
 611   //if Enable = SoundMuted then Exit;
 612   SoundMuted := Enable;
 613   for i := 0 to N_CHANNELS-1 do
 614   begin
 615     if ChanSIds[i].muted <> SoundMuted then
 616     begin
 617       ChanSIds[i].muted := SoundMuted;
 618       //e_WriteLog(Format('gmuting sound for channel %d', [i]), TMsgType.Warning);
 619       if ChanSIds[i].muted then Mix_Volume(i, 0) else Mix_Volume(i, ChanSIds[i].oldvol);
 620     end;
 621   end;
 622   //if SoundMuted then e_WriteLog('muting music', TMsgType.Notify) else e_WriteLog(Format('unmuting music (%d)', [MusVolume]), TMsgType.Notify);
 623   if SoundMuted then Mix_VolumeMusic(0) else Mix_VolumeMusic(MusVolume);
 624 end;
 625
 626 procedure e_StopChannels();
 627 var
 628   i: Integer;
 629 begin
 630   Mix_HaltChannel(-1);
 631   Mix_HaltMusic();
 632   for i := 0 to High(e_SoundsArray) do e_SoundsArray[i].nRefs := 0;
 633   for i := 0 to N_CHANNELS-1 do ChanSIds[i].id := NO_SOUND_ID;
 634 end;
 635
 636 procedure e_RemoveAllSounds();
 637 var
 638   i: Integer;
 639 begin
 640   if SoundInitialized then e_StopChannels();
 641   for i := 0 to High(e_SoundsArray) do e_DeleteSound(i);
 642   SetLength(e_SoundsArray, 0);
 643   e_SoundsArray := nil;
 644 end;
 645
 646 procedure e_ReleaseSoundSystem();
 647 begin
 648   e_RemoveAllSounds();
 649   if SoundInitialized then
 650   begin
 651     Mix_CloseAudio();
 652     SoundInitialized := False;
 653   end;
 654 end;
 655
 656 procedure e_SoundUpdate();
 657 begin
 658   //FMOD_System_Update(F_System);
 659 end;
 660
 661
 662 { TBasicSound: }
 663
 664 constructor TBasicSound.Create();
 665 begin
 666   FID := NO_SOUND_ID;
 667   FMusic := False;
 668   FChanNum := -1;
 669   FPosition := 0;
 670   FPriority := 128;
 671 end;
 672
 673 destructor TBasicSound.Destroy();
 674 begin
 675   FreeSound();
 676   inherited;
 677 end;
 678
 679 function TBasicSound.GetChan (): Integer;
 680 begin
 681   if (FID <> NO_SOUND_ID) and (FChanNum >= 0) and (FChanNum < N_CHANNELS) then
 682   begin
 683     if ChanSIds[FChanNum].id <> FID then FChanNum := -1;
 684   end
 685   else if e_isMusic(FID) then
 686   begin
 687     FChanNum := N_MUSCHAN;
 688   end;
 689   Result := FChanNum;
 690 end;
 691
 692 procedure TBasicSound.FreeSound();
 693 begin
 694   if FID = NO_SOUND_ID then Exit;
 695   Stop();
 696   FID := NO_SOUND_ID;
 697   FMusic := False;
 698   FPosition := 0;
 699   FChanNum := -1;
 700 end;
 701
 702 // aPos: msecs
 703 function TBasicSound.RawPlay(Pan: Single; Volume: Single; aPos: DWORD): Boolean;
 704 begin
 705   Result := False;
 706   if (FID = NO_SOUND_ID) or not SoundInitialized then Exit;
 707   FChanNum := e_PlaySoundPanVolume(FID, Pan, Volume);
 708   Result := (FChanNum >= 0);
 709   //if e_isMusic(FID) then e_WriteLog(Format('playing music (%u)', [FID]), TMsgType.Notify);
 710   //TODO: aPos
 711 end;
 712
 713 procedure TBasicSound.SetID(ID: DWORD);
 714 begin
 715   FreeSound();
 716   FID := ID;
 717   if ID <> NO_SOUND_ID then
 718   begin
 719     FMusic := e_SoundsArray[ID].isMusic;
 720   end;
 721   FChanNum := -1;
 722 end;
 723
 724 function TBasicSound.IsPlaying(): Boolean;
 725 var
 726   chan: Integer;
 727 begin
 728   Result := False;
 729   if e_isSound(FID) then
 730   begin
 731     //e_WriteLog(Format('IsPlaying: FID=%u; FChanNum=%d', [FID, FChanNum]), TMsgType.Warning);
 732     chan := Channel;
 733     if chan < 0 then
 734     begin
 735       //e_WriteLog(Format('IsPlaying: FID=%u; ONA', [FID]), TMsgType.Warning);
 736       Exit;
 737     end;
 738     //Result := (Mix_Playing(chan) > 0)
 739     //e_WriteLog(Format('IsPlaying: FID=%u; TAN', [FID]), TMsgType.Warning);
 740     Result := True;
 741   end
 742   else if e_isMusic(FID) then
 743   begin
 744     Result := (Mix_PlayingMusic() > 0);
 745   end;
 746 end;
 747
 748 procedure TBasicSound.Stop();
 749 var
 750   chan: Integer;
 751 begin
 752   if e_isSound(FID) then
 753   begin
 754     chan := Channel;
 755     if chan >= 0 then
 756     begin
 757       //GetPosition();
 758       Mix_HaltChannel(chan);
 759     end;
 760   end
 761   else if e_isMusic(FID) then
 762   begin
 763     Mix_HaltMusic();
 764   end;
 765   FChanNum := -1;
 766 end;
 767
 768 function TBasicSound.IsPaused(): Boolean;
 769 var
 770   chan: Integer;
 771 begin
 772   Result := False;
 773   if e_isSound(FID) then
 774   begin
 775     chan := Channel;
 776     if chan < 0 then Exit;
 777     Result := (Mix_Paused(chan) > 0);
 778   end
 779   else if e_isMusic(FID) then
 780   begin
 781     Result := (Mix_PausedMusic() > 0);
 782   end;
 783 end;
 784
 785 procedure TBasicSound.Pause(Enable: Boolean);
 786 var
 787   chan: Integer;
 788   pl: Boolean;
 789 begin
 790   Enable := not Enable; // fuckin' double negation
 791   if e_isSound(FID) then
 792   begin
 793     chan := Channel;
 794     if chan < 0 then Exit;
 795     pl := not (Mix_Paused(chan) > 0);
 796     if pl <> Enable then
 797     begin
 798       if Enable then Mix_Resume(chan) else Mix_Pause(chan);
 799     end;
 800   end
 801   else if e_isMusic(FID) then
 802   begin
 803     pl := not (Mix_PausedMusic() > 0);
 804     if pl <> Enable then
 805     begin
 806       if Enable then Mix_ResumeMusic() else Mix_PauseMusic();
 807     end;
 808   end;
 809   {
 810   if Enable then
 811   begin
 812     res := FMOD_Channel_GetPosition(FChanNum, FPosition, FMOD_TIMEUNIT_MS);
 813     if res <> FMOD_OK then
 814     begin
 815     end;
 816   end;
 817   }
 818 end;
 819
 820 function TBasicSound.GetVolume(): Single;
 821 var
 822   chan: Integer;
 823 begin
 824   Result := 0.0;
 825   if e_isSound(FID) then
 826   begin
 827     chan := Channel;
 828     if chan < 0 then Exit;
 829     Result := (ChanSIds[chan].oldvol+0.0)/(MIX_MAX_VOLUME+0.0);
 830   end
 831   else if e_isMusic(FID) then
 832   begin
 833     Result := (MusVolume+0.0)/(MIX_MAX_VOLUME+0.0);
 834   end;
 835 end;
 836
 837 procedure TBasicSound.SetVolume(Volume: Single);
 838 var
 839   chan: Integer;
 840 begin
 841   if e_isSound(FID) then
 842   begin
 843     chan := Channel;
 844     if chan < 0 then Exit;
 845     //e_WriteLog(Format('SetVolume: chan=%d; Volume=%f', [chan, Volume]), TMsgType.Warning);
 846     e_chanSetVol(chan, Volume);
 847   end
 848   else if e_isMusic(FID) then
 849   begin
 850     //e_WriteLog(Format('SetVolume: chan=MUSIC; Volume=%f', [Volume]), TMsgType.Warning);
 851     e_chanSetVol(N_MUSCHAN, Volume);
 852   end;
 853 end;
 854
 855 function TBasicSound.GetPan(): Single;
 856 var
 857   chan: Integer;
 858 begin
 859   Result := 1.0;
 860   if e_isSound(FID) then
 861   begin
 862     chan := Channel;
 863     if chan < 0 then Exit;
 864     Result := ChanSIds[chan].pan;
 865   end;
 866 end;
 867
 868 procedure TBasicSound.SetPan(Pan: Single);
 869 var
 870   chan: Integer;
 871 begin
 872   if e_isSound(FID) then
 873   begin
 874     chan := Channel;
 875     if chan < 0 then Exit;
 876     e_chanSetPan(chan, Pan);
 877   end;
 878 end;
 879
 880 function TBasicSound.IsMuted(): Boolean;
 881 var
 882   chan: Integer;
 883 begin
 884   Result := False;
 885   if e_isSound(FID) then
 886   begin
 887     chan := Channel;
 888     if chan < 0 then Exit;
 889     Result := ChanSIds[chan].muted;
 890   end
 891   else if e_isMusic(FID) then
 892   begin
 893     Result := SoundMuted;
 894   end;
 895 end;
 896
 897 procedure TBasicSound.Mute(Enable: Boolean);
 898 var
 899   chan: Integer;
 900 begin
 901   if e_isSound(FID) then
 902   begin
 903     chan := Channel;
 904     if chan < 0 then Exit;
 905     if ChanSIds[chan].muted <> Enable then
 906     begin
 907       //e_WriteLog(Format('muting sound for channel %d', [cnan]), TMsgType.Warning);
 908       ChanSIds[chan].muted := Enable;
 909       if ChanSIds[chan].muted then Mix_Volume(chan, 0) else Mix_Volume(chan, ChanSIds[chan].oldvol);
 910     end;
 911   end
 912   else if e_isMusic(FID) then
 913   begin
 914     if Enable then Mix_VolumeMusic(0) else Mix_VolumeMusic(MusVolume);
 915   end;
 916 end;
 917
 918 //TODO
 919 function TBasicSound.GetPosition(): DWORD;
 920 begin
 921   Result := 0;
 922 {
 923   if FChanNum < 0 then Exit;
 924   res := FMOD_Channel_GetPosition(FChanNum, FPosition, FMOD_TIMEUNIT_MS);
 925   if res <> FMOD_OK then
 926   begin
 927     Exit;
 928   end;
 929   Result := FPosition;
 930 }
 931 end;
 932
 933 //TODO
 934 procedure TBasicSound.SetPosition(aPos: DWORD);
 935 begin
 936   FPosition := aPos;
 937 {
 938   if FChanNum < 0 then Exit;
 939   res := FMOD_Channel_SetPosition(FChanNum, FPosition, FMOD_TIMEUNIT_MS);
 940   if res <> FMOD_OK then
 941   begin
 942   end;
 943 }
 944 end;
 945
 946 //TODO
 947 procedure TBasicSound.SetPriority(priority: Integer);
 948 begin
 949 {
 950   if (FChanNum <> nil) and (FPriority <> priority) and
 951      (priority >= 0) and (priority <= 256) then
 952   begin
 953     FPriority := priority;
 954     res := FMOD_Channel_SetPriority(FChanNum, priority);
 955     if res <> FMOD_OK then
 956     begin
 957     end;
 958   end;
 959 }
 960 end;
 961
 962 end.