#include <string>

#include "AudioPlayer.h"
#include "Allocator.h"
#include "FrameTableInc.h"
#include "Indoor.h"
#include "LayingItem.h"
#include "Party.h"
#include "Actor.h"
#include "Game.h"
#include "DecorationList.h"
#include "Time.h"
#include "OSInfo.h"
#include "Math.h"
#include "MapInfo.h"
#include "Log.h"

#include "Bink_Smacker.h"

#include "mm7_data.h"



PCMWAVEFORMAT pcmWaveFormat;

int Aureal3D_SplashScreen;
int Aureal3D_SplashAudio;
int uFindSound_BinSearch_ResultID; // weak
int uLastLoadedSoundID; // weak
int sLastTrackLengthMS;
Sound pSounds[3000];
AudioPlayer *pAudioPlayer;
SoundList *pSoundList;


stru339_spell_sound stru_A750F8[4];
stru339_spell_sound stru_AA1058[4];



unsigned __int8 uSoundVolumeMultiplier = 4;
unsigned __int8 uVoicesVolumeMultiplier = 4;
unsigned __int8 uMusicVolimeMultiplier = 4;
int bWalkSound; // idb

float pSoundVolumeLevels[10] = 
{
  0.0,
  0.10999999940395,
  0.21999999880791,
  0.33000001311302,
  0.43999999761581,
  0.55000001192093,
  0.66000002622604,
  0.76999998092651,
  0.87999999523163,
  0.99000000953674
}; // idb




void ReleaseSoundData(void *_this);




//----- (004A9953) --------------------------------------------------------
void SoundList::Initialize()
{
  SoundList *pSoundList; // esi@1
  signed int v2; // edi@2
  SoundDesc *pSoundDesc; // eax@5
  void *pSoundData; // ebx@7
  unsigned int uSoundSize; // eax@7
  char *pSoundBytes; // ebx@7
  AILFILETYPE pType; // eax@7
  int v8; // eax@8
  char pSoundName[120]; // [sp+4h] [bp-A4h]@4
  AILSOUNDINFO pInfo; // [sp+7Ch] [bp-2Ch]@10
  int v12; // [sp+A0h] [bp-8h]@12
  int a2; // [sp+A4h] [bp-4h]@1

  pSoundList = this;
  a2 = 1;
  if ( (signed int)this->uNumSounds > 1 )
  {
    v2 = 1;
    //while ( 1 )
	do
    {
	  sprintf(pSoundName, "%s", pSounds[v2].pSoundName);
	 // pSoundList->pSounds[v2].pSoundData[0] = ::LoadSound(pSoundName, (SoundData *)0xFFFFFFFF, pSounds[v2].uSoundID); Ritor1: it's error - result: no sound
	  pSoundDesc = &pSoundList->pSounds[v2];
      if ( pSoundList->pSounds[v2].eType != SOUND_DESC_SYSTEM || (sprintf(pSoundName, "%s", pSounds[v2].pSoundName),
            pSoundList->pSounds[v2].pSoundData[0] = ::LoadSound(pSoundName, (SoundData *)0xFFFFFFFF, pSounds[v2].uSoundID),
            !pAudioPlayer->b3DSoundInitialized)
        || (pSoundDesc = &pSoundList->pSounds[v2], !(pSoundDesc->uFlags & 2))
        || !pSoundDesc->pSoundData[0] ) // ����� �����������
        goto LABEL_17;
      pSoundData = pSoundDesc->pSoundData[0];
      uSoundSize = *(int *)pSoundData;
      pSoundBytes = (char *)pSoundData + 4;
      pType = AIL_file_type(pSoundBytes, uSoundSize);
      if ( !pType )
        //goto LABEL_15;
	  {
		LOBYTE(pSoundList->pSounds[v2].bDecompressed) = 0;
		goto LABEL_16;
	  }
      v8 = pType - 1;
      if ( v8 )
	  {
        /*break;
      pSoundList->pSounds[v2].p3DSound = pSoundList->pSounds[v2].pSoundData[0];
LABEL_16:
      pSoundList->_4A9DCD(a2, 1);
LABEL_17:
      ++a2;
      ++v2;
      if ( a2 >= (signed int)pSoundList->uNumSounds )
        return;
    }*/
      if ( v8 == 1 )
      {
        if ( AIL_WAV_info(pSoundBytes, &pInfo) && pInfo.uChannels != 2 )
        {
          if ( !AIL_decompress_ADPCM(&pInfo, &pSoundList->pSounds[v2].p3DSound, &v12) )
          {
            pSoundList->pSounds[v2].p3DSound = 0;
            LOBYTE(pSoundList->pSounds[v2].bDecompressed) = 1;
          }
        }
        goto LABEL_16;
      }
//LABEL_15:
      LOBYTE(pSoundList->pSounds[v2].bDecompressed) = 0;
      goto LABEL_16;
    }
	pSoundList->pSounds[v2].p3DSound = pSoundList->pSounds[v2].pSoundData[0];
LABEL_16:
    pSoundList->_4A9DCD(a2, 1);
LABEL_17:
      ++a2;
      ++v2;
	}
    while ( a2 < (signed int)pSoundList->uNumSounds );
  }
}

//----- (004A9A67) --------------------------------------------------------
__int16 SoundList::LoadSound(int a1, unsigned int a3)
{
  AILSOUNDINFO v24; // [sp+84h] [bp-28h]@23

  if (bNoSound || !uNumSounds)
    return 0;

  uint       uSoundIdx = 0;
  SoundDesc *pSound = nullptr;
  for (uint i = 1; i < uNumSounds; ++i)
    if (pSounds[i].uSoundID == a1)
    {
      uSoundIdx = i;
      pSound = &pSounds[i];
      break;
    }
  if (!pSound)
    return 0;

  if (pSound->uFlags & 2 && pSound->p3DSound ||
      ~pSound->uFlags & 2 && pSound->pSoundData[0])
    return uSoundIdx;

  if (!pSound->pSoundData[0])
    pSound->pSoundData[0] = ::LoadSound(pSound->pSoundName, (SoundData *)0xFFFFFFFF, pSound->uSoundID);

  if (!pSound->pSoundData[0])
    return 0;

  if (a3)
    pSound->uFlags |= 1u;

  if (!pAudioPlayer->b3DSoundInitialized)
    return uSoundIdx;

  if (~pSound->uFlags & 2 || !pSound->pSoundData[0])
    return uSoundIdx;


  auto pSoundData = pSound->pSoundData[0];
  switch (AIL_file_type((void *)pSoundData->pData, pSoundData->uDataSize))
  {
    default:
    case AILFILETYPE_UNKNOWN:
      pSound->bDecompressed = false;
      return 0;

    case AILFILETYPE_PCM_WAV:
      pSound->p3DSound = pSound->pSoundData[0];
      return uSoundIdx;

    case AILFILETYPE_ADPCM_WAV:
      if (AIL_WAV_info((void *)pSoundData->pData, &v24) && v24.uChannels != 2)
      {
        if (!AIL_decompress_ADPCM(&v24, &pSound->p3DSound, &a1) )
        {
          pSound->p3DSound = nullptr;
          pSound->bDecompressed = true;
          _4A9DCD(uSoundIdx, 0);
        }
      }
      return uSoundIdx;
  };
}

//----- (004A9BBD) --------------------------------------------------------
int SoundList::LoadSound(unsigned int a2, LPVOID lpBuffer, int uBufferSizeLeft, int *pOutSoundSize, int a6)
{
  //SoundList *v6; // edi@1
  signed int v7; // esi@1
  //unsigned __int8 v8; // zf@1
  //unsigned __int8 v9; // sf@1
  SoundDesc *v10; // eax@3
  SoundDesc *v11; // ecx@3
  int v12; // ebx@7
  int result; // eax@13
  SoundHeader *v14; // esi@16
  DWORD *v15; // edi@16
  int v16; // ebx@16
  unsigned int v17; // eax@18
  void *v18; // ebx@19
  std::string v19; // [sp-18h] [bp-38h]@22
  const char *v20; // [sp-8h] [bp-28h]@22
  int v21; // [sp-4h] [bp-24h]@22
  //SoundList *v22; // [sp+Ch] [bp-14h]@1
  SoundDesc *Args; // [sp+10h] [bp-10h]@3
  unsigned int v24; // [sp+14h] [bp-Ch]@2
  int v25; // [sp+18h] [bp-8h]@2
  int v26; // [sp+1Ch] [bp-4h]@1

  //v6 = this;
  v7 = 0;
  //v22 = this;
  //v8 = this->uNumSounds == 0;
  //v9 = (this->uNumSounds & 0x80000000u) != 0;
  v26 = 0;
  if (!uNumSounds)
    return 0;


    v24 = 0;
    v25 = 44;
    while ( 1 )
    {
      v10 = pSounds;
      v11 = &v10[v24 / 0x78];
      Args = &v10[v24 / 0x78];
      if ( a2 == v10[v24 / 0x78].uSoundID )
      {
        if ( a6 == v7 && *(int *)&v10->pSoundName[v25] != v7 )
          return v26;
        if ( (signed int)pAudioPlayer->uNumSoundHeaders > v7 )
          break;
      }
LABEL_12:
      ++v26;
      v25 += 120;
      v24 += 120;
      if ( v26 >= (signed int)uNumSounds )
        return 0;
    }
    v12 = 0;
    while ( _strcmpi(pAudioPlayer->pSoundHeaders[v12].pSoundName, v11->pSoundName) )
    {
      ++v7;
      ++v12;
      if ( v7 >= (signed int)pAudioPlayer->uNumSoundHeaders )
      {
        v7 = 0;
        goto LABEL_12;
      }
      v11 = Args;
    }
    v14 = &pAudioPlayer->pSoundHeaders[v7];
    v15 = (DWORD *)&v14->uDecompressedSize;
    a2 = v14->uDecompressedSize;
    v16 = a2;
    if ( (signed int)a2 > uBufferSizeLeft )
      Abortf("Sound %s is size %i bytes, sound buffer size is %i bytes", Args, a2, uBufferSizeLeft);
    SetFilePointer(pAudioPlayer->hAudioSnd, v14->uFileOffset, 0, 0);
    v17 = v14->uCompressedSize;
    if ( (signed int)v17 >= (signed int)*v15 )
    {
      if ( v17 == *v15 )
      {
        ReadFile(pAudioPlayer->hAudioSnd, lpBuffer, *v15, (LPDWORD)&Args, 0);
      }
      else
      {
      MessageBoxW(nullptr, L"Can't load sound file!", L"E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\Sound.cpp:666", 0);
      }
    }
    else
    {
      v18 = malloc(v14->uCompressedSize);
      ReadFile(pAudioPlayer->hAudioSnd, v18, v14->uCompressedSize, (LPDWORD)&Args, 0);
      zlib::MemUnzip(lpBuffer, &v14->uDecompressedSize, v18, v14->uCompressedSize);
      free(v18);
      v16 = a2;
    }
    result = v26;
    pSounds->pSoundData[a6 + 30 * v26] = (SoundData *)lpBuffer;
    *pOutSoundSize = v16;

  return result;
}

//----- (004A9D3E) --------------------------------------------------------
SoundDesc *SoundList::Release()
{
  SoundList *v1; // esi@1
  signed int v2; // ebx@1
  int v3; // edi@2
  SoundDesc *result; // eax@3
  void *v5; // ecx@3

  v1 = this;
  v2 = 0;
  if ( (signed int)this->uNumSounds > 0 )
  {
    v3 = 0;
    do
    {
      result = v1->pSounds;
      v5 = result[v3].pSoundData[0];
      if ( v5 )
      {
        ReleaseSoundData(v5);
        v1->pSounds[v3].pSoundData[0] = 0;
        result = (SoundDesc *)((char *)&v1->pSounds[v3] + 40);
        *(int *)&result->pSoundName[0] &= 0xFFFFFFFEu;
      }
      ++v2;
      ++v3;
    }
    while ( v2 < (signed int)v1->uNumSounds );
  }
  return result;
}

//----- (004A9D79) --------------------------------------------------------
void SoundList::_4A9D79(int a2)
{
  SoundList *v2; // esi@1
  int v3; // edi@1
  signed int i; // ebx@1
  SoundDesc *v5; // eax@2
  SOUND_DESC_TYPE v6; // ecx@2
  void *v7; // eax@5

  v2 = this;
  v3 = 0;
  for ( i = 0; i < (signed int)v2->uNumSounds; ++v3 )
  {
    v5 = &v2->pSounds[v3];
    v6 = v5->eType;
    if ( v6 != SOUND_DESC_SYSTEM && (a2 || v6 != SOUND_DESC_LOCK) )
    {
      v7 = v5->pSoundData[0];
      if ( v7 )
      {
        ReleaseSoundData(v7);
        v2->pSounds[v3].pSoundData[0] = 0;
      }
      v2->pSounds[v3].uFlags &= 0xFFFFFFFEu;
    }
    ++i;
  }
}

//----- (004A9DCD) --------------------------------------------------------
void SoundList::_4A9DCD(unsigned int uSoundID, char a3)
{
  unsigned int v3; // esi@1
  //SoundList *v4; // edi@1
  SoundDesc *v5; // eax@1
  void *v6; // ecx@8

  v3 = uSoundID;
  //v4 = this;
  v5 = &this->pSounds[uSoundID];
  if ( v5->eType != SOUND_DESC_SYSTEM )
  {
    if ( v5->uFlags & 2 && v5->p3DSound && a3 )
    {
      if ( LOBYTE(v5->bDecompressed) )
        AIL_mem_free_lock(v5->p3DSound);
      pSounds[v3].p3DSound = 0;
      pSounds[v3].uFlags &= 0xFFFFFFFEu;
    }
    v6 = pSounds[v3].pSoundData[0];
    if ( v6 )
    {
      ReleaseSoundData(v6);
      pSounds[v3].pSoundData[0] = 0;
      pSounds[v3].uFlags &= 0xFFFFFFFEu;
    }
  }
}


//----- (004A9E3D) --------------------------------------------------------
void SoundList::ToFile()
{
  SoundList *v1; // esi@1
  FILE *v2; // eax@1
  FILE *v3; // edi@1

  v1 = this;
  v2 = fopen("data\\dsounds.bin", "wb");
  v3 = v2;
  if ( !v2 )
    Abortf("Unable to save dsounds.bin!");
  fwrite(v1, 4u, 1u, v2);
  fwrite(v1->pSounds, 0x78u, v1->uNumSounds, v3);
  fclose(v3);
}

//----- (004A9E89) --------------------------------------------------------
void *SoundList::FromFile(void *pSerialized)
{
  uNumSounds = *(int *)pSerialized;
  pSounds = (SoundDesc *)pAllocator->AllocNamedChunk(pSounds, 120 * uNumSounds, "Snd Des.");
  return memcpy(pSounds, (char *)pSerialized + 4, 120 * uNumSounds);
}

//----- (004A9ED0) --------------------------------------------------------
int SoundList::FromFileTxt(const char *Args)
{
  SoundList *v2; // ebx@1
  __int32 v3; // edi@1
  FILE *v4; // eax@1
  unsigned int v5; // esi@3
  void *v6; // eax@9
  FILE *v7; // ST0C_4@11
  char *i; // eax@11
  int v9; // eax@14
  const char *v10; // ST0C_4@14
  int v11; // eax@18
  SoundDesc *v12; // ecx@18
  char v13; // zf@18
  unsigned int v14; // eax@18
  int v15; // eax@23
  char Buf; // [sp+Ch] [bp-2F0h]@3
  FrameTableTxtLine v18; // [sp+200h] [bp-FCh]@4
  FrameTableTxtLine v19; // [sp+27Ch] [bp-80h]@4
  FILE *File; // [sp+2F8h] [bp-4h]@1
  unsigned int Argsa; // [sp+304h] [bp+8h]@3

  v2 = this;
  pAllocator->FreeChunk(this->pSounds);
  v3 = 0;
  v2->pSounds = 0;
  v2->uNumSounds = 0;
  v4 = fopen(Args, "r");
  File = v4;
  if ( !v4 )
    Abortf("SoundListClass::load - Unable to open file: %s.");
  v5 = 0;
  Argsa = 0;
  if ( fgets(&Buf, 490, v4) )
  {
    do
    {
      *strchr(&Buf, 10) = 0;
      memcpy(&v19, texture_frame_table_txt_parser(&Buf, &v18), sizeof(v19));
      if ( v19.field_0 && *v19.pProperties[0] != 47 )
        ++Argsa;
    }
    while ( fgets(&Buf, 490, File) );
    v5 = Argsa;
    v3 = 0;
  }
  v2->uNumSounds = v5;
  v6 = pAllocator->AllocNamedChunk(v2->pSounds, 120 * v5, "Snd Des.");
  v2->pSounds = (SoundDesc *)v6;
  if ( v6 == (void *)v3 )
    Abortf("SoundListClass::load - Out of Memory!");
  memset(v6, v3, 120 * v2->uNumSounds);
  v7 = File;
  v2->uNumSounds = v3;
  fseek(v7, v3, v3);
  for ( i = fgets(&Buf, 490, File); i; i = fgets(&Buf, 490, File) )
  {
    *strchr(&Buf, 10) = 0;
    memcpy(&v19, texture_frame_table_txt_parser(&Buf, &v18), sizeof(v19));
    if ( v19.field_0 && *v19.pProperties[0] != 47 )
    {
      sprintf(v2->pSounds[v2->uNumSounds].pSoundName, "%s", v19.pProperties[0]);
      v9 = atoi(v19.pProperties[1]);
      v10 = v19.pProperties[2];
      v2->pSounds[v2->uNumSounds].uSoundID = v9;
      if ( _strcmpi(v10, "system") )
      {
        if ( _strcmpi(v19.pProperties[2], "swap") )
        {
          v11 = _strcmpi(v19.pProperties[2], "lock");
          v12 = v2->pSounds;
          v13 = v11 == 0;
          v14 = v2->uNumSounds;
          if ( v13 )
            v12[v14].eType = SOUND_DESC_LOCK;
          else
            v12[v14].eType = SOUND_DESC_LEVEL;
        }
        else
        {
          v2->pSounds[v2->uNumSounds].eType = SOUND_DESC_SWAP;
        }
      }
      else
      {
        v2->pSounds[v2->uNumSounds].eType = SOUND_DESC_SYSTEM;
      }
      if ( v19.field_0 >= 4 && !_strcmpi(v19.pProperties[3], "3D") )
      {
        v15 = (int)&v2->pSounds[v2->uNumSounds].uFlags;
        *(int *)v15 |= 2u;
      }
      ++v2->uNumSounds;
    }
  }
  fclose(File);
  return 1;
}

//----- (004AA13F) --------------------------------------------------------
void AudioPlayer::PlayMusicTrack(MusicID eTrack)
{
  if (!bNoSound && bPlayerReady && hAILRedbook && uMusicVolimeMultiplier)
  {
    AIL_redbook_stop(hAILRedbook);
    AIL_redbook_set_volume(hAILRedbook, (signed)(pSoundVolumeLevels[uMusicVolimeMultiplier] * 64.0));
    AIL_redbook_track_info(hAILRedbook, eTrack, &uCurrentMusicTrackStartMS, &uCurrentMusicTrackEndMS);
    AIL_redbook_play(hAILRedbook, uCurrentMusicTrackStartMS + 1, uCurrentMusicTrackEndMS);
    uCurrentMusicTrackLength = ((uCurrentMusicTrackEndMS - uCurrentMusicTrackStartMS) * 128) / 1000;
  }
}


//----- (004AA1F3) --------------------------------------------------------
void AudioPlayer::SetMusicVolume(int vol)
{
  if (bPlayerReady)
  {
    if (hAILRedbook)
      AIL_redbook_set_volume(hAILRedbook, vol);
  }
}

//----- (004AA214) --------------------------------------------------------
void AudioPlayer::SetMasterVolume(unsigned int uVolume)
{
  AudioPlayer *v2; // esi@1
  _DIG_DRIVER *hDrv; // eax@2

  v2 = this;
  if ( this->bPlayerReady )
  {
    hDrv = this->hDigDriver;
    this->uMasterVolume = uVolume;
    if ( hDrv )
      AIL_set_digital_master_volume(hDrv, uVolume);
    if ( v2->b3DSoundInitialized )
      v2->s3DSoundVolume = (signed __int64)((double)(signed int)uVolume * 0.5);
  }
}
// 4D8304: using guessed type int __stdcall AIL_set_digital_master_volume(int, int);

//----- (004AA258) --------------------------------------------------------
void AudioPlayer::_4AA258(int a2)
{
  AudioPlayer *v2; // esi@1
  int v3; // edi@4
  AudioPlayer_3DSample *v4; // ebx@5
  int v5; // ebx@11
  MixerChannel *v6; // edi@12

  v2 = this;
  if ( this->bPlayerReady )
  {
    if ( this->b3DSoundInitialized && a2 && (v3 = 0, this->uNum3DSamples > 0) )
    {
      v4 = this->p3DSamples;
      while ( v4->field_4 != a2 || AIL_3D_sample_status(v4->hSample) != 4 )
      {
        ++v3;
        ++v4;
        if ( v3 >= v2->uNum3DSamples )
          goto LABEL_9;
      }
      AIL_end_3D_sample(v2->p3DSamples[v3].hSample);
    }
    else
    {
LABEL_9:
      if ( v2->hDigDriver )
      {
        if ( a2 )
        {
          v5 = 0;
          if ( v2->uMixerChannels > 0 )
          {
            v6 = v2->pMixerChannels;
            do
            {
              if ( v6->dword_000004 == a2 )
              {
                if ( AIL_sample_status(v6->hSample) == 4 )
                {
                  AIL_end_sample(v6->hSample);
                  _4ABE55(v6);
                }
              }
              ++v5;
              ++v6;
            }
            while ( v5 < v2->uMixerChannels );
          }
        }
      }
    }
  }
}
// 4D82F4: using guessed type int __stdcall AIL_3D_sample_status(int);
// 4D82F8: using guessed type int __stdcall AIL_sample_status(int);
// 4D82FC: using guessed type int __stdcall AIL_end_sample(int);
// 4D8300: using guessed type int __stdcall AIL_end_3D_sample(int);

//----- (004AA306) --------------------------------------------------------
void AudioPlayer::PlaySound(SoundID eSoundID, signed int a3, unsigned int uNumRepeats, signed int PartyX, signed int PartyY, int a7, unsigned int uVolume, int sPlaybackRate)
{
  //AudioPlayer *pAudioPlayer1; // esi@1
  signed int pNum; // edx@5
  int *pSoundID; // ecx@6
  int v12; // edi@13
  signed int v13; // ecx@17
  signed int v14; // eax@20
  int v15; // eax@24
  signed int v16; // eax@25
  LayingItem *pLayingItem; // eax@28
  signed int v18; // eax@29
  Actor *pActor1; // eax@32
  signed int v20; // ecx@32
  double v21; // st7@32
  signed int v22; // ecx@33
  AudioPlayer_3DSample *pAudioPlayer_3DSample; // esi@53
  AudioPlayer_3DSample *pAudioPlayer_3DSample1; // esi@61
  int v25; // esi@67
  double v26; // st7@68
  int v27; // ST18_4@68
  int v28; // ebx@68
  int v29; // eax@68
  AudioPlayer_3DSample *pAudioPlayer_3DSample2; // esi@69
  int v31; // ST18_4@70
  int v32; // ebx@70
  int v33; // eax@70
  int v34; // eax@70
  char v35; // zf@70
  signed int v36; // ebx@74
  //AudioPlayer *pAudioPlayer2; // edi@79
  AudioPlayer_3DSample *pAudioPlayer_3DSample3; // esi@79
  unsigned int v39; // ebx@80
  int v40; // eax@81
  char *v41; // edi@82
  int v42; // esi@82
  double v43; // st7@91
  LayingItem *pLayingItem2; // eax@92
  Actor *pActor; // eax@93
  signed int v46; // ecx@93
  double v47; // st7@93
  BLVDoor *pBLVDoor; // eax@97
  double v49; // st7@104
  int v50; // ST18_4@104
  int v51; // ebx@104
  int v52; // eax@104
  float v53; // ST0C_4@106
  float v54; // ST04_4@106
  //AudioPlayer *pAudioPlayer3; // edx@106
  SoundDesc *pSoundDesc; // edx@107
  LayingItem *pLayingItem3; // eax@114
  int v58; // edx@115
  int v59; // ecx@115
  Actor *pActor2; // eax@118
  MixerChannel *pMixerChannel; // esi@126
  signed int v62; // esi@133
  //AudioPlayer *pAudioPlayer4; // ebx@133
  MixerChannel *pMixerChannel2; // edi@134
  int v65; // ebx@141
  //AudioPlayer *pAudioPlayer5; // ecx@142
  MixerChannel *pMixerChannel3; // edi@142
  int v68; // eax@143
  MixerChannel *pMixerChannel4; // edi@149
  int v70; // ecx@152
  SoundDesc *pSoundDesc2; // eax@153
  int v72; // edi@156
  MixerChannel *pMixerChannel5; // esi@157
  unsigned int pVolume; // eax@157
  int pPartyX; // ebx@159
  int v76; // ebx@160
  LayingItem *pLayingItem4; // edi@164
  unsigned int pPosY; // edx@166
  unsigned int pPosX; // ecx@166
  int v80; // eax@167
  Actor *pActor3; // edi@168
  BLVDoor *pBLVDoor2; // edi@173
  int v83; // eax@183
  int v84; // eax@183
  _SAMPLE *v85; // ST18_4@186
  unsigned int v86; // [sp+14h] [bp-60h]@84
  int v87; // [sp+14h] [bp-60h]@115
  RenderVertexSoft pRenderVertexSoft; // [sp+24h] [bp-50h]@1
  unsigned int v89; // [sp+54h] [bp-20h]@12
  int v90; // [sp+58h] [bp-1Ch]@68
  float v91; // [sp+5Ch] [bp-18h]@68
  //unsigned int v92; // [sp+60h] [bp-14h]@10
  float v93; // [sp+64h] [bp-10h]@1
  signed int varC; // [sp+68h] [bp-Ch]@68
  AudioPlayer *pAudioPlayer; // [sp+6Ch] [bp-8h]@1
  int v96; // [sp+70h] [bp-4h]@19
  signed int uNumRepeatsb; // [sp+84h] [bp+10h]@93
  float uNumRepeatsa; // [sp+84h] [bp+10h]@104
  float v99; // [sp+8Ch] [bp+18h]@104
  signed int v100; // [sp+90h] [bp+1Ch]@32
  int v101; // [sp+90h] [bp+1Ch]@52
  int v102; // [sp+90h] [bp+1Ch]@60
  int v103; // [sp+90h] [bp+1Ch]@68

  uVolume = 120; //Ritor1:It's temporary
  pAudioPlayer = this;
  v35 = this->bPlayerReady == 0;
  //pAudioPlayer = this;
  pRenderVertexSoft.flt_2C = 0.0;
  LODWORD(v93) = 10000;
  if ( v35 || !uSoundVolumeMultiplier || !this->hDigDriver || !eSoundID )
    return;
 pNum = 0;
  if ( (signed int)pSoundList->uNumSounds <= 0 )
  {
LABEL_9:
    pNum = 0;
  }
  else
  {
    pSoundID = (int *)&pSoundList->pSounds->uSoundID;
    while ( *pSoundID != eSoundID )
    {
      ++pNum;
      pSoundID += 30;
      if ( pNum >= (signed int)pSoundList->uNumSounds )
        goto LABEL_9;
    }
  }
  /* v92 = pNum;//38 
 pNum = 0;
  for ( pSoundID = (int *)&pSoundList->pSounds->uSoundID; *pSoundID != eSoundID; pSoundID += 30)
  {
    ++pNum;
  }*/
  if ( !pNum )
    return;
  if ( !pAudioPlayer->b3DSoundInitialized || (v89 = 120 * pNum, !(pSoundList->pSounds[pNum].uFlags & 2)) )
  {
    //pSoundDesc = (SoundDesc *)7;
    if ( a3 < 0 )
    {
      if ( a3 == -1 )
      {
        varC = 13;
        v96 = 13;
        goto LABEL_133;
      }
      varC = 14;
      v96 = 14;
LABEL_123:
      if ( a3 )
      {
        if ( a3 != -1 )
        {
          LODWORD(v91) = 0;
          if ( pAudioPlayer->uMixerChannels > 0 )
          {
            pMixerChannel = pAudioPlayer->pMixerChannels;
            do
            {
              if ( AIL_sample_status(pMixerChannel->hSample) == 4 && pMixerChannel->dword_000004 == a3
                && AIL_sample_status(pMixerChannel->hSample) == 4 )
              {
                if ( pMixerChannel->uSourceTrackIdx == pNum )
                  return;
                AIL_end_sample(pMixerChannel->hSample);
                _4ABE55(pMixerChannel);
              }
              ++LODWORD(v91);
              ++pMixerChannel;
            }
            while ( SLODWORD(v91) < pAudioPlayer->uMixerChannels );
          }
        }
      }
LABEL_133:
      v62 = varC;
      //pAudioPlayer4 = pAudioPlayer;
      if ( varC <= v96 )
      {
        pMixerChannel2 = &pAudioPlayer->pMixerChannels[varC];
        while ( AIL_sample_status(pMixerChannel2->hSample) != 2 )
        {
          ++v62;
          ++pMixerChannel2;
          if ( v62 > v96 )
            goto LABEL_140;
        }
        AIL_end_sample(pMixerChannel2->hSample);
        if ( pMixerChannel2->uSourceTrackIdx )
          _4ABE55(pMixerChannel2);
      }
LABEL_140:
      if ( v62 != v96 + 1 )//10!=13
      {
LABEL_150:
        if ( LODWORD(v93) == 10000 )
          LODWORD(v93) = pAudioPlayer->uMasterVolume;
        v70 = 0;
        if ( !a7 )
        {
          //pSoundDesc = pSoundList->pSounds;
          pSoundDesc2 = &pSoundList->pSounds[pNum];
          if ( !pSoundDesc2->pSoundData[0] )
          {
            if (pSoundDesc2->eType == SOUND_DESC_SWAP)
              pSoundList->LoadSound(eSoundID, 0);
          }
        }
        v72 = 4 * (a7 + 30 * pNum) + 44;
        if ( !*(int *)&pSoundList->pSounds->pSoundName[v72] )
          return;
        pMixerChannel5 = &pAudioPlayer->pMixerChannels[v62];
        AIL_init_sample(pMixerChannel5->hSample);
        AIL_set_sample_file(pMixerChannel5->hSample, (void *)(*(int *)&pSoundList->pSounds->pSoundName[v72] + 4 * (a7 == 0)), -1);
        pVolume = uVolume;
        if ( !uVolume )
          pVolume = LODWORD(v93);
        AIL_set_sample_volume(pMixerChannel5->hSample, pVolume);
        pPartyX = PartyX;
        if ( PartyX != -1 )
        {
          if ( !PartyX )
            pPartyX = pParty->vPosition.x;
          if ( !PartyY )
            PartyY = pParty->vPosition.y;
          if ( uNumRepeats )
            AIL_set_sample_loop_count(pMixerChannel5->hSample, uNumRepeats - 1);
          v83 = sub_4AB66C(pPartyX, PartyY);
          AIL_set_sample_pan(pMixerChannel5->hSample, v83);
          v84 = GetSoundStrengthByDistanceFromParty(pPartyX, PartyY, pParty->vPosition.z);
          AIL_set_sample_volume(pMixerChannel5->hSample, v84);
          v76 = a3;
          goto LABEL_184;
        }
        v76 = a3;
        if ( (a3 & 7) == OBJECT_BLVDoor)
        {
          if ( uCurrentlyLoadedLevelType != LEVEL_Indoor )
            goto LABEL_184;
          pBLVDoor2 = &pIndoor->pDoors[a3 >> 3];
          if ( !pBLVDoor2->uDoorID )
            return;
          if ( !GetSoundStrengthByDistanceFromParty(*pBLVDoor2->pXOffsets, *pBLVDoor2->pYOffsets, *pBLVDoor2->pZOffsets) )
          {
            AIL_end_sample(pMixerChannel5->hSample);
            pAudioPlayer->AudioPlayer::_4ABE55(pMixerChannel5);
            return;
          }
          pPosY = *pBLVDoor2->pYOffsets;
          pPosX = *pBLVDoor2->pXOffsets;
          //goto LABEL_167;
		  v80 = sub_4AB66C(pPosX, pPosY);
          AIL_set_sample_pan(pMixerChannel5->hSample, v80);
          goto LABEL_184;
        }
        if ( (a3 & 7) == OBJECT_Item)
        {
          pLayingItem4 = &pLayingItems[a3 >> 3];
          if ( !GetSoundStrengthByDistanceFromParty(pLayingItem4->vPosition.x, pLayingItem4->vPosition.y, pLayingItem4->vPosition.z) )
            return;
        }
        else
        {
          if ( (a3 & 7) == OBJECT_Actor)
          {
            pActor3 = &pActors[a3 >> 3];
            if ( !GetSoundStrengthByDistanceFromParty(pActor3->vPosition.x, pActor3->vPosition.y, pActor3->vPosition.z) )
              return;
            pPosY = pActor3->vPosition.y;
            pPosX = pActor3->vPosition.x;
            //goto LABEL_167;
			v80 = sub_4AB66C(pPosX, pPosY);
            AIL_set_sample_pan(pMixerChannel5->hSample, v80);
			goto LABEL_184;
          }
          if ( (a3 & 7) != OBJECT_Decoration)
          {
LABEL_184:
            if ( uNumRepeats )
              AIL_set_sample_loop_count(pMixerChannel5->hSample, uNumRepeats - 1);
            v85 = pMixerChannel5->hSample;
            pMixerChannel5->uSourceTrackIdx = pNum;
            pMixerChannel5->dword_000004 = v76;
            pMixerChannel5->uSourceTrackID = eSoundID;
            AIL_start_sample(v85);
            if ( sPlaybackRate )
              AIL_set_sample_playback_rate(pMixerChannel5->hSample, sPlaybackRate);
            if ( (v76 & 7) == OBJECT_Player)
              AIL_sample_ms_position(pMixerChannel5->hSample, &sLastTrackLengthMS, 0);
            return;
          }
          pLayingItem4 = (LayingItem *)&pLevelDecorations[a3 >> 3];
          if ( !GetSoundStrengthByDistanceFromParty(pLayingItem4->vPosition.x, pLayingItem4->vPosition.y, pLayingItem4->vPosition.z) )
            return;
          AIL_set_sample_loop_count(pMixerChannel5->hSample, uNumRepeats - 1);
        }
        pPosY = pLayingItem4->vPosition.y;
        pPosX = pLayingItem4->vPosition.x;
//LABEL_167:
        v80 = sub_4AB66C(pPosX, pPosY);
        AIL_set_sample_pan(pMixerChannel5->hSample, v80);
        goto LABEL_184;
      }
      v65 = varC;
      v62 = -1;
      v91 = v93;
      if ( varC <= v96 )
      {
        //pAudioPlayer5 = pAudioPlayer;
        pMixerChannel3 = &pAudioPlayer->pMixerChannels[varC];
        do
        {
          v68 = AIL_sample_volume(pMixerChannel3->hSample);
          if ( v68 < SLODWORD(v91) )
          {
            LODWORD(v91) = v68;
            v62 = v65;
          }
          ++v65;
          ++pMixerChannel3;
        }
        while ( v65 <= v96 );
        if ( v62 != -1 )
        {
//LABEL_149:
          //pAudioPlayer4 = pAudioPlayer;
          pMixerChannel4 = &pAudioPlayer->pMixerChannels[v62];
          AIL_end_sample(pMixerChannel4->hSample);
          _4ABE55(pMixerChannel4);
          goto LABEL_150;
        }
        v65 = varC;
      }
      v62 = 13;
      if ( v65 != 13 )
        return;
      //goto LABEL_149;
	  //pAudioPlayer4 = pAudioPlayer;
      pMixerChannel4 = &pAudioPlayer->pMixerChannels[v62];
      AIL_end_sample(pMixerChannel4->hSample);
      _4ABE55(pMixerChannel4);
      goto LABEL_150;
    }
    if ( (a3 & 7) == OBJECT_Item)
    {
      varC = 5;
      v96 = 7;
      pLayingItem3 = &pLayingItems[a3 >> 3];
    }
    else
    {
      if ( (a3 & 7) == OBJECT_Actor)
      {
        *(float *)&varC = 0.0;
        pActor2 = &pActors[a3 >> 3];
        v96 = 3;
        v58 = pActor2->vPosition.y;
        v87 = pActor2->vPosition.z;
        v59 = pActor2->vPosition.x;
LABEL_116:
        LODWORD(v93) = GetSoundStrengthByDistanceFromParty(v59, /*(int)pSoundDesc*/ v58, v87);
        if ( v93 == 0.0 )
          return;
        goto LABEL_123;
      }
      if ( (a3 & 7) != OBJECT_Decoration)
      {
        if ( (a3 & 7) == OBJECT_BModel)
        {
          varC = 8;
          v96 = 9;
        }
        else
        {
          varC = 10;
          v96 = 12;
        }
        goto LABEL_123;
      }
      varC = 4;
      v96 = 4;
      pLayingItem3 = (LayingItem *)&pLevelDecorations[a3 >> 3];
    }
    v87 = pLayingItem3->vPosition.z;
    v58 = pLayingItem3->vPosition.y;
    v59 = pLayingItem3->vPosition.x;
    goto LABEL_116;
  }
  v12 = 13;
  if ( a3 < 0 )
  {
    v15 = pAudioPlayer->uNum3DSamples;
    if ( a3 == -1 )
    {
      if ( v15 < 16 )
        v12 = v15 - 1;
      v96 = v12;
      //goto LABEL_46;
	  pRenderVertexSoft.vWorldPosition.x = (double)pParty->vPosition.x;
      pRenderVertexSoft.vWorldPosition.y = (double)pParty->vPosition.y;
      v21 = (double)pParty->sEyelevel + (double)pParty->vPosition.z;
      goto LABEL_47;
    }
    if ( v15 >= 16 )
      v15 = 14;
    v12 = v15;
    //goto LABEL_45;
	v96 = v15;
    pRenderVertexSoft.vWorldPosition.x = (double)pParty->vPosition.x;
    pRenderVertexSoft.vWorldPosition.y = (double)pParty->vPosition.y;
    v21 = (double)pParty->sEyelevel + (double)pParty->vPosition.z;
    goto LABEL_47;
  }
  if ( (a3 & 7) == OBJECT_Item)
  {
    v22 = pAudioPlayer->uNum3DSamples;
    if ( v22 < 16 )
    {
      v12 = 5 * v22 / 16;
      v96 = 7 * v22 / 16;
    }
    else
    {
      v96 = 7;
      v12 = 5;
    }
    pLayingItem = &pLayingItems[a3 >> 3];
  }
  else
  {
    if ( (a3 & 7) == OBJECT_Actor)
    {
      v18 = pAudioPlayer->uNum3DSamples;
      v12 = 0;
      if ( v18 < 16 )
        v96 = 3 * v18 / 16;
      else
        v96 = 3;
      pActor1 = &pActors[a3 >> 3];
      v20 = pActor1->vPosition.y;
      pRenderVertexSoft.vWorldPosition.x = (double)pActor1->vPosition.x;
      v100 = pActor1->vPosition.z;
      pRenderVertexSoft.vWorldPosition.y = (double)v20;
      v21 = (double)v100;
      goto LABEL_47;
    }
    if ( (a3 & 7) != OBJECT_Decoration)
    {
      v13 = pAudioPlayer->uNum3DSamples;
      if ( (a3 & 7) == OBJECT_BModel)
      {
        if ( v13 >= 16 )
        {
          v96 = 9;
          v12 = 8;
          //goto LABEL_46;
		  pRenderVertexSoft.vWorldPosition.x = (double)pParty->vPosition.x;
          pRenderVertexSoft.vWorldPosition.y = (double)pParty->vPosition.y;
		  v21 = (double)pParty->sEyelevel + (double)pParty->vPosition.z;
		  goto LABEL_47;
        }
        v12 = 8 * v13 / 16;
        v14 = 9 * v13;
      }
      else
      {
        if ( v13 >= 16 )
        {
          v96 = 12;
          v12 = 10;
//LABEL_46:
          pRenderVertexSoft.vWorldPosition.x = (double)pParty->vPosition.x;
          pRenderVertexSoft.vWorldPosition.y = (double)pParty->vPosition.y;
          v21 = (double)pParty->sEyelevel + (double)pParty->vPosition.z;
          goto LABEL_47;
        }
        v12 = 10 * v13 / 16;
        v14 = 12 * v13;
      }
      v15 = v14 / 16;
//LABEL_45:
      v96 = v15;
      //goto LABEL_46;
	  pRenderVertexSoft.vWorldPosition.x = (double)pParty->vPosition.x;
      pRenderVertexSoft.vWorldPosition.y = (double)pParty->vPosition.y;
      v21 = (double)pParty->sEyelevel + (double)pParty->vPosition.z;
      goto LABEL_47;
    }
    v16 = pAudioPlayer->uNum3DSamples;
    if ( v16 < 16 )
    {
      v12 = v16 / 4;
      v96 = v16 / 4;
    }
    else
    {
      v12 = 4;
      v96 = 4;
    }
    pLayingItem = (LayingItem *)&pLevelDecorations[a3 >> 3];
  }
  pRenderVertexSoft.vWorldPosition.x = (double)pLayingItem->vPosition.x;
  pRenderVertexSoft.vWorldPosition.y = (double)pLayingItem->vPosition.y;
  v21 = (double)pLayingItem->vPosition.z;
LABEL_47:
  pRenderVertexSoft.vWorldPosition.z = v21;
  if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
    sub_4AAEA6_transform(&pRenderVertexSoft);
  else
    pGame->pIndoorCameraD3D->ViewTransform(&pRenderVertexSoft, 1);
  if ( a3 )
  {
    if ( a3 != -1 )
    {
      v101 = 0;
      if ( pAudioPlayer->uNum3DSamples > 0 )
      {
        pAudioPlayer_3DSample = pAudioPlayer->p3DSamples;
        do
        {
          if ( AIL_3D_sample_status(pAudioPlayer_3DSample->hSample) == 4 
			  && pAudioPlayer_3DSample->field_4 == a3 && AIL_3D_sample_status(pAudioPlayer_3DSample->hSample) == 4 )
          {
            if ( pAudioPlayer_3DSample->field_8 == pNum )
              return;
            AIL_end_3D_sample(pAudioPlayer_3DSample->hSample);
            pAudioPlayer->_4ABF23(pAudioPlayer_3DSample);
          }
          ++v101;
          ++pAudioPlayer_3DSample;
        }
        while ( v101 < pAudioPlayer->uNum3DSamples );
      }
    }
  }
  v102 = v12;
  if ( v12 <= v96 )
  {
    pAudioPlayer_3DSample1 = &pAudioPlayer->p3DSamples[v12];
    while ( AIL_3D_sample_status(pAudioPlayer_3DSample1->hSample) != 2 )
    {
      ++v102;
      ++pAudioPlayer_3DSample1;
      if ( v102 > v96 )
        goto LABEL_67;
    }
    AIL_end_3D_sample(pAudioPlayer_3DSample1->hSample);
    if ( pAudioPlayer_3DSample1->field_8 )
      pAudioPlayer->_4ABF23(pAudioPlayer_3DSample1);
  }
LABEL_67:
  v25 = v96;
  if ( v102 == v96 + 1 )
  {
    LODWORD(v91) = -1;
    v103 = 0;
    *(float *)&varC = pRenderVertexSoft.vWorldViewPosition.y * -0.012207031;
    v93 = 0.0;
    v26 = pRenderVertexSoft.vWorldViewPosition.x * 0.012207031;
    *(float *)&uVolume = v26;
    v27 = abs((signed __int64)v26);
    v28 = abs((signed __int64)v93);
    v29 = abs((signed __int64)*(float *)&varC);
    v90 = sub_4621DA(v29, v28, v27);
    sPlaybackRate = v12;
    if ( v12 > v25 )
      goto LABEL_192;
    pAudioPlayer_3DSample2 = &pAudioPlayer->p3DSamples[v12];
    do
    {
      AIL_3D_position(pAudioPlayer_3DSample2->hSample, &varC, &v93, (long *)&uVolume);
      v31 = abs((signed __int64)*(float *)&uVolume);
      v32 = abs((signed __int64)v93);
      v33 = abs((signed __int64)*(float *)&varC);
      v34 = sub_4621DA(v33, v32, v31);
      v35 = v103 == v34;
      if ( v103 < v34 )
      {
        v103 = v34;
        v35 = 1;
      }
      if ( v35 && v90 < v103 )
      {
        v36 = sPlaybackRate;
        LODWORD(v91) = sPlaybackRate;
      }
      else
      {
        v36 = LODWORD(v91);
      }
      ++sPlaybackRate;
      ++pAudioPlayer_3DSample2;
    }
    while ( sPlaybackRate <= v96 );
    if ( v36 == -1 )
    {
LABEL_192:
      v36 = 13;
      if ( v12 != 13 )
        return;
    }
    //pAudioPlayer2 = pAudioPlayer;
    pAudioPlayer_3DSample3 = &pAudioPlayer->p3DSamples[v36];
    AIL_end_3D_sample(pAudioPlayer_3DSample3->hSample);
    pAudioPlayer->_4ABF23(pAudioPlayer_3DSample3);
    v102 = v36;
  }
  v39 = v89;
  if ( pSoundList->pSounds[v89 / 0x78].p3DSound || (LOWORD(v40) = pSoundList->LoadSound(eSoundID, 0), v40) )
  {
    v41 = (char *)pAudioPlayer + 16 * v102;
    v42 = (int)(v41 + 20);
    if ( AIL_set_3D_sample_file(*((int *)v41 + 5), *(void **)((char *)&pSoundList->pSounds->p3DSound + v39)) )
    {
      if ( uNumRepeats )
        v86 = uNumRepeats - 1;
      else
        v86 = 1;
      AIL_set_3D_sample_loop_count(*(int *)v42, v86);
      if ( PartyX == -1 )
      {
        if ( (a3 & 7) == OBJECT_BLVDoor)
        {
          if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
          {
			//goto LABEL_103;
            pBLVDoor = &pIndoor->pDoors[a3 >> 3];
            if ( !pBLVDoor->uDoorID )
             return;
            pRenderVertexSoft.vWorldPosition.x = (double)*pBLVDoor->pXOffsets;
            pRenderVertexSoft.vWorldPosition.y = (double)*pBLVDoor->pYOffsets;
            v47 = (double)*pBLVDoor->pZOffsets;
LABEL_101:
            pRenderVertexSoft.vWorldPosition.z = v47;
          //if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
          //{
            sub_4AAEA6_transform(&pRenderVertexSoft);
            //goto LABEL_104;
          //}
		  }
//LABEL_103:
		  if ( uCurrentlyLoadedLevelType != LEVEL_Indoor )
            pGame->pIndoorCameraD3D->ViewTransform(&pRenderVertexSoft, 1);
//LABEL_104:
          AIL_start_3D_sample(*(int *)v42);
          AIL_set_3D_sample_float_distances(*(int **)v42, 100.0, 20.0, 100.0, 20.0);
          AIL_set_3D_sample_volume(*(int **)v42, pAudioPlayer->s3DSoundVolume);
          v99 = pRenderVertexSoft.vWorldViewPosition.y * -0.012207031;
          v49 = pRenderVertexSoft.vWorldViewPosition.x * 0.012207031;
          uNumRepeatsa = v49;
          v50 = abs((signed __int64)v49);
          v51 = abs(0);
          v52 = abs((signed __int64)v99);
          if ( sub_4621DA(v52, v51, v50) <= 100 )
          {
            AIL_set_3D_position((void *)*(int *)v42, LODWORD(v99), 0.0, LODWORD(uNumRepeatsa));
            v53 = -uNumRepeatsa;
            v54 = -v99;
            AIL_set_3D_orientation((void *)*(int *)v42, LODWORD(v54), 0.0, LODWORD(v53), 0.0, 1.0, 0.0);
            //pAudioPlayer3 = pAudioPlayer;
            *((int *)v41 + 6) = a3;
            *((int *)v41 + 7) = pNum;
            *(&pAudioPlayer->bEAXSupported + 4 * (v102 + 2)) = eSoundID;
          }
          else
          {
            AIL_end_3D_sample(*(int **)v42);
            pAudioPlayer->_4ABF23((AudioPlayer_3DSample *)(v41 + 20));
          }
          return;
        }
        if ( (a3 & 7) == OBJECT_Item)
        {
          pLayingItem2 = &pLayingItems[a3 >> 3];
        }
        else
        {
          if ( (a3 & 7) == OBJECT_Actor)
          {
            pActor = &pActors[a3 >> 3];
            v46 = pActor->vPosition.y;
            pRenderVertexSoft.vWorldPosition.x = (double)pActor->vPosition.x;
            uNumRepeatsb = pActor->vPosition.z;
            pRenderVertexSoft.vWorldPosition.y = (double)v46;
            v47 = (double)uNumRepeatsb;
            goto LABEL_101;
          }
          if ( (a3 & 7) != OBJECT_Decoration)
          {
            pRenderVertexSoft.vWorldPosition.x = (double)pParty->vPosition.x;
            v43 = (double)pParty->vPosition.y;
LABEL_100:
            pRenderVertexSoft.vWorldPosition.y = v43;
            v47 = (double)pParty->sEyelevel + (double)pParty->vPosition.z;
            goto LABEL_101;
          }
          pLayingItem2 = (LayingItem *)&pLevelDecorations[a3 >> 3];
        }
        pRenderVertexSoft.vWorldPosition.x = (double)pLayingItem2->vPosition.x;
        pRenderVertexSoft.vWorldPosition.y = (double)pLayingItem2->vPosition.y;
        v47 = (double)pLayingItem2->vPosition.z;
        goto LABEL_101;
      }
      pRenderVertexSoft.vWorldPosition.x = (double)PartyX;
      v43 = (double)PartyY;
      goto LABEL_100;
    }
  }
}

//----- (0040DEA5) --------------------------------------------------------
void __cdecl AudioPlayer::MessWithChannels()
{
  pAudioPlayer->StopChannels(-1, -1);
}



//----- (004AAFCF) --------------------------------------------------------
void AudioPlayer::_4AAFCF()
{
  AudioPlayer *pAudioPlayer; // edi@1
  int v2; // ebx@1
  unsigned __int8 v3; // zf@1
  int *v4; // eax@2
  unsigned __int8 v5; // sf@4
  AudioPlayer_3DSample *v6; // esi@5
  int v7; // ebx@6
  int v8; // ebx@9
  int v9; // ebx@10
  int v10; // ebx@11
  double v11; // st7@13
  LayingItem *v12; // eax@14
  Actor *v13; // eax@15
  signed int v14; // edx@15
  BLVDoor *v15; // eax@19
  double v16; // st7@22
  double v17; // st6@22
  double v18; // st5@23
  double v19; // st4@24
  double v20; // st3@24
  double v21; // st6@28
  double v22; // st7@32
  int v23; // ST1C_4@32
  int v24; // ebx@32
  int v25; // eax@32
  float v26; // ST10_4@34
  float v27; // ST08_4@34
  MixerChannel *v28; // esi@38
  unsigned __int8 v29; // of@43
  MixerChannel *v30; // esi@44
  int v31; // eax@45
  LayingItem *v32; // eax@49
  Actor *v33; // edi@50
  int v34; // eax@50
  unsigned int v35; // edx@51
  unsigned int v36; // ecx@51
  LayingItem *v37; // edi@53
  int v38; // eax@53
  BLVDoor *v39; // edi@56
  int v40; // eax@57
  int v41; // eax@60
  MixerChannel *v42; // edi@65
  int v43; // ebx@68
  LevelDecoration *v44; // esi@68
  int v45; // ST1C_4@68
  int v46; // edi@68
  int v47; // eax@68
  DecorationDesc *v48; // edi@69
  __int16 v49; // ax@69
  __int16 v50; // ax@70
  __int16 v51; // ax@71
  __int16 v52; // ax@73
  signed int v53; // eax@88
  RenderVertexSoft a1; // [sp+24h] [bp-48h]@1
  float v55; // [sp+54h] [bp-18h]@22
  float v56; // [sp+58h] [bp-14h]@22
  int uNumRepeats; // [sp+5Ch] [bp-10h]@15
  float v58; // [sp+60h] [bp-Ch]@23
  int v59; // [sp+64h] [bp-8h]@4
  AudioPlayer *thisa; // [sp+68h] [bp-4h]@1

  pAudioPlayer = this;
  v2 = 0;
  thisa = this;
  v3 = this->bPlayerReady == 0;
  a1.flt_2C = 0.0;
  if ( !v3 )
  {
    v4 = &this->field_2D0_time_left;
    *v4 -= pEventTimer->uTimeElapsed;
    if ( this->field_2D0_time_left <= 0 )
    {
      v3 = this->b3DSoundInitialized == 0;
      *v4 = 32;
      if ( !v3 )
      {
        v3 = this->uNum3DSamples == 0;
        v5 = this->uNum3DSamples < 0;
        v59 = 0;
        if ( !(v5 | v3) )
        {
          v6 = this->p3DSamples;
          while ( 1 )
          {
            v7 = v6->field_4 & 7;
            if ( AIL_3D_sample_status(v6->hSample) == 2 )
            {
              AIL_end_3D_sample(v6->hSample);
              pAudioPlayer->_4ABF23(v6);
            }
            if ( AIL_3D_sample_status(v6->hSample) != 4 )
              goto LABEL_35;
            v8 = v7 - 1;
            if ( v8 )
              break;
            if ( uCurrentlyLoadedLevelType != LEVEL_Indoor )
              goto LABEL_31;
            v15 = &pIndoor->pDoors[v6->field_4 >> 3];
            if ( v15->uDoorID )
            {
              uNumRepeats = *v15->pXOffsets;
              a1.vWorldPosition.x = (double)uNumRepeats;
              uNumRepeats = *v15->pYOffsets;
              a1.vWorldPosition.y = (double)uNumRepeats;
              uNumRepeats = *v15->pZOffsets;
              v11 = (double)uNumRepeats;
              goto LABEL_21;
            }
LABEL_35:
            ++v59;
            ++v6;
            if ( v59 >= pAudioPlayer->uNum3DSamples )
            {
              v2 = 0;
              goto LABEL_37;
            }
          }
          v9 = v8 - 1;
          if ( v9 )
          {
            v10 = v9 - 1;
            if ( !v10 )
            {
              v13 = &pActors[v6->field_4 >> 3];
              uNumRepeats = v13->vPosition.x;
              v14 = v13->vPosition.y;
              a1.vWorldPosition.x = (double)uNumRepeats;
              uNumRepeats = v13->vPosition.z;
              a1.vWorldPosition.y = (double)v14;
              v11 = (double)uNumRepeats;
              goto LABEL_21;
            }
            if ( v10 != 2 )
            {
              a1.vWorldPosition.x = (double)pParty->vPosition.x;
              a1.vWorldPosition.y = (double)pParty->vPosition.y;
              v11 = (double)pParty->sEyelevel + (double)pParty->vPosition.z;
              goto LABEL_21;
            }
            v12 = (LayingItem *)&pLevelDecorations[v6->field_4 >> 3];
          }
          else
          {
            v12 = &pLayingItems[v6->field_4 >> 3];
          }
          a1.vWorldPosition.x = (double)v12->vPosition.x;
          a1.vWorldPosition.y = (double)v12->vPosition.y;
          v11 = (double)v12->vPosition.z;
LABEL_21:
          a1.vWorldPosition.z = v11;
          if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
          {
            v16 = pBLVRenderParams->fCosineNegX;
            v17 = pBLVRenderParams->fSineNegX;
            v55 = pBLVRenderParams->fCosineY;
            v56 = pBLVRenderParams->fSineY;
            if ( pBLVRenderParams->sPartyRotX )
            {
              v58 = a1.vWorldPosition.x - (double)pParty->vPosition.x;
              *(float *)&uNumRepeats = a1.vWorldPosition.y - (double)pParty->vPosition.y;
              v18 = a1.vWorldPosition.z - (double)pParty->vPosition.z;
              if ( pRenderer->pRenderD3D )
              {
                v19 = *(float *)&uNumRepeats * v56 + v58 * v55;
                v20 = v58 * v56 - *(float *)&uNumRepeats * v55;
              }
              else
              {
                v19 = v58 * v55 - *(float *)&uNumRepeats * v56;
                v20 = v58 * v56 + *(float *)&uNumRepeats * v55;
              }
              a1.vWorldViewPosition.x = v19 * v16 - v18 * v17;
              a1.vWorldViewPosition.y = v20;
              a1.vWorldViewPosition.z = v19 * v17 + v18 * v16;
            }
            else
            {
              v58 = a1.vWorldPosition.x - (double)pParty->vPosition.x;
              *(float *)&uNumRepeats = a1.vWorldPosition.y - (double)pParty->vPosition.y;
              if ( pRenderer->pRenderD3D )
              {
                a1.vWorldViewPosition.x = *(float *)&uNumRepeats * v56 + v58 * v55;
                v21 = v58 * v56 - *(float *)&uNumRepeats * v55;
              }
              else
              {
                a1.vWorldViewPosition.x = v58 * v55 - *(float *)&uNumRepeats * v56;
                v21 = v58 * v56 + *(float *)&uNumRepeats * v55;
              }
              a1.vWorldViewPosition.y = v21;
              a1.vWorldViewPosition.z = a1.vWorldPosition.z - (double)pParty->vPosition.z;
            }
          }
          else
          {
LABEL_31:
            pGame->pIndoorCameraD3D->ViewTransform(&a1, 1u);
          }
          v58 = a1.vWorldViewPosition.y * -0.012207031;
          v22 = a1.vWorldViewPosition.x * 0.012207031;
          *(float *)&uNumRepeats = v22;
          v23 = abs((signed __int64)v22);
          v24 = abs(0);
          v25 = abs((signed __int64)v58);
          if ( sub_4621DA(v25, v24, v23) <= 100 )
          {
            AIL_set_3D_position(v6->hSample, LODWORD(v58), 0.0, uNumRepeats);
            v26 = -*(float *)&uNumRepeats;
            v27 = -v58;
            AIL_set_3D_orientation(v6->hSample, LODWORD(v27), 0.0, LODWORD(v26), 0.0, 1.0, 0.0);
          }
          else
          {
            AIL_end_3D_sample(v6->hSample);
            pAudioPlayer->_4ABF23(v6);
          }
          goto LABEL_35;
        }
      }
LABEL_37:
      if ( pAudioPlayer->uMixerChannels > v2 )
      {
        v28 = pAudioPlayer->pMixerChannels;
        do
        {
          if ( AIL_sample_status(v28->hSample) == 2 )
          {
            AIL_end_sample(v28->hSample);
            pAudioPlayer->_4ABE55(v28);
          }
          ++v2;
          ++v28;
        }
        while ( v2 < pAudioPlayer->uMixerChannels );
        v2 = 0;
      }
      //v29 = __OFSUB__(v1->uMixerChannels, v2);
      v29 = pAudioPlayer->uMixerChannels > v2;
      v3 = pAudioPlayer->uMixerChannels == v2;
      v5 = pAudioPlayer->uMixerChannels - v2 < 0;
      v59 = v2;
      if ( !((unsigned __int8)(v5 ^ v29) | v3) )
      {
        v30 = pAudioPlayer->pMixerChannels;
        while ( 1 )
        {
          v31 = v30->dword_000004;
          if ( (v30->dword_000004 & 7) == OBJECT_BLVDoor)
          {
            if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
            {
              v39 = &pIndoor->pDoors[v31 >> 3];
              if ( !v39->uDoorID )
              {
LABEL_61:
                pAudioPlayer = thisa;
                goto LABEL_62;
              }
              v40 = GetSoundStrengthByDistanceFromParty(*v39->pXOffsets, *v39->pYOffsets, *v39->pZOffsets);
              if ( !v40 )
              {
LABEL_58:
                AIL_end_sample(v30->hSample);
                thisa->_4ABE55(v30);
                goto LABEL_61;
              }
              AIL_set_sample_volume(v30->hSample, v40);
              v35 = *v39->pYOffsets;
              v36 = *v39->pXOffsets;
LABEL_60:
              v41 = sub_4AB66C(v36, v35);
              AIL_set_sample_pan(v30->hSample, v41);
              goto LABEL_61;
            }
          }
          else
          {
            if ( (v30->dword_000004 & 7) == OBJECT_Item)
            {
              v32 = &pLayingItems[v31 >> 3];
              goto LABEL_53;
            }
            if ( (v30->dword_000004 & 7) == OBJECT_Actor)
            {
              v33 = &pActors[v31 >> 3];
              v34 = GetSoundStrengthByDistanceFromParty(v33->vPosition.x, v33->vPosition.y, v33->vPosition.z);
              if ( !v34 )
                goto LABEL_58;
              AIL_set_sample_volume(v30->hSample, v34);
              v35 = v33->vPosition.y;
              v36 = v33->vPosition.x;
              goto LABEL_60;
            }
            if ( (v30->dword_000004 & 7) == 5 )
            {
              v32 = (LayingItem *)&pLevelDecorations[v31 >> 3];
LABEL_53:
              v37 = v32;
              v38 = GetSoundStrengthByDistanceFromParty(v32->vPosition.x, v32->vPosition.y, v32->vPosition.z);
              if ( !v38 )
                goto LABEL_58;
              AIL_set_sample_volume(v30->hSample, v38);
              v35 = v37->vPosition.y;
              v36 = v37->vPosition.x;
              goto LABEL_60;
            }
          }
LABEL_62:
          ++v59;
          ++v30;
          if ( v59 >= pAudioPlayer->uMixerChannels )
          {
            v2 = 0;
            break;
          }
        }
      }
      if ( pCurrentScreen != v2 )
      {
        v42 = &pAudioPlayer->pMixerChannels[4];
        if ( AIL_sample_status(v42->hSample) == 4 )
          AIL_end_sample(v42->hSample);
        return;
      }
      v59 = v2;
      if ( _6807E0_num_decorations_with_sounds_6807B8 <= v2 )
        return;
      while ( 1 )
      {
        LODWORD(v56) = 1;
        v43 = 4 * v59 + 6817720;
        v44 = &pLevelDecorations[_6807B8_level_decorations_ids[v59]];
        v45 = abs(v44->vPosition.z - pParty->vPosition.z);
        v46 = abs(v44->vPosition.y - pParty->vPosition.y);
        v47 = abs(v44->vPosition.x - pParty->vPosition.x);
        if ( sub_4621DA(v47, v46, v45) <= 8192 )
          break;
LABEL_89:
        ++v59;
        if ( v59 >= _6807E0_num_decorations_with_sounds_6807B8 )
          return;
      }
      v48 = &pDecorationList->pDecorations[v44->uDecorationDescID];
      v49 = v48->uFlags;
      uNumRepeats = (~(unsigned __int8)v48->uFlags & 0x40) >> 6;
      if ( HIBYTE(v49) & 3 )
      {
        v50 = v44->field_1A;
        v55 = 0.0;
        uNumRepeats = 2;
        if ( v50 )
        {
          v51 = v50 - 32;
          v44->field_1A = v51;
          if ( v51 < 0 )
            v44->field_1A = 0;
        }
      }
      v52 = v48->uFlags;
      if ( !(HIBYTE(v52) & 1) )
      {
        if ( !(HIBYTE(v52) & 2) )
          goto LABEL_84;
        if ( v55 != 0.0 )
          goto LABEL_85;
      }
      v56 = 0.0;
      if ( pParty->uCurrentHour >= 5 && pParty->uCurrentHour < 6
        || pParty->uCurrentHour >= 0x14 && pParty->uCurrentHour < 0x15 )
      {
        if ( !v44->field_1A && rand() % 100 < 100 )
          LODWORD(v56) = 1;
        LODWORD(v55) = 1;
      }
LABEL_84:
      if ( v55 == 0.0 )
      {
LABEL_87:
        if ( v56 != 0.0 )
        {
          v53 = 8 * *(int *)v43;
          LOBYTE(v53) = v53 | 5;
          thisa->PlaySound((SoundID)v48->uSoundID, v53, uNumRepeats, -1, 0, 0, 0, 0);
        }
        goto LABEL_89;
      }
LABEL_85:
      if ( !v44->field_1A )
        v44->field_1A = (rand() % 15 + 1) << 7;
      goto LABEL_87;
    }
  }
}



//----- (004AB66C) --------------------------------------------------------
int __fastcall sub_4AB66C(int a1, int a2)
{
  signed int v2; // eax@1

  v2 = stru_5C6E00->uDoublePiMask & (stru_5C6E00->Atan2(a1 - pParty->vPosition.x, a2 - pParty->vPosition.y)
                                  - stru_5C6E00->uIntegerHalfPi - pParty->sRotationY);
  if ( v2 > (signed int)stru_5C6E00->uIntegerPi )
    v2 = 2 * stru_5C6E00->uIntegerPi - v2;
  return (v2 >> 3) - (v2 >> 10);
}
// 4AB66C: using guessed type int __fastcall sub_4AB66C(int, int);

//----- (004AB6B1) --------------------------------------------------------
int __fastcall GetSoundStrengthByDistanceFromParty(int a1, int a2, int a3)
{
  int v3; // esi@1
  int v4; // edi@1
  int v5; // ST08_4@1
  int v6; // esi@1
  int v7; // eax@1
  int result; // eax@2
  int v9; // [sp+10h] [bp+8h]@1

  v3 = a2;
  v4 = a1;
  v5 = abs(a3 - pParty->vPosition.z);
  v6 = abs(v3 - pParty->vPosition.y);
  v7 = abs(v4 - pParty->vPosition.x);
  v9 = sub_4621DA(v7, v6, v5);
  if ( v9 <= 8192 )
    result = 114 - (unsigned __int64)(signed __int64)((double)v9 * 0.0001220703125 * 100.0);
  else
    result = 0;
  return result;
}



//----- (004AB71F) --------------------------------------------------------
void AudioPlayer::StopChannels(int uStartChannel, int uEndChannel)
{
  //AudioPlayer *v3; // esi@1
  int v4; // ecx@1
  AudioPlayer_3DSample *v5; // edi@4
  int v6; // ebx@12
  MixerChannel *pChannel; // edi@14
  //_STREAM *v8; // esi@23
  int v9; // [sp+4h] [bp-4h]@3

  //v3 = this;
  v4 = 0;
  if ( bPlayerReady )
  {
    if ( b3DSoundInitialized )
    {
      v9 = 0;
      if ( uNum3DSamples > 0 )
      {
        v5 = p3DSamples;//;(char *)&p3DSamples[0].field_8;
        do
        {
          if ( (uStartChannel == -1 || v4 < uStartChannel || v4 > uEndChannel)
			  && v5->field_8
			  && pSoundList->pSounds[v5->field_8].eType != SOUND_DESC_SYSTEM)
          {
			  AIL_end_3D_sample(v5->hSample);
            _4ABF23(v5);
            v5->field_4 = 0;
            v4 = v9;
          }
          ++v4;
          v5 += 16;
          v9 = v4;
        }
        while ( v4 < uNum3DSamples );
      }
    }
    v6 = 0;
    if ( hDigDriver && uMixerChannels > 0 )
    {
      pChannel = pMixerChannels;
      do
      {
        if ( (uStartChannel == -1 || v6 < uStartChannel || v6 > uEndChannel)
          && pSoundList->pSounds[pChannel->uSourceTrackIdx].eType != SOUND_DESC_SYSTEM)
        {
          AIL_end_sample(pChannel->hSample);
          _4ABE55(pChannel);
          pChannel->dword_000004 = 0;
        }
        ++v6;
        ++pChannel;
      }
      while (v6 < uMixerChannels);
    }
    if (hSequence)
      AIL_end_sequence(hSequence);
    //v8 = hStream;
    if (hStream)
      AIL_pause_stream(hStream, 1);
  }
}


//----- (004AB818) --------------------------------------------------------
void AudioPlayer::LoadAudioSnd()
{
  DWORD NumberOfBytesRead; // [sp+Ch] [bp-4h]@3

  hAudioSnd = CreateFileA("Sounds\\Audio.snd", GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0x8000080u, 0);
  if (hAudioSnd == INVALID_HANDLE_VALUE)
  {
    Log::Warning(L"Can't open file: %s", L"Sounds\\Audio.snd");
    return;
  }

  ReadFile(hAudioSnd, &uNumSoundHeaders, 4u, &NumberOfBytesRead, 0);
  pSoundHeaders = nullptr;
  pSoundHeaders = (SoundHeader *)pAllocator->AllocNamedChunk(0, 52 * uNumSoundHeaders + 2, 0);
  ReadFile(hAudioSnd, pSoundHeaders, 52 * uNumSoundHeaders, &NumberOfBytesRead, 0);
}

//----- (004AB8CE) --------------------------------------------------------
void AudioPlayer::Initialize(HWND hWnd)
{
  //AudioPlayer *v2; // esi@1
  int v3; // ebx@1
  //_DIG_DRIVER *v4; // eax@1
  char v5; // dl@5
  _PROVIDER *v6; // eax@9
  HWND v7; // ST00_4@9
  MixerChannel *pChannel; // edi@14
  _SAMPLE *v9; // eax@15
  //_REDBOOK *v10; // eax@19
  //int v11; // ecx@21
  int v12; // [sp+Ch] [bp-Ch]@9
  char *Str1; // [sp+10h] [bp-8h]@6
  int v14; // [sp+14h] [bp-4h]@5

  //v2 = this;
  v3 = 0;
  this->hWindow = hWnd;
  this->hAILRedbook = 0;
  this->hDigDriver = 0;
  this->dword_0002AC = 0;
  this->hSequence = 0;
  this->uMasterVolume = 127;
  this->dword_0002C8 = 64;
  this->dword_0002CC = 2;

  MSS32_DLL_Initialize();
  BINKW32_DLL_Initialize();
  SMACKW32_DLL_Initialize();
  
  AIL_startup();
  if (bCanLoadFromCD)
    hAILRedbook = AIL_redbook_open_drive(cMM7GameCDDriveLetter/*cGameCDDriveLetter*/);
  //else
  //  hAILRedbook = AIL_redbook_open(0);
  //v4 = Audio_GetFirstHardwareDigitalDriver();

  hDigDriver = Audio_GetFirstHardwareDigitalDriver();
  if ( hDigDriver )
    SmackSoundUseMSS(hDigDriver);
  if ( ReadWindowsRegistryInt("Disable3DSound", 0) != 1 && pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT )
  {
    v14 = 0;
    bEAXSupported = 0;
    b3DSoundInitialized = 0;
    ReadWindowsRegistryString("3DSoundProvider", p3DSoundProvider, 128u, "NONE");
    CheckA3DSupport(v5);
    while ( AIL_enumerate_3D_providers(&v14, (HPROVIDER *)&hWnd, &Str1) )
    {
      if ( !strcmp(Str1, p3DSoundProvider) )
      {
        if ( AIL_open_3D_provider((HPROVIDER)hWnd) )
        {
          bEAXSupported = 0;
          b3DSoundInitialized = 0;
          h3DSoundProvider = 0;
        }
        else
        {
          v6 = (_PROVIDER *)hWnd;
          v7 = hWnd;
          b3DSoundInitialized = 1;
          h3DSoundProvider = v6;
          uNum3DSamples = 4;
          AIL_3D_provider_attribute((HPROVIDER)v7, "EAX environment selection", &v12);
          if ( v12 != -1 )
            bEAXSupported = 1;
        }
        pAudioPlayer->_4AC0A2();
        break;
      }
    }
  }
  if ( uMixerChannels > 0 )
  {
    pChannel = pMixerChannels;
    do
    {
      v9 = AIL_allocate_sample_handle(hDigDriver);
      pChannel->hSample = v9;
      if ( !v9 )
        break;
      ++v3;
      ++pChannel;
    }
    while ( v3 < uMixerChannels );
  }
  uMixerChannels = v3;
  if ( bPlayerReady )
    StopChannels(-1, -1);
  //v10 = hAILRedbook;
  bPlayerReady = true;
  if ( hAILRedbook )
  {
    AIL_redbook_stop(hAILRedbook);
    uNumRedbookTracks = AIL_redbook_tracks(hAILRedbook);
  }
  pAudioPlayer->sRedbookVolume = AIL_redbook_volume(hAILRedbook);
  pAudioPlayer->SetMasterVolume(pSoundVolumeLevels[uSoundVolumeMultiplier] * 128.0);
  if ( bPlayerReady && hAILRedbook )
    AIL_redbook_set_volume(hAILRedbook, (unsigned __int64)(pSoundVolumeLevels[uMusicVolimeMultiplier] * 64.0) >> 32);
  LoadAudioSnd();
}

//----- (004ABAF7) --------------------------------------------------------
_DIG_DRIVER *Audio_GetFirstHardwareDigitalDriver(void)
{
  int v0; // ecx@1
  unsigned int v1; // ebp@2
  size_t v2; // eax@4
  signed int v3; // kr14_4@9
  char *v5; // [sp+10h] [bp-Ch]@2
  unsigned int v6; // [sp+14h] [bp-8h]@1
  _DIG_DRIVER *hDrv; // [sp+18h] [bp-4h]@3
  
  static int dword_4F00DC = 22050;
  static int dword_4F00E0 = 16;
  static int dword_4F00E4 = 2;

  AIL_set_preference(15, 0);
  AIL_set_preference(33, 1);
  v0 = dword_4F00DC;
  pAudioPlayer->pDeviceNames[0][0] = 0;
  pAudioPlayer->uNumDevices = 0;
  v6 = 0;

  if ( dword_4F00DC < 11025 )
    return 0;
  v1 = 0;
  v5 = (char *)pAudioPlayer->array_000BF0;
  while ( 1 )
  {
    while ( 1 )
    {
      pcmWaveFormat.wf.wFormatTag = 1;
      pcmWaveFormat.wf.nChannels = dword_4F00E4;
      pcmWaveFormat.wf.nSamplesPerSec = v0;
      pcmWaveFormat.wf.nBlockAlign = dword_4F00E4 * dword_4F00E0 / 8;
      pcmWaveFormat.wBitsPerSample = dword_4F00E0;
      pcmWaveFormat.wf.nAvgBytesPerSec = v0 * dword_4F00E4 * dword_4F00E0 / 8;
      if ( !AIL_waveOutOpen(&hDrv, 0, -1, &pcmWaveFormat.wf) )
        break;
      if ( !AIL_get_preference(15) )
        goto LABEL_8;
      v3 = dword_4F00DC;
      v0 = dword_4F00DC / 2;
      dword_4F00DC /= 2;
      if ( v3 / 2 < 11025 )
      {
        if ( dword_4F00E0 == 8 )
        {
          v0 = 22050;
          dword_4F00E0 = 8;
          dword_4F00DC = 22050;
        }
        goto LABEL_12;
      }
    }
    strcpy(pAudioPlayer->pDeviceNames[v1 / 8], "Device: ");
    v2 = strlen(pAudioPlayer->pDeviceNames[v1 / 8]);
    AIL_digital_configuration(hDrv, (int *)v5, (int *)(v5 + 64), (char *)pAudioPlayer->pDeviceNames + v2 + v1 * 16);
    ++v6;
    v1 += 8;
    v5 += 4;
    pAudioPlayer->uNumDevices = v6;
    if ( AIL_get_preference(15) )
      return hDrv;
    if ( !strstr(pAudioPlayer->pDeviceNames[v1 / 8 - 1], "Emulated") )
      return hDrv;
    AIL_waveOutClose(hDrv);
    AIL_set_preference(15, 1);
LABEL_8:
    AIL_set_preference(15, 1);
    v0 = dword_4F00DC;
LABEL_12:
    if ( v0 < 11025 )
      return 0;
  }
}


//----- (004ABC9B) --------------------------------------------------------
LSTATUS AudioPlayer::CheckA3DSupport(char a2)
{
  LSTATUS result; // eax@1
  DWORD cbData; // [sp+8h] [bp-Ch]@1
  int Data; // [sp+Ch] [bp-8h]@1
  HKEY hKey; // [sp+10h] [bp-4h]@1
  char v6; // [sp+1Ch] [bp+8h]@0

  hKey = 0;
  cbData = 4;
  Data = 0;
  result = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Aureal\\A3D", 0, 0x2001Fu, &hKey);
  if ( !result )
  {
    if ( v6 )
      RegQueryValueExA(hKey, "SplashAudio", 0, 0, (LPBYTE)&Aureal3D_SplashAudio, &cbData);
    else
      Data = Aureal3D_SplashAudio;
    RegSetValueExA(hKey, "SplashAudio", 0, 4u, (const BYTE *)&Data, 4u);
    Data = 0;
    if ( v6 )
      RegQueryValueExA(hKey, "SplashScreen", 0, 0, (LPBYTE)&Aureal3D_SplashScreen, &cbData);
    else
      Data = Aureal3D_SplashScreen;
    RegSetValueExA(hKey, "SplashScreen", 0, 4u, (const BYTE *)&Data, 4u);
    result = RegCloseKey(hKey);
  }
  return result;
}
// 4ABC9B: inconsistent function type and number of purged bytes

//----- (004ABD5B) --------------------------------------------------------
void AudioPlayer::Release() //����������
{
  AudioPlayer *pAudioPlayer; // esi@1
  int v2; // edi@1
  MixerChannel *pMixerChannel; // ebx@3
  char v4; // dl@5
  int v5; // ebx@6
  AudioPlayer_3DSample *p3DSample; // edi@7
  //int v7; // edx@14
  int v8; // ecx@14
  void *v9; // ecx@15

  pAudioPlayer = this;
  v2 = 0;
  if ( this->bPlayerReady )
  {
    CloseHandle(pVideoPlayer->hMagicVid);
    CloseHandle(pVideoPlayer->hMightVid);
    pAudioPlayer->StopChannels(-1, -1);
    if ( pAudioPlayer->uMixerChannels > 0 )
    {
      pMixerChannel = pAudioPlayer->pMixerChannels;
      do
      {
        AIL_release_sample_handle(pMixerChannel->hSample);
        ++v2;
        ++pMixerChannel;
      }
      while ( v2 < pAudioPlayer->uMixerChannels );
    }
    if ( ReadWindowsRegistryInt("Disable3DSound", 0) != 1 )
    {
      v5 = 0;
      pAudioPlayer->CheckA3DSupport(0);// pAudioPlayer->CheckA3DSupport(v4);
      if ( pAudioPlayer->uNum3DSamples > 0 )
      {
        p3DSample = pAudioPlayer->p3DSamples;
        do
        {
          if ( p3DSample->hSample )
          {
            AIL_release_3D_sample_handle(p3DSample->hSample);
            p3DSample->hSample = 0;
          }
          ++v5;
          ++p3DSample;
        }
        while ( v5 < pAudioPlayer->uNum3DSamples );
      }
      if ( pAudioPlayer->h3DSoundProvider )
      {
        AIL_close_3D_provider(pAudioPlayer->h3DSoundProvider);
        pAudioPlayer->h3DSoundProvider = 0;
      }
    }
    v8 = (int)&pAudioPlayer->hAILRedbook;
    if ( pAudioPlayer->hAILRedbook )
    {
      AIL_redbook_stop(pAudioPlayer->hAILRedbook);
      AIL_redbook_set_volume((HREDBOOK)v8, pAudioPlayer->sRedbookVolume);
      AIL_redbook_close(pAudioPlayer->hAILRedbook);
    }
    AIL_shutdown();
    pSoundList->Release();
    v9 = *(void **)&pAudioPlayer->field_C78[0];
    if ( v9 )
      ReleaseSoundData(v9);
    CloseHandle(pAudioPlayer->hAudioSnd);
  }
}

//----- (004ABE55) --------------------------------------------------------
void AudioPlayer::_4ABE55(MixerChannel *pChannel)
{
  int v2; // ebx@1
  //AudioPlayer *v3; // esi@1
  SoundDesc *v4; // eax@2
  unsigned __int8 v5; // zf@5
  unsigned __int8 v6; // sf@5
  char *v7; // edi@6
  int v8; // eax@8
  int v9; // ST04_4@8
  int v10; // ecx@12
  int v11; // edi@13
  int v12; // eax@13
  unsigned __int8 v13; // of@13
  int v14[16]; // [sp+Ch] [bp-48h]@8
  int v15; // [sp+4Ch] [bp-8h]@5
  int v16; // [sp+50h] [bp-4h]@5

  v2 = 0;
  //v3 = this;
  if ( pSoundList->pSounds )
  {
    v4 = &pSoundList->pSounds[pChannel->uSourceTrackIdx];
    if ( v4->eType == SOUND_DESC_SWAP)
    {
      if ( v4->pSoundData[0] && !(v4->uFlags & 1) )
      {
        v5 = this->uMixerChannels == 0;
        v6 = this->uMixerChannels < 0;
        v15 = 0;
        v16 = 0;
        if ( v6 | v5 )
          goto LABEL_16;
        v7 = (char *)this->pMixerChannels;
        do
        {
          if ( pChannel->uSourceTrackID == *((int *)v7 + 3) )
          {
            v8 = v16;
            v9 = *(int *)v7;
            ++v16;
            v14[v8] = v2;
            if ( AIL_sample_status((HSAMPLE)v9) == 4 )
              ++v15;
          }
          ++v2;
          v7 += 16;
        }
        while ( v2 < uMixerChannels );
        if ( !v15 )
        {
LABEL_16:
          pSoundList->_4A9DCD(pChannel->uSourceTrackIdx, 1);
          v10 = 0;
          if ( v16 > 0 )
          {
            do
            {
              v11 = v14[v10];
              v12 = 16 * (v14[v10++] + 47);
              pMixerChannels[v11].uSourceTrackID = 0;
              v13 = __OFSUB__(v10, v16);
              v6 = v10 - v16 < 0;
              *(unsigned int *)((char *)&bEAXSupported + v12) = 0;
            }
            while ( v6 ^ v13 );
          }
        }
      }
    }
  }
}
// 4D82F8: using guessed type int __stdcall AIL_sample_status(int);
// 4ABE55: using guessed type int var_48[16];



//----- (004AAEA6) --------------------------------------------------------
int __fastcall sub_4AAEA6_transform(RenderVertexSoft *a1)
{
  double v1; // st7@1
  double v2; // st6@1
  int result; // eax@1
  double v4; // st5@2
  double v5; // st4@3
  double v6; // st3@3
  double v7; // st7@6
  double v8; // st6@7
  float v9; // [sp+0h] [bp-10h]@1
  float v10; // [sp+4h] [bp-Ch]@1
  float v11; // [sp+8h] [bp-8h]@2
  float v12; // [sp+8h] [bp-8h]@6
  float v13; // [sp+Ch] [bp-4h]@2
  float v14; // [sp+Ch] [bp-4h]@6

  v1 = pBLVRenderParams->fCosineNegX;
  v2 = pBLVRenderParams->fSineNegX;
  v9 = pBLVRenderParams->fCosineY;
  v10 = pBLVRenderParams->fSineY;
  result = 0;
  if ( pBLVRenderParams->sPartyRotX )
  {
    v13 = a1->vWorldPosition.x - (double)pParty->vPosition.x;
    v11 = a1->vWorldPosition.y - (double)pParty->vPosition.y;
    v4 = a1->vWorldPosition.z - (double)pParty->vPosition.z;
    if ( pRenderer->pRenderD3D )
    {
      v5 = v11 * pBLVRenderParams->fSineY + v13 * pBLVRenderParams->fCosineY;
      v6 = v13 * pBLVRenderParams->fSineY - v11 * pBLVRenderParams->fCosineY;
    }
    else
    {
      v5 = v13 * pBLVRenderParams->fCosineY - v11 * pBLVRenderParams->fSineY;
      v6 = v13 * pBLVRenderParams->fSineY + v11 * pBLVRenderParams->fCosineY;
    }
    a1->vWorldViewPosition.x = v5 * v1 - v4 * v2;
    a1->vWorldViewPosition.y = v6;
    a1->vWorldViewPosition.z = v5 * v2 + v4 * v1;
  }
  else
  {
    v14 = a1->vWorldPosition.x - (double)pParty->vPosition.x;
    v12 = a1->vWorldPosition.y - (double)pParty->vPosition.y;
    v7 = a1->vWorldPosition.z - (double)pParty->vPosition.z;
    if ( pRenderer->pRenderD3D )
    {
      a1->vWorldViewPosition.x = v12 * pBLVRenderParams->fSineY + v14 * pBLVRenderParams->fCosineY;
      v8 = v14 * v10 - v12 * v9;
    }
    else
    {
      a1->vWorldViewPosition.x = v14 * pBLVRenderParams->fCosineY - v12 * pBLVRenderParams->fSineY;
      v8 = v14 * v10 + v12 * v9;
    }
    a1->vWorldViewPosition.y = v8;
    a1->vWorldViewPosition.z = v7;
  }
  return result;
}




//----- (004ABF23) --------------------------------------------------------
void AudioPlayer::_4ABF23(AudioPlayer_3DSample *a2)
{
  int v2; // ebx@1
  //AudioPlayer *v3; // esi@1
  SoundDesc *v4; // eax@2
  unsigned __int8 v5; // zf@5
  unsigned __int8 v6; // sf@5
  char *v7; // edi@6
  int v8; // eax@8
  int v9; // ST04_4@8
  int v10; // ecx@12
  int v11; // eax@13
  unsigned __int8 v12; // of@13
  int v13[16]; // [sp+Ch] [bp-48h]@8
  int v14; // [sp+4Ch] [bp-8h]@5
  int v15; // [sp+50h] [bp-4h]@5

  v2 = 0;
  //v3 = this;
  if ( pSoundList->pSounds )
  {
    v4 = &pSoundList->pSounds[a2->field_8];
    if ( v4->eType == SOUND_DESC_SWAP)
    {
      if ( v4->p3DSound && !(v4->uFlags & 1) )
      {
        v5 = this->uNum3DSamples == 0;
        v6 = this->uNum3DSamples < 0;
        v14 = 0;
        v15 = 0;
        if ( v6 | v5 )
          goto LABEL_16;
        v7 = (char *)this->p3DSamples;
        do
        {
          if ( a2->field_C == *((int *)v7 + 3) )
          {
            v8 = v15;
            v9 = *(int *)v7;
            ++v15;
            v13[v8] = v2;
            if ( AIL_3D_sample_status((void *)v9) == 4 )
              ++v14;
          }
          ++v2;
          v7 += 16;
        }
        while ( v2 < uNum3DSamples );
        if ( !v14 )
        {
LABEL_16:
          pSoundList->_4A9DCD(a2->field_8, 1);
          v10 = 0;
          if ( v15 > 0 )
          {
            do
            {
              v11 = v13[v10++];
              *(&bEAXSupported + 4 * (v11 + 2)) = 0;
              v12 = __OFSUB__(v10, v15);
              v6 = v10 - v15 < 0;
              p3DSamples[v11].field_8 = 0;
            }
            while ( v6 ^ v12 );
          }
        }
      }
    }
  }
}
// 4D82F4: using guessed type int __stdcall AIL_3D_sample_status(int);
// 4ABF23: using guessed type int var_48[16];

//----- (004ABFDB) --------------------------------------------------------
void __cdecl PlayLevelMusic()
{
  unsigned int v0; // eax@1

  v0 = pMapStats->GetMapInfo(pCurrentMapName);
  if ( v0 )
    pAudioPlayer->PlayMusicTrack((MusicID)pMapStats->pInfos[v0].uRedbookTrackID);
}

//----- (004AC004) --------------------------------------------------------
void AudioPlayer::SetEAXPreferences()
{
  AudioPlayer *v1; // edi@1
  _PROVIDER *v2; // ST00_4@2
  _PROVIDER *v3; // ST00_4@2
  float v4; // [sp+4h] [bp-4h]@2

  v1 = this;
  if ( this->bEAXSupported )
  {
    v2 = this->h3DSoundProvider;
    v4 = 0.0;
    AIL_set_3D_provider_preference(v2, "EAX effect volume", (int *)&v4);
    v3 = v1->h3DSoundProvider;
    v4 = 1.0;
    AIL_set_3D_provider_preference(v3, "EAX damping", (int *)&v4);
  }
}
// 4D82DC: using guessed type int __stdcall AIL_set_3D_provider_preference(int, int, int);

//----- (004AC041) --------------------------------------------------------
void AudioPlayer::SetMapEAX()
{
  AudioPlayer *v1; // esi@1
  unsigned int v2; // eax@1
  int v3; // [sp+4h] [bp-4h]@3

  v1 = this;
  v2 = pMapStats->GetMapInfo(pCurrentMapName);
  if ( v1->b3DSoundInitialized && v1->bEAXSupported )
  {
    v3 = pMapStats->pInfos[v2].uEAXEnv;
    if ( (unsigned int)v3 >= 0x1A )
    {
      SetEAXPreferences();
      v1->field_214 = -1;
    }
    else
    {
      AIL_set_3D_provider_preference(v1->h3DSoundProvider, "EAX environment selection", &v3);
      v1->field_214 = v3;
    }
  }
}
// 4D82DC: using guessed type int __stdcall AIL_set_3D_provider_preference(int, int, int);

//----- (004AC0A2) --------------------------------------------------------
int AudioPlayer::_4AC0A2()
{
  AudioPlayer *v1; // esi@1
  unsigned int v2; // eax@1
  char v3; // zf@1
  int v4; // ebx@1
  int *v5; // edi@2
  int v6; // eax@4
  AudioPlayer_3DSample *v8; // ebx@7
  void *v9; // eax@8
  int v10; // ebx@14
  unsigned int v11; // eax@14
  int v12; // [sp+1Ch] [bp-8h]@1
  int v13; // [sp+20h] [bp-4h]@6

  v1 = this;
  v2 = pMapStats->GetMapInfo(pCurrentMapName);
  v3 = v1->b3DSoundInitialized == 0;
  v4 = v2;
  v12 = v2;
  if ( !v3 )
  {
    v5 = &v1->uNum3DSamples;
    AIL_3D_provider_attribute(v1->h3DSoundProvider, "Maximum supported samples", &v1->uNum3DSamples);
    if ( v1->uNum3DSamples > 32 )
      *v5 = 32;
    v6 = *v5;
    if ( !*v5 )
    {
      v1->b3DSoundInitialized = 0;
      return -1;
    }
    v13 = 0;
    if ( v6 > 0 )
    {
      v8 = v1->p3DSamples;
      while ( 1 )
      {
        v9 = (void *)AIL_allocate_3D_sample_handle(v1->h3DSoundProvider);
        v8->hSample = v9;
        if ( !v9 )
          break;
        AIL_set_3D_sample_float_distances(v9, 4096.0, 256.0, 4096.0, 256.0);
        AIL_set_3D_sample_volume(v8->hSample, v1->s3DSoundVolume);
        ++v13;
        ++v8;
        if ( v13 >= *v5 )
          goto LABEL_12;
      }
      *v5 = v13;
LABEL_12:
      v4 = v12;
    }
    if ( v1->bEAXSupported )
    {
      v10 = v4;
      v11 = pMapStats->pInfos[v10].uEAXEnv;
      v12 = pMapStats->pInfos[v10].uEAXEnv;
      if ( v11 >= 0x1A )
      {
        pAudioPlayer->SetEAXPreferences();
        v1->field_214 = -1;
      }
      else
      {
        AIL_set_3D_provider_preference(v1->h3DSoundProvider, "EAX environment selection", &v12);
        v1->field_214 = v12;
      }
    }
  }
  return 1;
}


//----- (004A96BE) --------------------------------------------------------
void ReleaseSoundData(void *_this)
{
  int pID; // esi@1
  char *v2; // eax@1

  pID = 0;
  v2 = (char *)&pSounds[0].pSoundData;
  while ( *(void **)v2 != _this )
  {
    v2 += 128;
    ++pID;
	if ( v2 > (void *)&pSounds[2999].pSoundData)//(signed int)&pAudioPlayer->p3DSamples[6].field_8 )
      return;
  }
  pAllocator->FreeChunk(_this);
  memset(&pSounds[pID], 0, 0x80u);
}

//----- (004A96FF) --------------------------------------------------------
SoundHeader *__fastcall FindSound_BinSearch(unsigned int uStart, unsigned int uEnd, const char *pName)
{
  unsigned int v3; // ebx@1
  unsigned int v4; // esi@1
  SoundHeader *result; // eax@2
  signed int v6; // ebx@11
  int v7; // edi@13
  unsigned int v8; // esi@14
  unsigned int v9; // esi@20
  unsigned int v10; // [sp+Ch] [bp-4h]@1

  v3 = uEnd;
  v10 = uEnd;
  v4 = uStart;
  while ( 1 )
  {
    v6 = v3 - v4;
    result = &pAudioPlayer->pSoundHeaders[v6 / 2 + v4];
    if ( !result )
      return result;
    result = (SoundHeader *)_strcmpi(pName, result->pSoundName);
    if ( !result )
      uFindSound_BinSearch_ResultID = v6 / 2 + v4;
    if ( v4 == v10 )
      goto LABEL_17;
    if ( (signed int)result < 0 )
      break;
    if ( v6 <= 4 )
    {
      v7 = v4;
      if ( (signed int)v4 < (signed int)v10 )
      {
        v9 = v4;
        do
        {
          result = (SoundHeader *)_strcmpi(pName, pAudioPlayer->pSoundHeaders[v9].pSoundName);
          if ( !result )
            goto LABEL_24;
          ++v7;
          ++v9;
        }
        while ( v7 < (signed int)v10 );
      }
LABEL_17:
      uFindSound_BinSearch_ResultID = -1;
      return result;
    }
    v4 += v6 / 2;
LABEL_10:
    v3 = v10;
  }
  if ( v6 > 4 )
  {
    v10 = v6 / 2 + v4;
    goto LABEL_10;
  }
  v7 = v4;
  if ( (signed int)v4 >= (signed int)v10 )
    goto LABEL_17;
  v8 = v4;
  while ( 1 )
  {
    result = (SoundHeader *)_strcmpi(pName, pAudioPlayer->pSoundHeaders[v8].pSoundName);
    if ( !result )
      break;
    ++v7;
    ++v8;
    if ( v7 >= (signed int)v10 )
      goto LABEL_17;
  }
LABEL_24:
  uFindSound_BinSearch_ResultID = v7;
  return result;
}
// F1B4C8: using guessed type int uFindSound_BinSearch_ResultID;

//----- (004A97C6) --------------------------------------------------------
SoundData *LoadSound(const char *pSoundName, SoundData *pOutBuff, unsigned int uID)
{
  SoundData *v3; // edi@1
  int v4; // ecx@1
  //Sound *v5; // eax@1
  SoundHeader *v6; // esi@5
  unsigned int *pDecompressedSize; // ebx@5
  unsigned int v8; // eax@5
  unsigned int v9; // eax@7
  SoundData *result; // eax@9
  int v11; // esi@15
  int v12; // eax@15
  char *v13; // ecx@16
  int v14; // eax@19
  std::string v15; // [sp-18h] [bp-34h]@12
  const char *v16; // [sp-8h] [bp-24h]@12
  int v17; // [sp-4h] [bp-20h]@12
  char v18; // [sp+Ch] [bp-10h]@12
  int v19; // [sp+10h] [bp-Ch]@5
  DWORD NumberOfBytesRead; // [sp+14h] [bp-8h]@8
  const char *pSoundName_; // [sp+18h] [bp-4h]@1

  pSoundName_ = pSoundName;
  v3 = pOutBuff;
  v4 = 0;
  for (uint i = 0; i < 3000; ++i)
    if (pSounds[i].uID == uID)
      return pSounds[i].pSoundData;

  FindSound_BinSearch(0, pAudioPlayer->uNumSoundHeaders, pSoundName_);
  if ( uFindSound_BinSearch_ResultID == -1 )
  {
    result = 0;
    return result;
  }
  v6 = &pAudioPlayer->pSoundHeaders[uFindSound_BinSearch_ResultID];
  pDecompressedSize = &v6->uDecompressedSize;
  v8 = v6->uDecompressedSize;
  v19 = v6->uDecompressedSize;
  if ( v3 == (SoundData *)-1 )
    v3 = (SoundData *)pAllocator->AllocNamedChunk(0, v8 + 4, pSoundName_);
  SetFilePointer(pAudioPlayer->hAudioSnd, v6->uFileOffset, 0, 0);
  v9 = *pDecompressedSize;
  if ( (signed int)v6->uCompressedSize >= (signed int)*pDecompressedSize )
  {
    v6->uCompressedSize = v9;
    if ( v9 )
    {
      ReadFile(pAudioPlayer->hAudioSnd, (char *)v3 + 4, v9, &NumberOfBytesRead, 0);
    }
    else
    {
      MessageBoxW(nullptr, L"Can't load sound file!", L"E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\Sound.cpp:448", 0);
    }
  }
  else
  {
    uID = (unsigned int)malloc(v6->uCompressedSize);
    ReadFile(pAudioPlayer->hAudioSnd, (LPVOID)uID, v6->uCompressedSize, &NumberOfBytesRead, 0);
    zlib::MemUnzip((char *)v3 + 4, &v6->uDecompressedSize, (const void *)uID, v6->uCompressedSize);
    free((void *)uID);
  }
  if ( v3 )
  {
    v11 = v19;
    v12 = 0;
    *(int *)v3 = v19;
    uLastLoadedSoundID = 0;
    if ( pSounds[0].pSoundData )
    {
      v13 = (char *)&pSounds[0].pSoundData;
      do
      {
        v13 += 128;
        ++v12;
      }
      while ( *(int *)v13 );
      uLastLoadedSoundID = v12;
    }
    v16 = pSounds[v12].SoundName;
    strcpy((char *)v16, pSoundName_);
    v14 = uLastLoadedSoundID++ << 7;
    pSoundList->uTotalLoadedSoundSize += v11;
    pSounds[uLastLoadedSoundID].pSoundData = v3;
    result = v3;
  }
  else
  {
    result = 0;
  }
  return result;
}