create tremded branch

39 files changed, 27077 insertions, 4 deletions

diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt
new file mode 100644
index 0000000..c10fd9c
--- /dev/null
+++ b/src/client/CMakeLists.txt
@@ -0,0 +1,209 @@
+#
+##  .o88b. db      d888888b d88888b d8b   db d888888b
+## d8P  Y8 88        `88'   88'     888o  88 `~~88~~'
+## 8P      88         88    88ooooo 88V8o 88    88
+## 8b      88         88    88~~~~~ 88 V8o88    88
+## Y8b  d8 88booo.   .88.   88.     88  V888    88
+##  `Y88P' Y88888P Y888888P Y88888P VP   V8P    YP
+#
+
+find_package(CURL)
+find_package(OpenGL)
+find_package(OpenAL)
+include(${CMAKE_SOURCE_DIR}/cmake/SDL2.cmake)
+
+add_definitions(
+    -DUSE_LOCAL_HEADERS
+    -DUSE_RESTCLIENT
+    -DUSE_CODEC_OPUS
+    -DUSE_OPENAL
+    -DUSE_OPENAL_DLOPEN
+    -DUSE_INTERNAL_JPEG
+    -DUSE_RENDERER_DLOPEN
+    -DNDEBUG
+    -DPRODUCT_VERSION="1.3.0 alpha"
+    ${SDL2_DEFINES}
+    )
+
+set(PARENT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/..)
+set(EXTERNAL_DIR ${CMAKE_SOURCE_DIR}/external)
+if(APPLE)
+set(APPLE_SOURCES ${PARENT_DIR}/sys/sys_osx.mm)
+endif(APPLE)
+
+add_executable(
+    tremulous
+    #
+    ${PARENT_DIR}/asm/snapvector.c
+    #
+    cl_avi.cpp
+    cl_cgame.cpp
+    cl_cin.cpp
+    cl_console.cpp
+    cl_curl.cpp
+    cl_input.cpp
+    cl_keys.cpp
+    cl_main.cpp
+    cl_net_chan.cpp
+    cl_parse.cpp
+    cl_rest.cpp
+    cl_scrn.cpp
+    cl_ui.cpp
+    cl_updates.cpp
+    libmumblelink.cpp
+    qal.cpp
+    snd_adpcm.cpp
+    snd_codec.cpp
+    snd_codec_ogg.cpp
+    snd_codec_opus.cpp
+    snd_codec_wav.cpp
+    snd_dma.cpp
+    snd_main.cpp
+    snd_mem.cpp
+    snd_mix.cpp
+    snd_openal.cpp
+    snd_wavelet.cpp
+    #
+    ${PARENT_DIR}/qcommon/cm_load.cpp
+    ${PARENT_DIR}/qcommon/cm_patch.cpp
+    ${PARENT_DIR}/qcommon/cm_polylib.cpp
+    ${PARENT_DIR}/qcommon/cm_test.cpp
+    ${PARENT_DIR}/qcommon/cm_trace.cpp
+    ${PARENT_DIR}/qcommon/cmd.cpp
+    ${PARENT_DIR}/qcommon/common.cpp
+    ${PARENT_DIR}/qcommon/crypto.cpp
+    ${PARENT_DIR}/qcommon/cvar.cpp
+    ${PARENT_DIR}/qcommon/cvar.h
+    ${PARENT_DIR}/qcommon/files.cpp
+    ${PARENT_DIR}/qcommon/files.h
+    ${PARENT_DIR}/qcommon/huffman.cpp
+    ${PARENT_DIR}/qcommon/huffman.h
+    ${PARENT_DIR}/qcommon/ioapi.cpp
+    ${PARENT_DIR}/qcommon/md4.cpp
+    ${PARENT_DIR}/qcommon/md5.cpp
+    ${PARENT_DIR}/qcommon/msg.cpp
+    ${PARENT_DIR}/qcommon/msg.h
+    ${PARENT_DIR}/qcommon/net_chan.cpp
+    ${PARENT_DIR}/qcommon/net_ip.cpp
+    ${PARENT_DIR}/qcommon/net.h
+    ${PARENT_DIR}/qcommon/parse.cpp
+    ${PARENT_DIR}/qcommon/puff.cpp
+    ${PARENT_DIR}/qcommon/q_shared.c
+    ${PARENT_DIR}/qcommon/q3_lauxlib.cpp
+    ${PARENT_DIR}/qcommon/q_math.c
+    ${PARENT_DIR}/qcommon/unzip.cpp
+    ${PARENT_DIR}/qcommon/vm.cpp
+    ${PARENT_DIR}/qcommon/vm_interpreted.cpp
+    ${PARENT_DIR}/qcommon/vm_x86.cpp
+    #
+    ${PARENT_DIR}/sdl/sdl_input.cpp
+    ${PARENT_DIR}/sdl/sdl_snd.cpp
+    #
+    ${PARENT_DIR}/server/sv_ccmds.cpp
+    ${PARENT_DIR}/server/sv_client.cpp
+    ${PARENT_DIR}/server/sv_game.cpp
+    ${PARENT_DIR}/server/sv_init.cpp
+    ${PARENT_DIR}/server/sv_main.cpp
+    ${PARENT_DIR}/server/sv_net_chan.cpp
+    ${PARENT_DIR}/server/sv_snapshot.cpp
+    ${PARENT_DIR}/server/sv_world.cpp
+    #
+    ${PARENT_DIR}/sys/con_log.cpp
+    ${PARENT_DIR}/sys/con_tty.cpp
+    ${PARENT_DIR}/sys/sys_main.cpp
+    ${PARENT_DIR}/sys/sys_unix.cpp
+    ${PARENT_DIR}/sys/sys_shared.h
+    ${APPLE_SOURCES}
+
+    ${EXTERNAL_DIR}/semver/src/lib/semantic_version_v1.cpp
+    ${EXTERNAL_DIR}/semver/src/lib/semantic_version_v2.cpp
+    )
+
+if(APPLE)
+ # FIXME Prefixed with "lua" to prevent cmake from doing "-l-framework Cocoa"
+ set(FRAMEWORKS "-framework Cocoa -framework Security -framework OpenAL -framework IOKit")
+else(APPLE)
+ if(UNIX)
+  set(SYSLIBS dl rt)
+ endif(UNIX)
+endif(APPLE)
+
+if(NOT USE_RENDERER_DLOPEN)
+  if(USE_OPENGL1)
+  set(RENDERER_LIBRARY renderergl1)
+  endif(USE_OPENGL1)
+  set(RENDERER_LIBRARY renderergl2)
+endif(NOT USE_RENDERER_DLOPEN)
+
+target_link_libraries(
+    tremulous
+    #
+    lua
+    nettle
+    zlib
+    ogg
+    opus
+    opusfile
+    #
+    script_api
+    restclient
+    #
+    ${FRAMEWORKS}
+    ${CURL_LIBRARIES}
+    ${SDL2_LIBRARIES}
+    ${OPENGL_LIBRARIES}
+    ${OPENAL_LIBRARY}
+    ${SYSLIBS}
+    )
+
+include_directories(
+    ${PARENT_DIR}
+    ${PARENT_DIR}/qcommon
+    ${EXTERNAL_DIR}/zlib
+    ${EXTERNAL_DIR}/restclient
+    ${EXTERNAL_DIR}/rapidjson
+    ${EXTERNAL_DIR}/SDL2/include
+    ${EXTERNAL_DIR}/jpeg-8c
+    ${EXTERNAL_DIR}/libogg-1.3.2/include
+    ${EXTERNAL_DIR}/lua-5.3.3/include
+    ${EXTERNAL_DIR}/sol
+    ${EXTERNAL_DIR}/nettle-3.3
+    ${EXTERNAL_DIR}/opus-1.1.4/include
+    ${EXTERNAL_DIR}/opusfile-0.8/include
+    ${EXTERNAL_DIR}/restclient
+    ${EXTERNAL_DIR}/semver/src/include
+    ${SDL2_INCLUDE_DIRS}
+    ${OPENAL_INCLUDE_DIR}
+    )
+
+# TODO: Turn this into a macro 
+if (USE_INTERNAL_SDL2)
+add_custom_command(
+    TARGET tremulous
+    POST_BUILD COMMAND ${CMAKE_COMMAND}
+    ARGS -E copy ${CMAKE_SOURCE_DIR}/external/SDL2/libs/Darwin/libSDL2-2.0.0.dylib ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/libSDL2-2.0.0.dylib
+    )
+endif(USE_INTERNAL_SDL2)
+
+if (USE_RENDERER_DLOPEN)
+    add_custom_command(
+        TARGET tremulous
+        POST_BUILD COMMAND ${CMAKE_COMMAND}
+        ARGS -E copy ${CMAKE_BINARY_DIR}/src/renderergl1/librenderergl1${CMAKE_SHARED_LIBRARY_SUFFIX} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/renderer_opengl1${CMAKE_SHARED_LIBRARY_SUFFIX}
+        )
+
+    add_custom_command(
+        TARGET tremulous
+        POST_BUILD COMMAND ${CMAKE_COMMAND}
+        ARGS -E copy ${CMAKE_BINARY_DIR}/src/renderergl2/librenderergl2${CMAKE_SHARED_LIBRARY_SUFFIX} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/renderer_opengl2${CMAKE_SHARED_LIBRARY_SUFFIX}
+        )
+endif(USE_RENDERER_DLOPEN)
+
+add_dependencies(
+    tremulous
+    ui
+    game
+    cgame
+    renderergl1
+    renderergl2
+    )
diff --git a/src/client/cl_avi.cpp b/src/client/cl_avi.cpp
new file mode 100644
index 0000000..d533e60
--- /dev/null
+++ b/src/client/cl_avi.cpp
@@ -0,0 +1,664 @@
+/*
+===========================================================================
+Copyright (C) 2005-2009 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include "client.h"
+#include "snd_local.h"
+
+#define INDEX_FILE_EXTENSION ".index.dat"
+
+#define MAX_RIFF_CHUNKS 16
+
+typedef struct audioFormat_s
+{
+  int rate;
+  int format;
+  int channels;
+  int bits;
+
+  int sampleSize;
+  int totalBytes;
+} audioFormat_t;
+
+typedef struct aviFileData_s
+{
+  bool          fileOpen;
+  fileHandle_t  f;
+  char          fileName[ MAX_QPATH ];
+  int           fileSize;
+  int           moviOffset;
+  int           moviSize;
+
+  fileHandle_t  idxF;
+  int           numIndices;
+
+  int           frameRate;
+  int           framePeriod;
+  int           width, height;
+  int           numVideoFrames;
+  int           maxRecordSize;
+  bool          motionJpeg;
+
+  bool          audio;
+  audioFormat_t a;
+  int           numAudioFrames;
+
+  int           chunkStack[ MAX_RIFF_CHUNKS ];
+  int           chunkStackTop;
+
+  byte          *cBuffer, *eBuffer;
+} aviFileData_t;
+
+static aviFileData_t afd;
+
+#define MAX_AVI_BUFFER 2048
+
+static byte buffer[ MAX_AVI_BUFFER ];
+static int  bufIndex;
+
+/*
+===============
+SafeFS_Write
+===============
+*/
+static ID_INLINE void SafeFS_Write( const void *buffer, int len, fileHandle_t f )
+{
+  if( FS_Write( buffer, len, f ) < len )
+    Com_Error( ERR_DROP, "Failed to write avi file" );
+}
+
+/*
+===============
+WRITE_STRING
+===============
+*/
+static ID_INLINE void WRITE_STRING( const char *s )
+{
+  ::memcpy( &buffer[ bufIndex ], s, strlen( s ) );
+  bufIndex += strlen( s );
+}
+
+/*
+===============
+WRITE_4BYTES
+===============
+*/
+static ID_INLINE void WRITE_4BYTES( int x )
+{
+  buffer[ bufIndex + 0 ] = (byte)( ( x >>  0 ) & 0xFF );
+  buffer[ bufIndex + 1 ] = (byte)( ( x >>  8 ) & 0xFF );
+  buffer[ bufIndex + 2 ] = (byte)( ( x >> 16 ) & 0xFF );
+  buffer[ bufIndex + 3 ] = (byte)( ( x >> 24 ) & 0xFF );
+  bufIndex += 4;
+}
+
+/*
+===============
+WRITE_2BYTES
+===============
+*/
+static ID_INLINE void WRITE_2BYTES( int x )
+{
+  buffer[ bufIndex + 0 ] = (byte)( ( x >>  0 ) & 0xFF );
+  buffer[ bufIndex + 1 ] = (byte)( ( x >>  8 ) & 0xFF );
+  bufIndex += 2;
+}
+
+/*
+===============
+START_CHUNK
+===============
+*/
+static ID_INLINE void START_CHUNK( const char *s )
+{
+  if( afd.chunkStackTop == MAX_RIFF_CHUNKS )
+  {
+    Com_Error( ERR_DROP, "ERROR: Top of chunkstack breached" );
+  }
+
+  afd.chunkStack[ afd.chunkStackTop ] = bufIndex;
+  afd.chunkStackTop++;
+  WRITE_STRING( s );
+  WRITE_4BYTES( 0 );
+}
+
+/*
+===============
+END_CHUNK
+===============
+*/
+static ID_INLINE void END_CHUNK( void )
+{
+  int endIndex = bufIndex;
+
+  if( afd.chunkStackTop <= 0 )
+  {
+    Com_Error( ERR_DROP, "ERROR: Bottom of chunkstack breached" );
+  }
+
+  afd.chunkStackTop--;
+  bufIndex = afd.chunkStack[ afd.chunkStackTop ];
+  bufIndex += 4;
+  WRITE_4BYTES( endIndex - bufIndex - 4 );
+  bufIndex = endIndex;
+  bufIndex = PAD( bufIndex, 2 );
+}
+
+/*
+===============
+CL_WriteAVIHeader
+===============
+*/
+void CL_WriteAVIHeader( void )
+{
+  bufIndex = 0;
+  afd.chunkStackTop = 0;
+
+  START_CHUNK( "RIFF" );
+  {
+    WRITE_STRING( "AVI " );
+    {
+      START_CHUNK( "LIST" );
+      {
+        WRITE_STRING( "hdrl" );
+        WRITE_STRING( "avih" );
+        WRITE_4BYTES( 56 );                     //"avih" "chunk" size
+        WRITE_4BYTES( afd.framePeriod );        //dwMicroSecPerFrame
+        WRITE_4BYTES( afd.maxRecordSize *
+            afd.frameRate );                    //dwMaxBytesPerSec
+        WRITE_4BYTES( 0 );                      //dwReserved1
+        WRITE_4BYTES( 0x110 );                  //dwFlags bits HAS_INDEX and IS_INTERLEAVED
+        WRITE_4BYTES( afd.numVideoFrames );     //dwTotalFrames
+        WRITE_4BYTES( 0 );                      //dwInitialFrame
+
+        if( afd.audio )                         //dwStreams
+          WRITE_4BYTES( 2 );
+        else
+          WRITE_4BYTES( 1 );
+
+        WRITE_4BYTES( afd.maxRecordSize );      //dwSuggestedBufferSize
+        WRITE_4BYTES( afd.width );              //dwWidth
+        WRITE_4BYTES( afd.height );             //dwHeight
+        WRITE_4BYTES( 0 );                      //dwReserved[ 0 ]
+        WRITE_4BYTES( 0 );                      //dwReserved[ 1 ]
+        WRITE_4BYTES( 0 );                      //dwReserved[ 2 ]
+        WRITE_4BYTES( 0 );                      //dwReserved[ 3 ]
+
+        START_CHUNK( "LIST" );
+        {
+          WRITE_STRING( "strl" );
+          WRITE_STRING( "strh" );
+          WRITE_4BYTES( 56 );                   //"strh" "chunk" size
+          WRITE_STRING( "vids" );
+
+          if( afd.motionJpeg )
+            WRITE_STRING( "MJPG" );
+          else
+            WRITE_4BYTES( 0 );                  // BI_RGB
+
+          WRITE_4BYTES( 0 );                    //dwFlags
+          WRITE_4BYTES( 0 );                    //dwPriority
+          WRITE_4BYTES( 0 );                    //dwInitialFrame
+
+          WRITE_4BYTES( 1 );                    //dwTimescale
+          WRITE_4BYTES( afd.frameRate );        //dwDataRate
+          WRITE_4BYTES( 0 );                    //dwStartTime
+          WRITE_4BYTES( afd.numVideoFrames );   //dwDataLength
+
+          WRITE_4BYTES( afd.maxRecordSize );    //dwSuggestedBufferSize
+          WRITE_4BYTES( -1 );                   //dwQuality
+          WRITE_4BYTES( 0 );                    //dwSampleSize
+          WRITE_2BYTES( 0 );                    //rcFrame
+          WRITE_2BYTES( 0 );                    //rcFrame
+          WRITE_2BYTES( afd.width );            //rcFrame
+          WRITE_2BYTES( afd.height );           //rcFrame
+
+          WRITE_STRING( "strf" );
+          WRITE_4BYTES( 40 );                   //"strf" "chunk" size
+          WRITE_4BYTES( 40 );                   //biSize
+          WRITE_4BYTES( afd.width );            //biWidth
+          WRITE_4BYTES( afd.height );           //biHeight
+          WRITE_2BYTES( 1 );                    //biPlanes
+          WRITE_2BYTES( 24 );                   //biBitCount
+
+          if( afd.motionJpeg )                  //biCompression
+          {
+            WRITE_STRING( "MJPG" );
+            WRITE_4BYTES( afd.width *
+                afd.height );                   //biSizeImage
+          }
+          else
+          {
+            WRITE_4BYTES( 0 );                  // BI_RGB
+            WRITE_4BYTES( afd.width *
+                afd.height * 3 );               //biSizeImage
+          }
+
+          WRITE_4BYTES( 0 );                    //biXPelsPetMeter
+          WRITE_4BYTES( 0 );                    //biYPelsPetMeter
+          WRITE_4BYTES( 0 );                    //biClrUsed
+          WRITE_4BYTES( 0 );                    //biClrImportant
+        }
+        END_CHUNK( );
+
+        if( afd.audio )
+        {
+          START_CHUNK( "LIST" );
+          {
+            WRITE_STRING( "strl" );
+            WRITE_STRING( "strh" );
+            WRITE_4BYTES( 56 );                 //"strh" "chunk" size
+            WRITE_STRING( "auds" );
+            WRITE_4BYTES( 0 );                  //FCC
+            WRITE_4BYTES( 0 );                  //dwFlags
+            WRITE_4BYTES( 0 );                  //dwPriority
+            WRITE_4BYTES( 0 );                  //dwInitialFrame
+
+            WRITE_4BYTES( afd.a.sampleSize );   //dwTimescale
+            WRITE_4BYTES( afd.a.sampleSize *
+                afd.a.rate );                   //dwDataRate
+            WRITE_4BYTES( 0 );                  //dwStartTime
+            WRITE_4BYTES( afd.a.totalBytes /
+                afd.a.sampleSize );             //dwDataLength
+
+            WRITE_4BYTES( 0 );                  //dwSuggestedBufferSize
+            WRITE_4BYTES( -1 );                 //dwQuality
+            WRITE_4BYTES( afd.a.sampleSize );   //dwSampleSize
+            WRITE_2BYTES( 0 );                  //rcFrame
+            WRITE_2BYTES( 0 );                  //rcFrame
+            WRITE_2BYTES( 0 );                  //rcFrame
+            WRITE_2BYTES( 0 );                  //rcFrame
+
+            WRITE_STRING( "strf" );
+            WRITE_4BYTES( 18 );                 //"strf" "chunk" size
+            WRITE_2BYTES( afd.a.format );       //wFormatTag
+            WRITE_2BYTES( afd.a.channels );     //nChannels
+            WRITE_4BYTES( afd.a.rate );         //nSamplesPerSec
+            WRITE_4BYTES( afd.a.sampleSize *
+                afd.a.rate );                   //nAvgBytesPerSec
+            WRITE_2BYTES( afd.a.sampleSize );   //nBlockAlign
+            WRITE_2BYTES( afd.a.bits );         //wBitsPerSample
+            WRITE_2BYTES( 0 );                  //cbSize
+          }
+          END_CHUNK( );
+        }
+      }
+      END_CHUNK( );
+
+      afd.moviOffset = bufIndex;
+
+      START_CHUNK( "LIST" );
+      {
+        WRITE_STRING( "movi" );
+      }
+    }
+  }
+}
+
+/*
+===============
+CL_OpenAVIForWriting
+
+Creates an AVI file and gets it into a state where
+writing the actual data can begin
+===============
+*/
+bool CL_OpenAVIForWriting( const char *fileName )
+{
+  if( afd.fileOpen )
+    return false;
+
+  ::memset( &afd, 0, sizeof( aviFileData_t ) );
+
+  // Don't start if a framerate has not been chosen
+  if( cl_aviFrameRate->integer <= 0 )
+  {
+    Com_Printf( S_COLOR_RED "cl_aviFrameRate must be >= 1\n" );
+    return false;
+  }
+
+  if( ( afd.f = FS_FOpenFileWrite( fileName ) ) <= 0 )
+    return false;
+
+  if( ( afd.idxF = FS_FOpenFileWrite(
+          va( "%s" INDEX_FILE_EXTENSION, fileName ) ) ) <= 0 )
+  {
+    FS_FCloseFile( afd.f );
+    return false;
+  }
+
+  Q_strncpyz( afd.fileName, fileName, MAX_QPATH );
+
+  afd.frameRate = cl_aviFrameRate->integer;
+  afd.framePeriod = (int)( 1000000.0f / afd.frameRate );
+  afd.width = cls.glconfig.vidWidth;
+  afd.height = cls.glconfig.vidHeight;
+
+  if( cl_aviMotionJpeg->integer )
+    afd.motionJpeg = true;
+  else
+    afd.motionJpeg = false;
+
+  // Buffers only need to store RGB pixels.
+  // Allocate a bit more space for the capture buffer to account for possible
+  // padding at the end of pixel lines, and padding for alignment
+  #define MAX_PACK_LEN 16
+  afd.cBuffer = (byte*)Z_Malloc((afd.width * 3 + MAX_PACK_LEN - 1) * afd.height + MAX_PACK_LEN - 1);
+  // raw avi files have pixel lines start on 4-byte boundaries
+  afd.eBuffer = (byte*)Z_Malloc(PAD(afd.width * 3, AVI_LINE_PADDING) * afd.height);
+
+  afd.a.rate = dma.speed;
+  afd.a.format = WAV_FORMAT_PCM;
+  afd.a.channels = dma.channels;
+  afd.a.bits = dma.samplebits;
+  afd.a.sampleSize = ( afd.a.bits / 8 ) * afd.a.channels;
+
+  if( afd.a.rate % afd.frameRate )
+  {
+    int suggestRate = afd.frameRate;
+
+    while( ( afd.a.rate % suggestRate ) && suggestRate >= 1 )
+      suggestRate--;
+
+    Com_Printf( S_COLOR_YELLOW "WARNING: cl_aviFrameRate is not a divisor "
+        "of the audio rate, suggest %d\n", suggestRate );
+  }
+
+  if( !Cvar_VariableIntegerValue( "s_initsound" ) )
+  {
+    afd.audio = false;
+  }
+  else if( Q_stricmp( Cvar_VariableString( "s_backend" ), "OpenAL" ) )
+  {
+    if( afd.a.bits != 16 || afd.a.channels != 2 )
+    {
+      Com_Printf( S_COLOR_YELLOW "WARNING: Audio format of %d bit/%d channels not supported",
+          afd.a.bits, afd.a.channels );
+      afd.audio = false;
+    }
+    else
+      afd.audio = true;
+  }
+  else
+  {
+    afd.audio = false;
+    Com_Printf( S_COLOR_YELLOW "WARNING: Audio capture is not supported "
+        "with OpenAL. Set s_useOpenAL to 0 for audio capture\n" );
+  }
+
+  // This doesn't write a real header, but allocates the
+  // correct amount of space at the beginning of the file
+  CL_WriteAVIHeader( );
+
+  SafeFS_Write( buffer, bufIndex, afd.f );
+  afd.fileSize = bufIndex;
+
+  bufIndex = 0;
+  START_CHUNK( "idx1" );
+  SafeFS_Write( buffer, bufIndex, afd.idxF );
+
+  afd.moviSize = 4; // For the "movi"
+  afd.fileOpen = true;
+
+  return true;
+}
+
+/*
+===============
+CL_CheckFileSize
+===============
+*/
+static bool CL_CheckFileSize( int bytesToAdd )
+{
+  unsigned int newFileSize;
+
+  newFileSize =
+    afd.fileSize +                // Current file size
+    bytesToAdd +                  // What we want to add
+    ( afd.numIndices * 16 ) +     // The index
+    4;                            // The index size
+
+  // I assume all the operating systems
+  // we target can handle a 2Gb file
+  if( newFileSize > INT_MAX )
+  {
+    // Close the current file...
+    CL_CloseAVI( );
+
+    // ...And open a new one
+    CL_OpenAVIForWriting( va( "%s_", afd.fileName ) );
+
+    return true;
+  }
+
+  return false;
+}
+
+/*
+===============
+CL_WriteAVIVideoFrame
+===============
+*/
+void CL_WriteAVIVideoFrame( const byte *imageBuffer, int size )
+{
+  int   chunkOffset = afd.fileSize - afd.moviOffset - 8;
+  int   chunkSize = 8 + size;
+  int   paddingSize = PADLEN(size, 2);
+  byte  padding[ 4 ] = { 0 };
+
+  if( !afd.fileOpen )
+    return;
+
+  // Chunk header + contents + padding
+  if( CL_CheckFileSize( 8 + size + 2 ) )
+    return;
+
+  bufIndex = 0;
+  WRITE_STRING( "00dc" );
+  WRITE_4BYTES( size );
+
+  SafeFS_Write( buffer, 8, afd.f );
+  SafeFS_Write( imageBuffer, size, afd.f );
+  SafeFS_Write( padding, paddingSize, afd.f );
+  afd.fileSize += ( chunkSize + paddingSize );
+
+  afd.numVideoFrames++;
+  afd.moviSize += ( chunkSize + paddingSize );
+
+  if( size > afd.maxRecordSize )
+    afd.maxRecordSize = size;
+
+  // Index
+  bufIndex = 0;
+  WRITE_STRING( "00dc" );           //dwIdentifier
+  WRITE_4BYTES( 0x00000010 );       //dwFlags (all frames are KeyFrames)
+  WRITE_4BYTES( chunkOffset );      //dwOffset
+  WRITE_4BYTES( size );             //dwLength
+  SafeFS_Write( buffer, 16, afd.idxF );
+
+  afd.numIndices++;
+}
+
+#define PCM_BUFFER_SIZE 44100
+
+/*
+===============
+CL_WriteAVIAudioFrame
+===============
+*/
+void CL_WriteAVIAudioFrame( const byte *pcmBuffer, int size )
+{
+  static byte pcmCaptureBuffer[ PCM_BUFFER_SIZE ] = { 0 };
+  static int  bytesInBuffer = 0;
+
+  if( !afd.audio )
+    return;
+
+  if( !afd.fileOpen )
+    return;
+
+  // Chunk header + contents + padding
+  if( CL_CheckFileSize( 8 + bytesInBuffer + size + 2 ) )
+    return;
+
+  if( bytesInBuffer + size > PCM_BUFFER_SIZE )
+  {
+    Com_Printf( S_COLOR_YELLOW
+        "WARNING: Audio capture buffer overflow -- truncating\n" );
+    size = PCM_BUFFER_SIZE - bytesInBuffer;
+  }
+
+  ::memcpy( &pcmCaptureBuffer[ bytesInBuffer ], pcmBuffer, size );
+  bytesInBuffer += size;
+
+  // Only write if we have a frame's worth of audio
+  if( bytesInBuffer >= (int)ceil( (float)afd.a.rate / (float)afd.frameRate ) *
+        afd.a.sampleSize )
+  {
+    int   chunkOffset = afd.fileSize - afd.moviOffset - 8;
+    int   chunkSize = 8 + bytesInBuffer;
+    int   paddingSize = PADLEN(bytesInBuffer, 2);
+    byte  padding[ 4 ] = { 0 };
+
+    bufIndex = 0;
+    WRITE_STRING( "01wb" );
+    WRITE_4BYTES( bytesInBuffer );
+
+    SafeFS_Write( buffer, 8, afd.f );
+    SafeFS_Write( pcmCaptureBuffer, bytesInBuffer, afd.f );
+    SafeFS_Write( padding, paddingSize, afd.f );
+    afd.fileSize += ( chunkSize + paddingSize );
+
+    afd.numAudioFrames++;
+    afd.moviSize += ( chunkSize + paddingSize );
+    afd.a.totalBytes += bytesInBuffer;
+
+    // Index
+    bufIndex = 0;
+    WRITE_STRING( "01wb" );           //dwIdentifier
+    WRITE_4BYTES( 0 );                //dwFlags
+    WRITE_4BYTES( chunkOffset );      //dwOffset
+    WRITE_4BYTES( bytesInBuffer );    //dwLength
+    SafeFS_Write( buffer, 16, afd.idxF );
+
+    afd.numIndices++;
+
+    bytesInBuffer = 0;
+  }
+}
+
+/*
+===============
+CL_TakeVideoFrame
+===============
+*/
+void CL_TakeVideoFrame( void )
+{
+  // AVI file isn't open
+  if( !afd.fileOpen )
+    return;
+
+  re.TakeVideoFrame( afd.width, afd.height, afd.cBuffer, afd.eBuffer, afd.motionJpeg );
+}
+
+/*
+===============
+CL_CloseAVI
+
+Closes the AVI file and writes an index chunk
+===============
+*/
+bool CL_CloseAVI( void )
+{
+  int indexRemainder;
+  int indexSize = afd.numIndices * 16;
+  const char *idxFileName = va( "%s" INDEX_FILE_EXTENSION, afd.fileName );
+
+  // AVI file isn't open
+  if( !afd.fileOpen )
+    return false;
+
+  afd.fileOpen = false;
+
+  FS_Seek( afd.idxF, 4, FS_SEEK_SET );
+  bufIndex = 0;
+  WRITE_4BYTES( indexSize );
+  SafeFS_Write( buffer, bufIndex, afd.idxF );
+  FS_FCloseFile( afd.idxF );
+
+  // Write index
+
+  // Open the temp index file
+  if( ( indexSize = FS_FOpenFileRead( idxFileName, &afd.idxF, true ) ) <= 0 )
+  {
+    FS_FCloseFile( afd.f );
+    return false;
+  }
+
+  indexRemainder = indexSize;
+
+  // Append index to end of avi file
+  while( indexRemainder > MAX_AVI_BUFFER )
+  {
+    FS_Read( buffer, MAX_AVI_BUFFER, afd.idxF );
+    SafeFS_Write( buffer, MAX_AVI_BUFFER, afd.f );
+    afd.fileSize += MAX_AVI_BUFFER;
+    indexRemainder -= MAX_AVI_BUFFER;
+  }
+  FS_Read( buffer, indexRemainder, afd.idxF );
+  SafeFS_Write( buffer, indexRemainder, afd.f );
+  afd.fileSize += indexRemainder;
+  FS_FCloseFile( afd.idxF );
+
+  // Remove temp index file
+  FS_HomeRemove( idxFileName );
+
+  // Write the real header
+  FS_Seek( afd.f, 0, FS_SEEK_SET );
+  CL_WriteAVIHeader( );
+
+  bufIndex = 4;
+  WRITE_4BYTES( afd.fileSize - 8 ); // "RIFF" size
+
+  bufIndex = afd.moviOffset + 4;    // Skip "LIST"
+  WRITE_4BYTES( afd.moviSize );
+
+  SafeFS_Write( buffer, bufIndex, afd.f );
+
+  Z_Free( afd.cBuffer );
+  Z_Free( afd.eBuffer );
+  FS_FCloseFile( afd.f );
+
+  Com_Printf( "Wrote %d:%d frames to %s\n", afd.numVideoFrames, afd.numAudioFrames, afd.fileName );
+
+  return true;
+}
+
+/*
+===============
+CL_VideoRecording
+===============
+*/
+bool CL_VideoRecording( void )
+{
+  return afd.fileOpen;
+}
diff --git a/src/client/cl_cgame.cpp b/src/client/cl_cgame.cpp
new file mode 100644
index 0000000..f16dc35
--- /dev/null
+++ b/src/client/cl_cgame.cpp
@@ -0,0 +1,1172 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+// cl_cgame.c  -- client system interaction with client game
+
+#include "client.h"
+
+#ifdef USE_MUMBLE
+#include "libmumblelink.h"
+#endif
+#include "snd_public.h"
+
+/*
+====================
+CL_GetGameState
+====================
+*/
+static void CL_GetGameState( gameState_t *gs )
+{
+	*gs = cl.gameState;
+}
+
+/*
+====================
+CL_GetGlconfig
+====================
+*/
+static void CL_GetGlconfig( glconfig_t *glconfig )
+{
+	*glconfig = cls.glconfig;
+}
+
+
+/*
+====================
+CL_GetUserCmd
+====================
+*/
+static bool CL_GetUserCmd( int cmdNumber, usercmd_t *ucmd )
+{
+	// cmds[cmdNumber] is the last properly generated command
+
+	// can't return anything that we haven't created yet
+	if ( cmdNumber > cl.cmdNumber )
+		Com_Error( ERR_DROP, "CL_GetUserCmd: %i >= %i", cmdNumber, cl.cmdNumber );
+
+	// the usercmd has been overwritten in the wrapping
+	// buffer because it is too far out of date
+	if ( cmdNumber <= cl.cmdNumber - CMD_BACKUP )
+		return false;
+
+	*ucmd = cl.cmds[ cmdNumber & CMD_MASK ];
+
+	return true;
+}
+
+static int CL_GetCurrentCmdNumber( void )
+{
+	return cl.cmdNumber;
+}
+
+/*
+====================
+CL_GetCurrentSnapshotNumber
+====================
+*/
+static void CL_GetCurrentSnapshotNumber( int *snapshotNumber, int *serverTime )
+{
+	*snapshotNumber = cl.snap.messageNum;
+	*serverTime = cl.snap.serverTime;
+}
+
+/*
+====================
+CL_GetSnapshot
+====================
+*/
+bool CL_GetSnapshot( int snapshotNumber, snapshot_t *snapshot )
+{
+	clSnapshot_t *clSnap;
+
+	if ( snapshotNumber > cl.snap.messageNum ) {
+		Com_Error( ERR_DROP, "CL_GetSnapshot: snapshotNumber > cl.snapshot.messageNum" );
+	}
+
+    // if the frame has fallen out of the circular buffer, we can't return it
+	if ( cl.snap.messageNum - snapshotNumber >= PACKET_BACKUP )
+		return false;
+
+	// if the frame is not valid, we can't return it
+	clSnap = &cl.snapshots[snapshotNumber & PACKET_MASK];
+	if ( !clSnap->valid )
+		return false;
+
+    // if the entities in the frame have fallen out of their circular buffer,
+    // we can't return it
+	if ( cl.parseEntitiesNum - clSnap->parseEntitiesNum >= MAX_PARSE_ENTITIES )
+		return false;
+
+	// write the snapshot
+	snapshot->snapFlags = clSnap->snapFlags;
+	snapshot->ping = clSnap->ping;
+	snapshot->serverTime = clSnap->serverTime;
+	::memcpy( snapshot->areamask, clSnap->areamask, sizeof( snapshot->areamask ) );
+
+	int count = clSnap->numEntities;
+	if ( count > MAX_ENTITIES_IN_SNAPSHOT )
+    {
+		Com_DPrintf( "CL_GetSnapshot: truncated %i entities to %i\n", count, MAX_ENTITIES_IN_SNAPSHOT );
+		count = MAX_ENTITIES_IN_SNAPSHOT;
+	}
+
+	if ( cls.cgInterface == 2 )
+    {
+		alternateSnapshot_t *altSnapshot = (alternateSnapshot_t *)snapshot;
+		altSnapshot->ps = clSnap->alternatePs;
+		altSnapshot->serverCommandSequence = clSnap->serverCommandNum;
+		altSnapshot->numEntities = count;
+
+		for ( int i = 0 ; i < count ; i++ )
+        {
+			entityState_t *es = &cl.parseEntities[ ( clSnap->parseEntitiesNum + i ) & (MAX_PARSE_ENTITIES-1) ];
+			::memcpy( &altSnapshot->entities[i], es, (size_t)&((entityState_t *)0)->weaponAnim );
+			altSnapshot->entities[i].generic1 = es->generic1;
+		}
+	}
+    else
+    {
+		snapshot->ps = clSnap->ps;
+		snapshot->serverCommandSequence = clSnap->serverCommandNum;
+		snapshot->numEntities = count;
+		for ( int i = 0 ; i < count ; i++ )
+        {
+			snapshot->entities[i] = 
+				cl.parseEntities[ ( clSnap->parseEntitiesNum + i ) & (MAX_PARSE_ENTITIES-1) ];
+		}
+	}
+
+	// FIXME: configstring changes and server commands!!!
+
+	return true;
+}
+
+/*
+=====================
+CL_SetUserCmdValue
+=====================
+*/
+void CL_SetUserCmdValue( int userCmdValue, float sensitivityScale ) {
+	cl.cgameUserCmdValue = userCmdValue;
+	cl.cgameSensitivity = sensitivityScale;
+}
+
+/*
+=====================
+CL_AddCgameCommand
+=====================
+*/
+void CL_AddCgameCommand( const char *cmdName ) {
+	Cmd_AddCommand( cmdName, NULL );
+}
+
+/*
+=====================
+CL_ConfigstringModified
+=====================
+*/
+void CL_ConfigstringModified( void )
+{
+	int idx = atoi( Cmd_Argv(1) );
+	if ( idx < 0 || idx >= MAX_CONFIGSTRINGS )
+		Com_Error( ERR_DROP, "CL_ConfigstringModified: bad index %i", idx );
+
+	// get everything after "cs <num>"
+	const char* s = Cmd_ArgsFrom(2);
+	const char* old = cl.gameState.stringData + cl.gameState.stringOffsets[ idx ];
+	if ( !strcmp(old, s) )
+		return;
+
+	// build the new gameState_t
+	gameState_t	oldGs = cl.gameState;
+
+	::memset( &cl.gameState, 0, sizeof( cl.gameState ) );
+
+	// leave the first 0 for uninitialized strings
+	cl.gameState.dataCount = 1;
+		
+    const char* dup;
+	for ( int i = 0 ; i < MAX_CONFIGSTRINGS ; i++ )
+    {
+		if ( i == idx )
+			dup = s;
+        else
+			dup = oldGs.stringData + oldGs.stringOffsets[ i ];
+
+		if ( !dup[0] )
+			continue;		// leave with the default empty string
+
+		int len = strlen(dup);
+		if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS )
+			Com_Error(ERR_DROP, "MAX_GAMESTATE_CHARS exceeded");
+
+		// append it to the gameState string buffer
+		cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
+		::memcpy( cl.gameState.stringData + cl.gameState.dataCount, dup, len + 1 );
+		cl.gameState.dataCount += len + 1;
+	}
+
+	if ( idx == CS_SYSTEMINFO )
+    {
+		// parse serverId and other cvars
+		CL_SystemInfoChanged();
+	}
+}
+
+
+/*
+===================
+CL_GetServerCommand
+
+Set up argc/argv for the given command
+===================
+*/
+static bool CL_GetServerCommand( int serverCommandNumber )
+{
+	const char *s;
+	const char *cmd;
+	static char bigConfigString[BIG_INFO_STRING];
+	int argc;
+
+	// if we have irretrievably lost a reliable command, drop the connection
+	if ( serverCommandNumber <= clc.serverCommandSequence - MAX_RELIABLE_COMMANDS )
+    {
+		// when a demo record was started after the client got a whole bunch of
+		// reliable commands then the client never got those first reliable commands
+		if ( clc.demoplaying )
+			return false;
+
+		Com_Error( ERR_DROP, "CL_GetServerCommand: a reliable command was cycled out" );
+		return false;
+	}
+
+	if ( serverCommandNumber > clc.serverCommandSequence )
+    {
+		Com_Error( ERR_DROP, "CL_GetServerCommand: requested a command not received" );
+		return false;
+	}
+
+	s = clc.serverCommands[ serverCommandNumber & ( MAX_RELIABLE_COMMANDS - 1 ) ];
+	clc.lastExecutedServerCommand = serverCommandNumber;
+
+	Com_DPrintf( "serverCommand: %i : %s\n", serverCommandNumber, s );
+
+rescan:
+	Cmd_TokenizeString( s );
+	cmd = Cmd_Argv(0);
+	argc = Cmd_Argc();
+
+	if ( !strcmp( cmd, "disconnect" ) )
+    {
+		// allow server to indicate why they were disconnected
+		if ( argc >= 2 )
+			Com_Error( ERR_SERVERDISCONNECT, "Server disconnected - %s", Cmd_Argv( 1 ) );
+		else
+			Com_Error( ERR_SERVERDISCONNECT, "Server disconnected" );
+	}
+
+	if ( !strcmp( cmd, "bcs0" ) )
+    {
+		Com_sprintf( bigConfigString, BIG_INFO_STRING, "cs %s \"%s", Cmd_Argv(1), Cmd_Argv(2) );
+		return false;
+	}
+
+	if ( !strcmp( cmd, "bcs1" ) )
+    {
+		s = Cmd_Argv(2);
+		if( strlen(bigConfigString) + strlen(s) >= BIG_INFO_STRING )
+			Com_Error( ERR_DROP, "bcs exceeded BIG_INFO_STRING" );
+
+		strcat( bigConfigString, s );
+		return false;
+	}
+
+	if ( !strcmp( cmd, "bcs2" ) )
+    {
+		s = Cmd_Argv(2);
+		if( strlen(bigConfigString) + strlen(s) + 1 >= BIG_INFO_STRING )
+			Com_Error( ERR_DROP, "bcs exceeded BIG_INFO_STRING" );
+
+		strcat( bigConfigString, s );
+		strcat( bigConfigString, "\"" );
+		s = bigConfigString;
+		goto rescan;
+	}
+
+	if ( !strcmp( cmd, "cs" ) )
+    {
+		CL_ConfigstringModified();
+        // reparse the string, because CL_ConfigstringModified may have done
+        // another Cmd_TokenizeString()
+		Cmd_TokenizeString( s );
+		return true;
+	}
+
+	if ( !strcmp( cmd, "map_restart" ) )
+    {
+		// clear notify lines and outgoing commands before passing
+		// the restart to the cgame
+		Con_ClearNotify();
+        // reparse the string, because Con_ClearNotify() may have done another
+        // Cmd_TokenizeString()
+		Cmd_TokenizeString( s );
+		::memset( cl.cmds, 0, sizeof( cl.cmds ) );
+		return true;
+	}
+
+	// we may want to put a "connect to other server" command here
+
+	// cgame can now act on the command
+	return true;
+}
+
+
+/*
+====================
+CL_CM_LoadMap
+
+Just adds default parameters that cgame doesn't need to know about
+====================
+*/
+void CL_CM_LoadMap( const char *mapname ) {
+	int		checksum;
+
+	CM_LoadMap( mapname, true, &checksum );
+}
+
+char * safe_strncpy(char *dest, const char *src, size_t n)
+{
+    char *ret = dest;
+    while (n > 0 && src[0])
+    {
+	    *ret++ = *src++;
+	    --n;
+    }
+    while (n > 0)
+    {
+	    *ret++ = '\0';
+    	--n;
+    }
+    return dest;
+}
+
+/*
+====================
+CL_ShutdonwCGame
+
+====================
+*/
+void CL_ShutdownCGame( void ) {
+	Key_SetCatcher( Key_GetCatcher( ) & ~KEYCATCH_CGAME );
+	cls.cgameStarted = false;
+	if ( !cls.cgame ) {
+		return;
+	}
+	VM_Call( cls.cgame, CG_SHUTDOWN );
+	VM_Free( cls.cgame );
+	cls.cgame = NULL;
+}
+
+static int	FloatAsInt( float f ) {
+	floatint_t fi;
+	fi.f = f;
+	return fi.i;
+}
+
+static bool probingCG = false;
+
+/*
+====================
+CL_CgameSystemCalls
+
+The cgame module is making a system call
+====================
+*/
+intptr_t CL_CgameSystemCalls( intptr_t *args )
+{
+	if( cls.cgInterface == 2 && args[0] >= CG_R_SETCLIPREGION && args[0] < CG_MEMSET )
+    {
+		if( args[0] < CG_S_STOPBACKGROUNDTRACK - 1 )
+			args[0] += 1;
+
+        else if( args[0] < CG_S_STOPBACKGROUNDTRACK + 4 )
+			args[0] += CG_PARSE_ADD_GLOBAL_DEFINE - CG_S_STOPBACKGROUNDTRACK + 1;
+
+        else if( args[0] < CG_PARSE_ADD_GLOBAL_DEFINE + 4 )
+			args[0] -= 4;
+
+        else if( args[0] >= CG_PARSE_SOURCE_FILE_AND_LINE && args[0] <= CG_S_SOUNDDURATION )
+			args[0] = CG_PARSE_SOURCE_FILE_AND_LINE - 1337 - args[0] ;
+	}
+
+	switch( args[0] )
+    {
+        case CG_PRINT:
+            Com_Printf( "%s", (const char*)VMA(1) );
+            return 0;
+        case CG_ERROR:
+            if( probingCG )
+            {
+                cls.cgInterface = 2; // this is a 1.1.0 cgame
+                return 0;
+            }
+            Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );
+            return 0;
+        case CG_MILLISECONDS:
+            return Sys_Milliseconds();
+        case CG_CVAR_REGISTER:
+            Cvar_Register( (vmCvar_t*)VMA(1), (const char*)VMA(2), (const char*)VMA(3), args[4] ); 
+            return 0;
+        case CG_CVAR_UPDATE:
+            Cvar_Update( (vmCvar_t*)VMA(1) );
+            return 0;
+        case CG_CVAR_SET:
+            Cvar_SetSafe( (const char*)VMA(1), (const char*)VMA(2) );
+            return 0;
+        case CG_CVAR_VARIABLESTRINGBUFFER:
+            Cvar_VariableStringBuffer( (const char*)VMA(1), (char*)VMA(2), args[3] );
+            return 0;
+        case CG_ARGC:
+            return Cmd_Argc();
+        case CG_ARGV:
+            Cmd_ArgvBuffer( args[1], (char*)VMA(2), args[3] );
+            return 0;
+        case CG_ARGS:
+            Cmd_ArgsBuffer( (char*)VMA(1), args[2] );
+            return 0;
+        case CG_LITERAL_ARGS:
+            Cmd_LiteralArgsBuffer( (char*)VMA(1), args[2] );
+            return 0;
+        case CG_FS_FOPENFILE:
+            return FS_FOpenFileByMode( (const char*)VMA(1), (fileHandle_t*)VMA(2), (FS_Mode)args[3] );
+        case CG_FS_READ:
+            FS_Read( VMA(1), args[2], args[3] );
+            return 0;
+        case CG_FS_WRITE:
+            FS_Write( VMA(1), args[2], args[3] );
+            return 0;
+        case CG_FS_FCLOSEFILE:
+            FS_FCloseFile( args[1] );
+            return 0;
+        case CG_FS_SEEK:
+            return FS_Seek( (fileHandle_t)args[1], args[2], (FS_Origin)args[3] );
+        case CG_FS_GETFILELIST:
+            return FS_GetFileList( (const char*)VMA(1), (const char*)VMA(2), (char*)VMA(3), args[4] );
+        case CG_SENDCONSOLECOMMAND:
+            Cbuf_AddText( (const char*)VMA(1) );
+            return 0;
+        case CG_ADDCOMMAND:
+            CL_AddCgameCommand( (const char*)VMA(1) );
+            return 0;
+        case CG_REMOVECOMMAND:
+            Cmd_RemoveCommandSafe( (const char*)VMA(1) );
+            return 0;
+        case CG_SENDCLIENTCOMMAND:
+            CL_AddReliableCommand((const char*)VMA(1), false);
+            return 0;
+        case CG_UPDATESCREEN:
+            // this is used during lengthy level loading, so pump message loop
+            //		Com_EventLoop();	// FIXME: if a server restarts here, BAD THINGS HAPPEN!
+            // We can't call Com_EventLoop here, a restart will crash and this _does_ happen
+            // if there is a map change while we are downloading at pk3.
+            // ZOID
+            SCR_UpdateScreen();
+            return 0;
+        case CG_CM_LOADMAP:
+            CL_CM_LoadMap( (const char*)VMA(1) );
+            return 0;
+        case CG_CM_NUMINLINEMODELS:
+            return CM_NumInlineModels();
+        case CG_CM_INLINEMODEL:
+            return CM_InlineModel( args[1] );
+        case CG_CM_TEMPBOXMODEL:
+            return CM_TempBoxModel( (const float*)VMA(1), (const float*)VMA(2), false );
+        case CG_CM_TEMPCAPSULEMODEL:
+            return CM_TempBoxModel( (const float*)VMA(1), (const float*)VMA(2), true );
+        case CG_CM_POINTCONTENTS:
+            return CM_PointContents( (const float*)VMA(1), args[2] );
+        case CG_CM_TRANSFORMEDPOINTCONTENTS:
+            return CM_TransformedPointContents( (const float*)VMA(1), (clipHandle_t)args[2],
+                                                (const float*)VMA(3), (const float*)VMA(4) );
+        case CG_CM_BOXTRACE:
+            CM_BoxTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3),
+                         (float*)VMA(4), (float*)VMA(5), (clipHandle_t)args[6], args[7], TT_AABB );
+            return 0;
+        case CG_CM_CAPSULETRACE:
+            CM_BoxTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3),
+                         (float*)VMA(4), (float*)VMA(5), (clipHandle_t)args[6], args[7], TT_CAPSULE );
+            return 0;
+        case CG_CM_TRANSFORMEDBOXTRACE:
+            CM_TransformedBoxTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3),
+                                    (float*)VMA(4), (float*)VMA(5), (clipHandle_t)args[6], args[7],
+                                    (const float*)VMA(8), (const float*)VMA(9), TT_AABB );
+            return 0;
+        case CG_CM_TRANSFORMEDCAPSULETRACE:
+            CM_TransformedBoxTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3),
+                                    (float*)VMA(4), (float*)VMA(5), (clipHandle_t)args[6], args[7],
+                                    (const float*)VMA(8), (const float*)VMA(9), TT_CAPSULE );
+            return 0;
+        case CG_CM_BISPHERETRACE:
+            CM_BiSphereTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3), VMF(4), VMF(5), (clipHandle_t)args[6], args[7] );
+            return 0;
+        case CG_CM_TRANSFORMEDBISPHERETRACE:
+            CM_TransformedBiSphereTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3),
+                                         VMF(4), VMF(5), (clipHandle_t)args[6], args[7], (const float*)VMA(8) );
+            return 0;
+        case CG_CM_MARKFRAGMENTS:
+            {
+            float (&arg2)[3][3] = *reinterpret_cast<float (*)[3][3]>(VMA(2));
+            return re.MarkFragments( args[1], arg2, (const float*)VMA(3), args[4], (float*)VMA(5), args[6], (markFragment_t*)VMA(7) );
+            }
+        case CG_S_STARTSOUND:
+            S_StartSound( (float*)VMA(1), args[2], args[3], (sfxHandle_t)args[4] );
+            return 0;
+        case CG_S_STARTLOCALSOUND:
+            S_StartLocalSound( (sfxHandle_t)args[1], args[2] );
+            return 0;
+        case CG_S_CLEARLOOPINGSOUNDS:
+            S_ClearLoopingSounds( (bool)args[1] );
+            return 0;
+        case CG_S_ADDLOOPINGSOUND:
+            S_AddLoopingSound( args[1], (const float*)VMA(2), (const float*)VMA(3), (sfxHandle_t)args[4] );
+            return 0;
+        case CG_S_ADDREALLOOPINGSOUND:
+            S_AddRealLoopingSound( args[1], (const float*)VMA(2), (const float*)VMA(3), (sfxHandle_t)args[4] );
+            return 0;
+        case CG_S_STOPLOOPINGSOUND:
+            S_StopLoopingSound( args[1] );
+            return 0;
+        case CG_S_UPDATEENTITYPOSITION:
+            S_UpdateEntityPosition( args[1], (const float*)VMA(2) );
+            return 0;
+        case CG_S_RESPATIALIZE:
+            {
+            float (&arg3)[3][3] = *reinterpret_cast<float (*)[3][3]>(VMA(3));
+            S_Respatialize( args[1], (const float*)VMA(2), arg3, args[4] );
+            return 0;
+            }
+        case CG_S_REGISTERSOUND:
+            return S_RegisterSound( (const char*)VMA(1), (bool)args[2] );
+        case CG_S_SOUNDDURATION:
+            return S_SoundDuration( args[1] );
+        case CG_S_STARTBACKGROUNDTRACK:
+            S_StartBackgroundTrack( (const char*)VMA(1), (const char*)VMA(2) );
+            return 0;
+        case CG_R_LOADWORLDMAP:
+            re.LoadWorld( (const char*)VMA(1) );
+            return 0; 
+        case CG_R_REGISTERMODEL:
+            return re.RegisterModel( (const char*)VMA(1) );
+        case CG_R_REGISTERSKIN:
+            return re.RegisterSkin( (const char*)VMA(1) );
+        case CG_R_REGISTERSHADER:
+            return re.RegisterShader( (const char*)VMA(1) );
+        case CG_R_REGISTERSHADERNOMIP:
+            return re.RegisterShaderNoMip( (const char*)VMA(1) );
+        case CG_R_REGISTERFONT:
+            re.RegisterFont( (const char*)VMA(1), args[2], (fontInfo_t*)VMA(3));
+            return 0;
+        case CG_R_CLEARSCENE:
+            re.ClearScene();
+            return 0;
+        case CG_R_ADDREFENTITYTOSCENE:
+            re.AddRefEntityToScene( (const refEntity_t*)VMA(1) );
+            return 0;
+        case CG_R_ADDPOLYTOSCENE:
+            re.AddPolyToScene( (qhandle_t)args[1], args[2], (const polyVert_t*)VMA(3), 1 );
+            return 0;
+        case CG_R_ADDPOLYSTOSCENE:
+            re.AddPolyToScene( (qhandle_t)args[1], args[2], (const polyVert_t*)VMA(3), args[4] );
+            return 0;
+        case CG_R_LIGHTFORPOINT:
+            return re.LightForPoint( (float*)VMA(1), (float*)VMA(2), (float*)VMA(3), (float*)VMA(4) );
+        case CG_R_ADDLIGHTTOSCENE:
+            re.AddLightToScene( (const float*)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
+            return 0;
+        case CG_R_ADDADDITIVELIGHTTOSCENE:
+            re.AddAdditiveLightToScene( (const float*)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
+            return 0;
+        case CG_R_RENDERSCENE:
+            re.RenderScene( (const refdef_t*)VMA(1) );
+            return 0;
+        case CG_R_SETCOLOR:
+            re.SetColor( (const float*)VMA(1) );
+            return 0;
+        case CG_R_SETCLIPREGION:
+            re.SetClipRegion( (const float*)VMA(1) );
+            return 0;
+        case CG_R_DRAWSTRETCHPIC:
+            re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), (qhandle_t)args[9] );
+            return 0;
+        case CG_R_MODELBOUNDS:
+            re.ModelBounds( (qhandle_t)args[1], (float*)VMA(2), (float*)VMA(3) );
+            return 0;
+        case CG_R_LERPTAG:
+            return re.LerpTag( (orientation_t*)VMA(1), args[2], args[3], args[4], VMF(5), (const char*)VMA(6) );
+        case CG_GETGLCONFIG:
+            CL_GetGlconfig( (glconfig_t*)VMA(1) );
+            return 0;
+        case CG_GETGAMESTATE:
+            CL_GetGameState( (gameState_t*)VMA(1) );
+            return 0;
+        case CG_GETCURRENTSNAPSHOTNUMBER:
+            CL_GetCurrentSnapshotNumber( (int*)VMA(1), (int*)VMA(2) );
+            return 0;
+        case CG_GETSNAPSHOT:
+            return CL_GetSnapshot( args[1], (snapshot_t*)VMA(2) );
+        case CG_GETSERVERCOMMAND:
+            return CL_GetServerCommand( args[1] );
+        case CG_GETCURRENTCMDNUMBER:
+            return CL_GetCurrentCmdNumber();
+        case CG_GETUSERCMD:
+            return CL_GetUserCmd( args[1], (usercmd_t*)VMA(2) );
+        case CG_SETUSERCMDVALUE:
+            CL_SetUserCmdValue( args[1], VMF(2) );
+            return 0;
+        case CG_MEMORY_REMAINING:
+            return Hunk_MemoryRemaining();
+        case CG_KEY_ISDOWN:
+            return Key_IsDown( args[1] );
+        case CG_KEY_GETCATCHER:
+            return Key_GetCatcher();
+        case CG_KEY_SETCATCHER:
+            // don't allow the cgame module to toggle the console
+            Key_SetCatcher( ( args[1] & ~KEYCATCH_CONSOLE ) | ( Key_GetCatcher() & KEYCATCH_CONSOLE ) );
+            return 0;
+        case CG_KEY_GETKEY:
+            return Key_GetKey( (const char*)VMA(1) );
+
+        case CG_GETDEMOSTATE:
+            return CL_DemoState( );
+        case CG_GETDEMOPOS:
+            return CL_DemoPos( );
+        case CG_GETDEMONAME:
+            CL_DemoName( (char*)VMA(1), args[2] );
+            return 0;
+
+        case CG_KEY_KEYNUMTOSTRINGBUF:
+            Key_KeynumToStringBuf( args[1], (char*)VMA(2), args[3] );
+            return 0;
+        case CG_KEY_GETBINDINGBUF:
+            Key_GetBindingBuf( args[1], (char*)VMA(2), args[3] );
+            return 0;
+        case CG_KEY_SETBINDING:
+            Key_SetBinding( args[1], (const char*)VMA(2) );
+            return 0;
+
+        case CG_PARSE_ADD_GLOBAL_DEFINE:
+            return Parse_AddGlobalDefine( (char*)VMA(1) );
+        case CG_PARSE_LOAD_SOURCE:
+            return Parse_LoadSourceHandle( (const char*)VMA(1) );
+        case CG_PARSE_FREE_SOURCE:
+            return Parse_FreeSourceHandle( args[1] );
+        case CG_PARSE_READ_TOKEN:
+            return Parse_ReadTokenHandle( args[1], (pc_token_t*)VMA(2) );
+        case CG_PARSE_SOURCE_FILE_AND_LINE:
+            return Parse_SourceFileAndLine( args[1], (char*)VMA(2), (int*)VMA(3) );
+
+        case CG_KEY_SETOVERSTRIKEMODE:
+            Key_SetOverstrikeMode( (bool)args[1] );
+            return 0;
+
+        case CG_KEY_GETOVERSTRIKEMODE:
+            return Key_GetOverstrikeMode( );
+
+        case CG_FIELD_COMPLETELIST:
+            Field_CompleteList( (char*)VMA(1) );
+            return 0;
+
+        case CG_MEMSET:
+            ::memset( VMA(1), args[2], args[3] );
+            return 0;
+        case CG_MEMCPY:
+            ::memcpy( VMA(1), VMA(2), args[3] );
+            return 0;
+        case CG_STRNCPY:
+            safe_strncpy( (char*)VMA(1), (const char*)VMA(2), args[3] );
+            return args[1];
+        case CG_SIN:
+            return FloatAsInt( sin( VMF(1) ) );
+        case CG_COS:
+            return FloatAsInt( cos( VMF(1) ) );
+        case CG_ATAN2:
+            return FloatAsInt( atan2( VMF(1), VMF(2) ) );
+        case CG_SQRT:
+            return FloatAsInt( sqrt( VMF(1) ) );
+        case CG_FLOOR:
+            return FloatAsInt( floor( VMF(1) ) );
+        case CG_CEIL:
+            return FloatAsInt( ceil( VMF(1) ) );
+        case CG_ACOS:
+            return FloatAsInt( Q_acos( VMF(1) ) );
+
+        case CG_S_STOPBACKGROUNDTRACK:
+            S_StopBackgroundTrack();
+            return 0;
+
+        case CG_REAL_TIME:
+            return Com_RealTime( (qtime_t*)VMA(1) );
+        case CG_SNAPVECTOR:
+            Q_SnapVector((float*)VMA(1));
+            return 0;
+
+        case CG_CIN_PLAYCINEMATIC:
+            return CIN_PlayCinematic((const char*)VMA(1), args[2], args[3], args[4], args[5], args[6]);
+
+        case CG_CIN_STOPCINEMATIC:
+            return CIN_StopCinematic(args[1]);
+
+        case CG_CIN_RUNCINEMATIC:
+            return CIN_RunCinematic(args[1]);
+
+        case CG_CIN_DRAWCINEMATIC:
+            CIN_DrawCinematic(args[1]);
+            return 0;
+
+        case CG_CIN_SETEXTENTS:
+            CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
+            return 0;
+
+        case CG_R_REMAP_SHADER:
+            re.RemapShader( (const char*)VMA(1), (const char*)VMA(2), (const char*)VMA(3) );
+            return 0;
+
+        case CG_GET_ENTITY_TOKEN:
+            return re.GetEntityToken( (char*)VMA(1), args[2] );
+        case CG_R_INPVS:
+            return re.inPVS( (const float*)VMA(1), (const float*)VMA(2) );
+
+        default:
+            assert(0);
+            Com_Error( ERR_DROP, "Bad cgame system trap: %ld", (long int) args[0] );
+    }
+	return 0;
+}
+
+
+/*
+====================
+CL_InitCGame
+
+Should only be called by CL_StartHunkUsers
+====================
+*/
+void CL_InitCGame( void ) {
+	const char			*info;
+	const char			*mapname;
+	int					t1, t2;
+	char				backup[ MAX_STRING_CHARS ];
+	vmInterpret_t		interpret;
+
+	t1 = Sys_Milliseconds();
+
+	// find the current mapname
+	info = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SERVERINFO ];
+	mapname = Info_ValueForKey( info, "mapname" );
+	Com_sprintf( cl.mapname, sizeof( cl.mapname ), "maps/%s.bsp", mapname );
+
+	// load the dll or bytecode
+	interpret = (vmInterpret_t)Cvar_VariableValue("vm_cgame");
+	if(cl_connectedToPureServer)
+	{
+		// if sv_pure is set we only allow qvms to be loaded
+		if(interpret != VMI_COMPILED && interpret != VMI_BYTECODE)
+			interpret = VMI_COMPILED;
+	}
+
+	cls.cgame = VM_Create( "cgame", CL_CgameSystemCalls, interpret );
+	if ( !cls.cgame ) {
+		Com_Error( ERR_DROP, "VM_Create on cgame failed" );
+	}
+	clc.state = CA_LOADING;
+
+	Cvar_VariableStringBuffer( "cl_voipSendTarget", backup, sizeof( backup ) );
+	Cvar_Set( "cl_voipSendTarget", "" );
+
+    // Probe 1.1 or gpp cgame
+	cls.cgInterface = 0;
+	probingCG = true;
+    VM_Call( cls.cgame, CG_VOIP_STRING );
+	probingCG = false;
+
+	Cvar_Set( "cl_voipSendTarget", backup );
+
+	if ( ( clc.netchan.alternateProtocol == 2 ) != ( cls.cgInterface == 2 ) ) {
+		Com_Error( ERR_DROP, "%s protocol %i, but a cgame module using the %s interface was found",
+		           ( clc.demoplaying ? "Demo was recorded using" : "Server uses" ),
+		           ( clc.netchan.alternateProtocol == 0 ? PROTOCOL_VERSION : clc.netchan.alternateProtocol == 1 ? 70 : 69 ),
+		           ( cls.cgInterface == 2 ? "1.1" : "non-1.1" ) );
+	}
+
+	// init for this gamestate
+	// use the lastExecutedServerCommand instead of the serverCommandSequence
+	// otherwise server commands sent just before a gamestate are dropped
+	VM_Call( cls.cgame, CG_INIT, clc.serverMessageSequence, clc.lastExecutedServerCommand, clc.clientNum );
+
+	// reset any CVAR_CHEAT cvars registered by cgame
+	if ( !clc.demoplaying && !cl_connectedToCheatServer )
+		Cvar_SetCheatState();
+
+	// we will send a usercmd this frame, which
+	// will cause the server to send us the first snapshot
+	clc.state = CA_PRIMED;
+
+	t2 = Sys_Milliseconds();
+
+	Com_Printf( "CL_InitCGame: %5.2f seconds\n", (t2-t1)/1000.0 );
+
+	// have the renderer touch all its images, so they are present
+	// on the card even if the driver does deferred loading
+	re.EndRegistration();
+
+	// make sure everything is paged in
+	if (!Sys_LowPhysicalMemory()) {
+		Com_TouchMemory();
+
+	CL_ProtocolSpecificCommandsInit();
+	}
+
+	// clear anything that got printed
+	Con_ClearNotify ();
+}
+
+
+/*
+====================
+CL_GameCommand
+
+See if the current console command is claimed by the cgame
+====================
+*/
+bool CL_GameCommand( void )
+{
+	if ( !cls.cgame )
+		return false;
+
+	return (bool)VM_Call( cls.cgame, CG_CONSOLE_COMMAND );
+}
+
+/*
+====================
+CL_GameConsoleText
+====================
+*/
+void CL_GameConsoleText( void )
+{
+	if ( !cls.cgame )
+		return;
+
+	VM_Call( cls.cgame, CG_CONSOLE_TEXT );
+}
+
+/*
+=====================
+CL_CGameRendering
+=====================
+*/
+void CL_CGameRendering( stereoFrame_t stereo )
+{
+	VM_Call( cls.cgame, CG_DRAW_ACTIVE_FRAME, cl.serverTime, stereo, clc.demoplaying );
+	VM_Debug( 0 );
+}
+
+
+/*
+=================
+CL_AdjustTimeDelta
+
+Adjust the clients view of server time.
+
+We attempt to have cl.serverTime exactly equal the server's view
+of time plus the timeNudge, but with variable latencies over
+the internet it will often need to drift a bit to match conditions.
+
+Our ideal time would be to have the adjusted time approach, but not pass,
+the very latest snapshot.
+
+Adjustments are only made when a new snapshot arrives with a rational
+latency, which keeps the adjustment process framerate independent and
+prevents massive overadjustment during times of significant packet loss
+or bursted delayed packets.
+=================
+*/
+
+#define	RESET_TIME	500
+
+void CL_AdjustTimeDelta( void ) {
+	int		newDelta;
+	int		deltaDelta;
+
+	cl.newSnapshots = false;
+
+	// the delta never drifts when replaying a demo
+	if ( clc.demoplaying ) {
+		return;
+	}
+
+	newDelta = cl.snap.serverTime - cls.realtime;
+	deltaDelta = abs( newDelta - cl.serverTimeDelta );
+
+	if ( deltaDelta > RESET_TIME ) {
+		cl.serverTimeDelta = newDelta;
+		cl.oldServerTime = cl.snap.serverTime;	// FIXME: is this a problem for cgame?
+		cl.serverTime = cl.snap.serverTime;
+		if ( cl_showTimeDelta->integer ) {
+			Com_Printf( "<RESET> " );
+		}
+	} else if ( deltaDelta > 100 ) {
+		// fast adjust, cut the difference in half
+		if ( cl_showTimeDelta->integer ) {
+			Com_Printf( "<FAST> " );
+		}
+		cl.serverTimeDelta = ( cl.serverTimeDelta + newDelta ) >> 1;
+	} else {
+		// slow drift adjust, only move 1 or 2 msec
+
+		// if any of the frames between this and the previous snapshot
+		// had to be extrapolated, nudge our sense of time back a little
+		// the granularity of +1 / -2 is too high for timescale modified frametimes
+		if ( com_timescale->value == 0 || com_timescale->value == 1 ) {
+			if ( cl.extrapolatedSnapshot ) {
+				cl.extrapolatedSnapshot = false;
+				cl.serverTimeDelta -= 2;
+			} else {
+				// otherwise, move our sense of time forward to minimize total latency
+				cl.serverTimeDelta++;
+			}
+		}
+	}
+
+	if ( cl_showTimeDelta->integer ) {
+		Com_Printf( "%i ", cl.serverTimeDelta );
+	}
+}
+
+
+/*
+==================
+CL_FirstSnapshot
+==================
+*/
+void CL_FirstSnapshot( void ) {
+	// ignore snapshots that don't have entities
+	if ( cl.snap.snapFlags & SNAPFLAG_NOT_ACTIVE ) {
+		return;
+	}
+	clc.state = CA_ACTIVE;
+
+	// set the timedelta so we are exactly on this first frame
+	cl.serverTimeDelta = cl.snap.serverTime - cls.realtime;
+	cl.oldServerTime = cl.snap.serverTime;
+
+	clc.timeDemoBaseTime = cl.snap.serverTime;
+
+	// if this is the first frame of active play,
+	// execute the contents of activeAction now
+	// this is to allow scripting a timedemo to start right
+	// after loading
+	if ( cl_activeAction->string[0] ) {
+		Cbuf_AddText( cl_activeAction->string );
+		Cvar_Set( "activeAction", "" );
+	}
+
+#ifdef USE_MUMBLE
+	if ((cl_useMumble->integer) && !mumble_islinked()) {
+		int ret = mumble_link(CLIENT_WINDOW_TITLE);
+		Com_Printf("Mumble: Linking to Mumble application %s\n", ret==0?"ok":"failed");
+	}
+#endif
+
+#ifdef USE_VOIP
+	if (!clc.voipCodecInitialized) {
+		int i;
+		int error;
+
+		clc.opusEncoder = opus_encoder_create(48000, 1, OPUS_APPLICATION_VOIP, &error);
+
+		if ( error ) {
+			Com_DPrintf("VoIP: Error opus_encoder_create %d\n", error);
+			return;
+		}
+
+		for (i = 0; i < MAX_CLIENTS; i++) {
+			clc.opusDecoder[i] = opus_decoder_create(48000, 1, &error);
+			if ( error ) {
+				Com_DPrintf("VoIP: Error opus_decoder_create(%d) %d\n", i, error);
+				return;
+			}
+			clc.voipIgnore[i] = false;
+			clc.voipGain[i] = 1.0f;
+		}
+		clc.voipCodecInitialized = true;
+		clc.voipMuteAll = false;
+		Cmd_AddCommand ("voip", CL_Voip_f);
+		Cvar_Set("cl_voipSendTarget", "spatial");
+		::memset(clc.voipTargets, ~0, sizeof(clc.voipTargets));
+	}
+#endif
+}
+
+/*
+==================
+CL_SetCGameTime
+==================
+*/
+void CL_SetCGameTime( void ) {
+	// getting a valid frame message ends the connection process
+	if ( clc.state != CA_ACTIVE ) {
+		if ( clc.state != CA_PRIMED ) {
+			return;
+		}
+		if ( clc.demoplaying ) {
+			// we shouldn't get the first snapshot on the same frame
+			// as the gamestate, because it causes a bad time skip
+			if ( !clc.firstDemoFrameSkipped ) {
+				clc.firstDemoFrameSkipped = true;
+				return;
+			}
+			CL_ReadDemoMessage();
+		}
+		if ( cl.newSnapshots ) {
+			cl.newSnapshots = false;
+			CL_FirstSnapshot();
+		}
+		if ( clc.state != CA_ACTIVE ) {
+			return;
+		}
+	}	
+
+	// if we have gotten to this point, cl.snap is guaranteed to be valid
+	if ( !cl.snap.valid ) {
+		Com_Error( ERR_DROP, "CL_SetCGameTime: !cl.snap.valid" );
+	}
+
+	// allow pause in single player
+	if ( sv_paused->integer && CL_CheckPaused() && com_sv_running->integer ) {
+		// paused
+		return;
+	}
+
+	if ( cl.snap.serverTime < cl.oldFrameServerTime ) {
+		Com_Error( ERR_DROP, "cl.snap.serverTime < cl.oldFrameServerTime" );
+	}
+	cl.oldFrameServerTime = cl.snap.serverTime;
+
+
+	// get our current view of time
+
+	if ( clc.demoplaying && cl_freezeDemo->integer ) {
+		// cl_freezeDemo is used to lock a demo in place for single frame advances
+
+	} else {
+		// cl_timeNudge is a user adjustable cvar that allows more
+		// or less latency to be added in the interest of better 
+		// smoothness or better responsiveness.
+		int tn;
+		
+		tn = cl_timeNudge->integer;
+		if (tn<-30) {
+			tn = -30;
+		} else if (tn>30) {
+			tn = 30;
+		}
+
+		cl.serverTime = cls.realtime + cl.serverTimeDelta - tn;
+
+		// guarantee that time will never flow backwards, even if
+		// serverTimeDelta made an adjustment or cl_timeNudge was changed
+		if ( cl.serverTime < cl.oldServerTime ) {
+			cl.serverTime = cl.oldServerTime;
+		}
+		cl.oldServerTime = cl.serverTime;
+
+		// note if we are almost past the latest frame (without timeNudge),
+		// so we will try and adjust back a bit when the next snapshot arrives
+		if ( cls.realtime + cl.serverTimeDelta >= cl.snap.serverTime - 5 ) {
+			cl.extrapolatedSnapshot = true;
+		}
+	}
+
+	// if we have gotten new snapshots, drift serverTimeDelta
+	// don't do this every frame, or a period of packet loss would
+	// make a huge adjustment
+	if ( cl.newSnapshots ) {
+		CL_AdjustTimeDelta();
+	}
+
+	if ( !clc.demoplaying ) {
+		return;
+	}
+
+	// if we are playing a demo back, we can just keep reading
+	// messages from the demo file until the cgame definately
+	// has valid snapshots to interpolate between
+
+	// a timedemo will always use a deterministic set of time samples
+	// no matter what speed machine it is run on,
+	// while a normal demo may have different time samples
+	// each time it is played back
+	if ( cl_timedemo->integer ) {
+		int now = Sys_Milliseconds( );
+		int frameDuration;
+
+		if (!clc.timeDemoStart) {
+			clc.timeDemoStart = clc.timeDemoLastFrame = now;
+			clc.timeDemoMinDuration = INT_MAX;
+			clc.timeDemoMaxDuration = 0;
+		}
+
+		frameDuration = now - clc.timeDemoLastFrame;
+		clc.timeDemoLastFrame = now;
+
+		// Ignore the first measurement as it'll always be 0
+		if( clc.timeDemoFrames > 0 )
+		{
+			if( frameDuration > clc.timeDemoMaxDuration )
+				clc.timeDemoMaxDuration = frameDuration;
+
+			if( frameDuration < clc.timeDemoMinDuration )
+				clc.timeDemoMinDuration = frameDuration;
+
+			// 255 ms = about 4fps
+			if( frameDuration > UCHAR_MAX )
+				frameDuration = UCHAR_MAX;
+
+			clc.timeDemoDurations[ ( clc.timeDemoFrames - 1 ) %
+				MAX_TIMEDEMO_DURATIONS ] = frameDuration;
+		}
+
+		clc.timeDemoFrames++;
+		cl.serverTime = clc.timeDemoBaseTime + clc.timeDemoFrames * 50;
+	}
+
+	while ( cl.serverTime >= cl.snap.serverTime ) {
+		// feed another messag, which should change
+		// the contents of cl.snap
+		CL_ReadDemoMessage();
+		if ( clc.state != CA_ACTIVE ) {
+			return;		// end of demo
+		}
+	}
+}
diff --git a/src/client/cl_cin.cpp b/src/client/cl_cin.cpp
new file mode 100644
index 0000000..6326e89
--- /dev/null
+++ b/src/client/cl_cin.cpp
@@ -0,0 +1,1937 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+/*****************************************************************************
+ * name:		cl_cin.c
+ *
+ * desc:		video and cinematic playback
+ *
+ * $Archive: /MissionPack/code/client/cl_cin.c $
+ *
+ * cl_glconfig.hwtype trtypes 3dfx/ragepro need 256x256
+ *
+ *****************************************************************************/
+
+#include "client.h"
+#include "snd_local.h"
+
+#define MAXSIZE             8
+#define MINSIZE             4
+
+#define DEFAULT_CIN_WIDTH   512
+#define DEFAULT_CIN_HEIGHT  512
+
+#define ROQ_QUAD        0x1000
+#define ROQ_QUAD_INFO   0x1001
+#define ROQ_CODEBOOK    0x1002
+#define ROQ_QUAD_VQ     0x1011
+#define ROQ_QUAD_JPEG   0x1012
+#define ROQ_QUAD_HANG   0x1013
+#define ROQ_PACKET      0x1030
+#define ZA_SOUND_MONO   0x1020
+#define ZA_SOUND_STEREO 0x1021
+
+#define MAX_VIDEO_HANDLES 16
+
+static void RoQ_init(void);
+
+/******************************************************************************
+*
+* Class:		trFMV
+*
+* Description:	RoQ/RnR manipulation routines
+*				not entirely complete for first run
+*
+******************************************************************************/
+
+static long ROQ_YY_tab[256];
+static long ROQ_UB_tab[256];
+static long ROQ_UG_tab[256];
+static long ROQ_VG_tab[256];
+static long ROQ_VR_tab[256];
+static unsigned short vq2[256 * 16 * 4];
+static unsigned short vq4[256 * 64 * 4];
+static unsigned short vq8[256 * 256 * 4];
+
+struct cinematics_t
+{
+    byte linbuf[DEFAULT_CIN_WIDTH * DEFAULT_CIN_HEIGHT * 4 * 2];
+    byte file[65536];
+    short sqrTable[256];
+
+    int mcomp[256];
+    byte *qStatus[2][32768];
+
+    long oldXOff;
+    long oldYOff;
+    long oldysize;
+    long oldxsize;
+
+    int currentHandle;
+};
+
+struct cin_cache
+{
+    char fileName[MAX_OSPATH];
+
+    int CIN_WIDTH;
+    int CIN_HEIGHT;
+
+    int xpos;
+    int ypos;
+    int width;
+    int height;
+
+    bool looping;
+    bool holdAtEnd; 
+    bool dirty;
+    bool alterGameState;
+    bool silent;
+    bool shader;
+
+    fileHandle_t iFile;
+    e_status status;
+
+    int startTime;
+    int lastTime;
+    long tfps;
+    long RoQPlayed;
+    long ROQSize;
+    unsigned int RoQFrameSize;
+    long onQuad;
+    long numQuads;
+    long samplesPerLine;
+    unsigned int roq_id;
+    long screenDelta;
+
+    void (*VQ0)(byte *status, void *qdata);
+    void (*VQ1)(byte *status, void *qdata);
+    void (*VQNormal)(byte *status, void *qdata);
+    void (*VQBuffer)(byte *status, void *qdata);
+
+    long samplesPerPixel;  // defaults to 2
+    byte *gray;
+    unsigned int xsize, ysize, maxsize, minsize;
+
+    bool half;
+    bool smootheddouble;
+    bool inMemory;
+    long normalBuffer0;
+    long roq_flags;
+    long roqF0;
+    long roqF1;
+    long t[2];
+    long roqFPS;
+    int playonwalls;
+    byte *buf;
+    long drawX;
+    long drawY;
+};
+
+static cinematics_t cin;
+static cin_cache cinTable[MAX_VIDEO_HANDLES];
+static int currentHandle = -1;
+static int CL_handle = -1;
+
+extern int s_soundtime;  // sample PAIRS
+
+void CIN_CloseAllVideos(void)
+{
+    int i;
+
+    for (i = 0; i < MAX_VIDEO_HANDLES; i++)
+    {
+        if (cinTable[i].fileName[0] != 0)
+        {
+            CIN_StopCinematic(i);
+        }
+    }
+}
+
+static int CIN_HandleForVideo(void)
+{
+    int i;
+
+    for (i = 0; i < MAX_VIDEO_HANDLES; i++)
+    {
+        if (cinTable[i].fileName[0] == 0)
+        {
+            return i;
+        }
+    }
+    Com_Error(ERR_DROP, "CIN_HandleForVideo: none free");
+    return -1;
+}
+
+//-----------------------------------------------------------------------------
+// RllSetupTable
+//
+// Allocates and initializes the square table.
+//
+// Parameters:	None
+//
+// Returns:		Nothing
+//-----------------------------------------------------------------------------
+static void RllSetupTable(void)
+{
+    int z;
+
+    for (z = 0; z < 128; z++)
+    {
+        cin.sqrTable[z] = (short)(z * z);
+        cin.sqrTable[z + 128] = (short)(-cin.sqrTable[z]);
+    }
+}
+
+#if 0
+//-----------------------------------------------------------------------------
+// RllDecodeMonoToMono
+//
+// Decode mono source data into a mono buffer.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= # of shorts of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+long RllDecodeMonoToMono(unsigned char *from, short *to, unsigned int size, char signedOutput, unsigned short flag)
+{
+    unsigned int z;
+    int prev;
+
+    if (signedOutput)
+        prev = flag - 0x8000;
+    else
+        prev = flag;
+
+    for (z = 0; z < size; z++)
+    {
+        prev = to[z] = (short)(prev + cin.sqrTable[from[z]]);
+    }
+    return size;  //*sizeof(short));
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// RllDecodeMonoToStereo
+//
+// Decode mono source data into a stereo buffer. Output is 4 times the number
+// of bytes in the input.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= 1/4 # of bytes of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+static long RllDecodeMonoToStereo(unsigned char *from, short *to, unsigned int size, char signedOutput, unsigned short flag)
+{
+    unsigned int z;
+    int prev;
+
+    if (signedOutput)
+        prev = flag - 0x8000;
+    else
+        prev = flag;
+
+    for (z = 0; z < size; z++)
+    {
+        prev = (short)(prev + cin.sqrTable[from[z]]);
+        to[z * 2 + 0] = to[z * 2 + 1] = (short)(prev);
+    }
+
+    return size;  // * 2 * sizeof(short));
+}
+
+//-----------------------------------------------------------------------------
+// RllDecodeStereoToStereo
+//
+// Decode stereo source data into a stereo buffer.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= 1/2 # of bytes of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+static long RllDecodeStereoToStereo(unsigned char *from, short *to, unsigned int size, char signedOutput, unsigned short flag)
+{
+    unsigned int z;
+    unsigned char *zz = from;
+    int prevL, prevR;
+
+    if (signedOutput)
+    {
+        prevL = (flag & 0xff00) - 0x8000;
+        prevR = ((flag & 0x00ff) << 8) - 0x8000;
+    }
+    else
+    {
+        prevL = flag & 0xff00;
+        prevR = (flag & 0x00ff) << 8;
+    }
+
+    for (z = 0; z < size; z += 2)
+    {
+        prevL = (short)(prevL + cin.sqrTable[*zz++]);
+        prevR = (short)(prevR + cin.sqrTable[*zz++]);
+        to[z + 0] = (short)(prevL);
+        to[z + 1] = (short)(prevR);
+    }
+
+    return (size >> 1);  //*sizeof(short));
+}
+
+#if 0
+//-----------------------------------------------------------------------------
+// RllDecodeStereoToMono
+//
+// Decode stereo source data into a mono buffer.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= # of bytes of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+long RllDecodeStereoToMono(unsigned char *from, short *to, unsigned int size, char signedOutput, unsigned short flag)
+{
+    unsigned int z;
+    int prevL, prevR;
+
+    if (signedOutput)
+    {
+        prevL = (flag & 0xff00) - 0x8000;
+        prevR = ((flag & 0x00ff) << 8) - 0x8000;
+    }
+    else
+    {
+        prevL = flag & 0xff00;
+        prevR = (flag & 0x00ff) << 8;
+    }
+
+    for (z = 0; z < size; z += 1)
+    {
+        prevL = prevL + cin.sqrTable[from[z * 2]];
+        prevR = prevR + cin.sqrTable[from[z * 2 + 1]];
+        to[z] = (short)((prevL + prevR) / 2);
+    }
+
+    return size;
+}
+#endif
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void move8_32(byte *src, byte *dst, int spl)
+{
+    int i;
+
+    for (i = 0; i < 8; ++i)
+    {
+        memcpy(dst, src, 32);
+        src += spl;
+        dst += spl;
+    }
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void move4_32(byte *src, byte *dst, int spl)
+{
+    int i;
+
+    for (i = 0; i < 4; ++i)
+    {
+        memcpy(dst, src, 16);
+        src += spl;
+        dst += spl;
+    }
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void blit8_32(byte *src, byte *dst, int spl)
+{
+    int i;
+
+    for (i = 0; i < 8; ++i)
+    {
+        memcpy(dst, src, 32);
+        src += 32;
+        dst += spl;
+    }
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+static void blit4_32(byte *src, byte *dst, int spl)
+{
+    int i;
+
+    for (i = 0; i < 4; ++i)
+    {
+        memmove(dst, src, 16);
+        src += 16;
+        dst += spl;
+    }
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void blit2_32(byte *src, byte *dst, int spl)
+{
+    memcpy(dst, src, 8);
+    memcpy(dst + spl, src + 8, 8);
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void blitVQQuad32fs(byte **status, unsigned char *data)
+{
+    unsigned short newd, celdata, code;
+    unsigned int index, i;
+    int spl;
+
+    newd = 0;
+    celdata = 0;
+    index = 0;
+
+    spl = cinTable[currentHandle].samplesPerLine;
+
+    do
+    {
+        if (!newd)
+        {
+            newd = 7;
+            celdata = data[0] + data[1] * 256;
+            data += 2;
+        }
+        else
+        {
+            newd--;
+        }
+
+        code = (unsigned short)(celdata & 0xc000);
+        celdata <<= 2;
+
+        switch (code)
+        {
+            case 0x8000:  // vq code
+                blit8_32((byte *)&vq8[(*data) * 128], status[index], spl);
+                data++;
+                index += 5;
+                break;
+            case 0xc000:  // drop
+                index++;  // skip 8x8
+                for (i = 0; i < 4; i++)
+                {
+                    if (!newd)
+                    {
+                        newd = 7;
+                        celdata = data[0] + data[1] * 256;
+                        data += 2;
+                    }
+                    else
+                    {
+                        newd--;
+                    }
+
+                    code = (unsigned short)(celdata & 0xc000);
+                    celdata <<= 2;
+
+                    switch (code)
+                    {  // code in top two bits of code
+                        case 0x8000:  // 4x4 vq code
+                            blit4_32((byte *)&vq4[(*data) * 32], status[index], spl);
+                            data++;
+                            break;
+                        case 0xc000:  // 2x2 vq code
+                            blit2_32((byte *)&vq2[(*data) * 8], status[index], spl);
+                            data++;
+                            blit2_32((byte *)&vq2[(*data) * 8], status[index] + 8, spl);
+                            data++;
+                            blit2_32((byte *)&vq2[(*data) * 8], status[index] + spl * 2, spl);
+                            data++;
+                            blit2_32((byte *)&vq2[(*data) * 8], status[index] + spl * 2 + 8, spl);
+                            data++;
+                            break;
+                        case 0x4000:  // motion compensation
+                            move4_32(status[index] + cin.mcomp[(*data)], status[index], spl);
+                            data++;
+                            break;
+                    }
+                    index++;
+                }
+                break;
+            case 0x4000:  // motion compensation
+                move8_32(status[index] + cin.mcomp[(*data)], status[index], spl);
+                data++;
+                index += 5;
+                break;
+            case 0x0000:
+                index += 5;
+                break;
+        }
+    } while (status[index] != NULL);
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void ROQ_GenYUVTables(void)
+{
+    float t_ub, t_vr, t_ug, t_vg;
+    long i;
+
+    t_ub = (1.77200f / 2.0f) * (float)(1 << 6) + 0.5f;
+    t_vr = (1.40200f / 2.0f) * (float)(1 << 6) + 0.5f;
+    t_ug = (0.34414f / 2.0f) * (float)(1 << 6) + 0.5f;
+    t_vg = (0.71414f / 2.0f) * (float)(1 << 6) + 0.5f;
+    for (i = 0; i < 256; i++)
+    {
+        float x = (float)(2 * i - 255);
+
+        ROQ_UB_tab[i] = (long)((t_ub * x) + (1 << 5));
+        ROQ_VR_tab[i] = (long)((t_vr * x) + (1 << 5));
+        ROQ_UG_tab[i] = (long)((-t_ug * x));
+        ROQ_VG_tab[i] = (long)((-t_vg * x) + (1 << 5));
+        ROQ_YY_tab[i] = (long)((i << 6) | (i >> 2));
+    }
+}
+
+#define VQ2TO4(a, b, c, d) \
+    {                      \
+        *c++ = a[0];       \
+        *d++ = a[0];       \
+        *d++ = a[0];       \
+        *c++ = a[1];       \
+        *d++ = a[1];       \
+        *d++ = a[1];       \
+        *c++ = b[0];       \
+        *d++ = b[0];       \
+        *d++ = b[0];       \
+        *c++ = b[1];       \
+        *d++ = b[1];       \
+        *d++ = b[1];       \
+        *d++ = a[0];       \
+        *d++ = a[0];       \
+        *d++ = a[1];       \
+        *d++ = a[1];       \
+        *d++ = b[0];       \
+        *d++ = b[0];       \
+        *d++ = b[1];       \
+        *d++ = b[1];       \
+        a += 2;            \
+        b += 2;            \
+    }
+
+#define VQ2TO2(a, b, c, d) \
+    {                      \
+        *c++ = *a;         \
+        *d++ = *a;         \
+        *d++ = *a;         \
+        *c++ = *b;         \
+        *d++ = *b;         \
+        *d++ = *b;         \
+        *d++ = *a;         \
+        *d++ = *a;         \
+        *d++ = *b;         \
+        *d++ = *b;         \
+        a++;               \
+        b++;               \
+    }
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static unsigned short yuv_to_rgb(long y, long u, long v)
+{
+    long r, g, b, YY = (long)(ROQ_YY_tab[(y)]);
+
+    r = (YY + ROQ_VR_tab[v]) >> 9;
+    g = (YY + ROQ_UG_tab[u] + ROQ_VG_tab[v]) >> 8;
+    b = (YY + ROQ_UB_tab[u]) >> 9;
+
+    if (r < 0) r = 0;
+    if (g < 0) g = 0;
+    if (b < 0) b = 0;
+    if (r > 31) r = 31;
+    if (g > 63) g = 63;
+    if (b > 31) b = 31;
+
+    return (unsigned short)((r << 11) + (g << 5) + (b));
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+static unsigned int yuv_to_rgb24(long y, long u, long v)
+{
+    long r, g, b, YY = (long)(ROQ_YY_tab[(y)]);
+
+    r = (YY + ROQ_VR_tab[v]) >> 6;
+    g = (YY + ROQ_UG_tab[u] + ROQ_VG_tab[v]) >> 6;
+    b = (YY + ROQ_UB_tab[u]) >> 6;
+
+    if (r < 0) r = 0;
+    if (g < 0) g = 0;
+    if (b < 0) b = 0;
+    if (r > 255) r = 255;
+    if (g > 255) g = 255;
+    if (b > 255) b = 255;
+
+    return LittleLong((r) | (g << 8) | (b << 16) | (255 << 24));
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void decodeCodeBook(byte *input, unsigned short roq_flags)
+{
+    long i, j, two, four;
+    unsigned short *aptr, *bptr, *cptr, *dptr;
+    long y0, y1, y2, y3, cr, cb;
+    byte *bbptr, *baptr, *bcptr, *bdptr;
+    union {
+        unsigned int *i;
+        unsigned short *s;
+    } iaptr, ibptr, icptr, idptr;
+
+    if (!roq_flags)
+    {
+        two = four = 256;
+    }
+    else
+    {
+        two = roq_flags >> 8;
+        if (!two) two = 256;
+        four = roq_flags & 0xff;
+    }
+
+    four *= 2;
+
+    bptr = (unsigned short *)vq2;
+
+    if (!cinTable[currentHandle].half)
+    {
+        if (!cinTable[currentHandle].smootheddouble)
+        {
+            //
+            // normal height
+            //
+            if (cinTable[currentHandle].samplesPerPixel == 2)
+            {
+                for (i = 0; i < two; i++)
+                {
+                    y0 = (long)*input++;
+                    y1 = (long)*input++;
+                    y2 = (long)*input++;
+                    y3 = (long)*input++;
+                    cr = (long)*input++;
+                    cb = (long)*input++;
+                    *bptr++ = yuv_to_rgb(y0, cr, cb);
+                    *bptr++ = yuv_to_rgb(y1, cr, cb);
+                    *bptr++ = yuv_to_rgb(y2, cr, cb);
+                    *bptr++ = yuv_to_rgb(y3, cr, cb);
+                }
+
+                cptr = (unsigned short *)vq4;
+                dptr = (unsigned short *)vq8;
+
+                for (i = 0; i < four; i++)
+                {
+                    aptr = (unsigned short *)vq2 + (*input++) * 4;
+                    bptr = (unsigned short *)vq2 + (*input++) * 4;
+                    for (j = 0; j < 2; j++) VQ2TO4(aptr, bptr, cptr, dptr);
+                }
+            }
+            else if (cinTable[currentHandle].samplesPerPixel == 4)
+            {
+                ibptr.s = bptr;
+                for (i = 0; i < two; i++)
+                {
+                    y0 = (long)*input++;
+                    y1 = (long)*input++;
+                    y2 = (long)*input++;
+                    y3 = (long)*input++;
+                    cr = (long)*input++;
+                    cb = (long)*input++;
+                    *ibptr.i++ = yuv_to_rgb24(y0, cr, cb);
+                    *ibptr.i++ = yuv_to_rgb24(y1, cr, cb);
+                    *ibptr.i++ = yuv_to_rgb24(y2, cr, cb);
+                    *ibptr.i++ = yuv_to_rgb24(y3, cr, cb);
+                }
+
+                icptr.s = vq4;
+                idptr.s = vq8;
+
+                for (i = 0; i < four; i++)
+                {
+                    iaptr.s = vq2;
+                    iaptr.i += (*input++) * 4;
+                    ibptr.s = vq2;
+                    ibptr.i += (*input++) * 4;
+                    for (j = 0; j < 2; j++) VQ2TO4(iaptr.i, ibptr.i, icptr.i, idptr.i);
+                }
+            }
+            else if (cinTable[currentHandle].samplesPerPixel == 1)
+            {
+                bbptr = (byte *)bptr;
+                for (i = 0; i < two; i++)
+                {
+                    *bbptr++ = cinTable[currentHandle].gray[*input++];
+                    *bbptr++ = cinTable[currentHandle].gray[*input++];
+                    *bbptr++ = cinTable[currentHandle].gray[*input++];
+                    *bbptr++ = cinTable[currentHandle].gray[*input];
+                    input += 3;
+                }
+
+                bcptr = (byte *)vq4;
+                bdptr = (byte *)vq8;
+
+                for (i = 0; i < four; i++)
+                {
+                    baptr = (byte *)vq2 + (*input++) * 4;
+                    bbptr = (byte *)vq2 + (*input++) * 4;
+                    for (j = 0; j < 2; j++) VQ2TO4(baptr, bbptr, bcptr, bdptr);
+                }
+            }
+        }
+        else
+        {
+            //
+            // double height, smoothed
+            //
+            if (cinTable[currentHandle].samplesPerPixel == 2)
+            {
+                for (i = 0; i < two; i++)
+                {
+                    y0 = (long)*input++;
+                    y1 = (long)*input++;
+                    y2 = (long)*input++;
+                    y3 = (long)*input++;
+                    cr = (long)*input++;
+                    cb = (long)*input++;
+                    *bptr++ = yuv_to_rgb(y0, cr, cb);
+                    *bptr++ = yuv_to_rgb(y1, cr, cb);
+                    *bptr++ = yuv_to_rgb(((y0 * 3) + y2) / 4, cr, cb);
+                    *bptr++ = yuv_to_rgb(((y1 * 3) + y3) / 4, cr, cb);
+                    *bptr++ = yuv_to_rgb((y0 + (y2 * 3)) / 4, cr, cb);
+                    *bptr++ = yuv_to_rgb((y1 + (y3 * 3)) / 4, cr, cb);
+                    *bptr++ = yuv_to_rgb(y2, cr, cb);
+                    *bptr++ = yuv_to_rgb(y3, cr, cb);
+                }
+
+                cptr = (unsigned short *)vq4;
+                dptr = (unsigned short *)vq8;
+
+                for (i = 0; i < four; i++)
+                {
+                    aptr = (unsigned short *)vq2 + (*input++) * 8;
+                    bptr = (unsigned short *)vq2 + (*input++) * 8;
+                    for (j = 0; j < 2; j++)
+                    {
+                        VQ2TO4(aptr, bptr, cptr, dptr);
+                        VQ2TO4(aptr, bptr, cptr, dptr);
+                    }
+                }
+            }
+            else if (cinTable[currentHandle].samplesPerPixel == 4)
+            {
+                ibptr.s = bptr;
+                for (i = 0; i < two; i++)
+                {
+                    y0 = (long)*input++;
+                    y1 = (long)*input++;
+                    y2 = (long)*input++;
+                    y3 = (long)*input++;
+                    cr = (long)*input++;
+                    cb = (long)*input++;
+                    *ibptr.i++ = yuv_to_rgb24(y0, cr, cb);
+                    *ibptr.i++ = yuv_to_rgb24(y1, cr, cb);
+                    *ibptr.i++ = yuv_to_rgb24(((y0 * 3) + y2) / 4, cr, cb);
+                    *ibptr.i++ = yuv_to_rgb24(((y1 * 3) + y3) / 4, cr, cb);
+                    *ibptr.i++ = yuv_to_rgb24((y0 + (y2 * 3)) / 4, cr, cb);
+                    *ibptr.i++ = yuv_to_rgb24((y1 + (y3 * 3)) / 4, cr, cb);
+                    *ibptr.i++ = yuv_to_rgb24(y2, cr, cb);
+                    *ibptr.i++ = yuv_to_rgb24(y3, cr, cb);
+                }
+
+                icptr.s = vq4;
+                idptr.s = vq8;
+
+                for (i = 0; i < four; i++)
+                {
+                    iaptr.s = vq2;
+                    iaptr.i += (*input++) * 8;
+                    ibptr.s = vq2;
+                    ibptr.i += (*input++) * 8;
+                    for (j = 0; j < 2; j++)
+                    {
+                        VQ2TO4(iaptr.i, ibptr.i, icptr.i, idptr.i);
+                        VQ2TO4(iaptr.i, ibptr.i, icptr.i, idptr.i);
+                    }
+                }
+            }
+            else if (cinTable[currentHandle].samplesPerPixel == 1)
+            {
+                bbptr = (byte *)bptr;
+                for (i = 0; i < two; i++)
+                {
+                    y0 = (long)*input++;
+                    y1 = (long)*input++;
+                    y2 = (long)*input++;
+                    y3 = (long)*input;
+                    input += 3;
+                    *bbptr++ = cinTable[currentHandle].gray[y0];
+                    *bbptr++ = cinTable[currentHandle].gray[y1];
+                    *bbptr++ = cinTable[currentHandle].gray[((y0 * 3) + y2) / 4];
+                    *bbptr++ = cinTable[currentHandle].gray[((y1 * 3) + y3) / 4];
+                    *bbptr++ = cinTable[currentHandle].gray[(y0 + (y2 * 3)) / 4];
+                    *bbptr++ = cinTable[currentHandle].gray[(y1 + (y3 * 3)) / 4];
+                    *bbptr++ = cinTable[currentHandle].gray[y2];
+                    *bbptr++ = cinTable[currentHandle].gray[y3];
+                }
+
+                bcptr = (byte *)vq4;
+                bdptr = (byte *)vq8;
+
+                for (i = 0; i < four; i++)
+                {
+                    baptr = (byte *)vq2 + (*input++) * 8;
+                    bbptr = (byte *)vq2 + (*input++) * 8;
+                    for (j = 0; j < 2; j++)
+                    {
+                        VQ2TO4(baptr, bbptr, bcptr, bdptr);
+                        VQ2TO4(baptr, bbptr, bcptr, bdptr);
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        //
+        // 1/4 screen
+        //
+        if (cinTable[currentHandle].samplesPerPixel == 2)
+        {
+            for (i = 0; i < two; i++)
+            {
+                y0 = (long)*input;
+                input += 2;
+                y2 = (long)*input;
+                input += 2;
+                cr = (long)*input++;
+                cb = (long)*input++;
+                *bptr++ = yuv_to_rgb(y0, cr, cb);
+                *bptr++ = yuv_to_rgb(y2, cr, cb);
+            }
+
+            cptr = (unsigned short *)vq4;
+            dptr = (unsigned short *)vq8;
+
+            for (i = 0; i < four; i++)
+            {
+                aptr = (unsigned short *)vq2 + (*input++) * 2;
+                bptr = (unsigned short *)vq2 + (*input++) * 2;
+                for (j = 0; j < 2; j++)
+                {
+                    VQ2TO2(aptr, bptr, cptr, dptr);
+                }
+            }
+        }
+        else if (cinTable[currentHandle].samplesPerPixel == 1)
+        {
+            bbptr = (byte *)bptr;
+
+            for (i = 0; i < two; i++)
+            {
+                *bbptr++ = cinTable[currentHandle].gray[*input];
+                input += 2;
+                *bbptr++ = cinTable[currentHandle].gray[*input];
+                input += 4;
+            }
+
+            bcptr = (byte *)vq4;
+            bdptr = (byte *)vq8;
+
+            for (i = 0; i < four; i++)
+            {
+                baptr = (byte *)vq2 + (*input++) * 2;
+                bbptr = (byte *)vq2 + (*input++) * 2;
+                for (j = 0; j < 2; j++)
+                {
+                    VQ2TO2(baptr, bbptr, bcptr, bdptr);
+                }
+            }
+        }
+        else if (cinTable[currentHandle].samplesPerPixel == 4)
+        {
+            ibptr.s = bptr;
+            for (i = 0; i < two; i++)
+            {
+                y0 = (long)*input;
+                input += 2;
+                y2 = (long)*input;
+                input += 2;
+                cr = (long)*input++;
+                cb = (long)*input++;
+                *ibptr.i++ = yuv_to_rgb24(y0, cr, cb);
+                *ibptr.i++ = yuv_to_rgb24(y2, cr, cb);
+            }
+
+            icptr.s = vq4;
+            idptr.s = vq8;
+
+            for (i = 0; i < four; i++)
+            {
+                iaptr.s = vq2;
+                iaptr.i += (*input++) * 2;
+                ibptr.s = vq2 + (*input++) * 2;
+                ibptr.i += (*input++) * 2;
+                for (j = 0; j < 2; j++)
+                {
+                    VQ2TO2(iaptr.i, ibptr.i, icptr.i, idptr.i);
+                }
+            }
+        }
+    }
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void recurseQuad(long startX, long startY, long quadSize, long xOff, long yOff)
+{
+    byte *scroff;
+    long bigx, bigy, lowx, lowy, useY;
+    long offset;
+
+    offset = cinTable[currentHandle].screenDelta;
+
+    lowx = lowy = 0;
+    bigx = cinTable[currentHandle].xsize;
+    bigy = cinTable[currentHandle].ysize;
+
+    if (bigx > cinTable[currentHandle].CIN_WIDTH) bigx = cinTable[currentHandle].CIN_WIDTH;
+    if (bigy > cinTable[currentHandle].CIN_HEIGHT) bigy = cinTable[currentHandle].CIN_HEIGHT;
+
+    if ((startX >= lowx) && (startX + quadSize) <= (bigx) && (startY + quadSize) <= (bigy) && (startY >= lowy) &&
+        quadSize <= MAXSIZE)
+    {
+        useY = startY;
+        scroff = cin.linbuf +
+                 (useY + ((cinTable[currentHandle].CIN_HEIGHT - bigy) >> 1) + yOff) *
+                     (cinTable[currentHandle].samplesPerLine) +
+                 (((startX + xOff)) * cinTable[currentHandle].samplesPerPixel);
+
+        cin.qStatus[0][cinTable[currentHandle].onQuad] = scroff;
+        cin.qStatus[1][cinTable[currentHandle].onQuad++] = scroff + offset;
+    }
+
+    if (quadSize != MINSIZE)
+    {
+        quadSize >>= 1;
+        recurseQuad(startX, startY, quadSize, xOff, yOff);
+        recurseQuad(startX + quadSize, startY, quadSize, xOff, yOff);
+        recurseQuad(startX, startY + quadSize, quadSize, xOff, yOff);
+        recurseQuad(startX + quadSize, startY + quadSize, quadSize, xOff, yOff);
+    }
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void setupQuad(long xOff, long yOff)
+{
+    long numQuadCels, i, x, y;
+    byte *temp;
+
+    if (xOff == cin.oldXOff && yOff == cin.oldYOff && cinTable[currentHandle].ysize == cin.oldysize &&
+        cinTable[currentHandle].xsize == cin.oldxsize)
+    {
+        return;
+    }
+
+    cin.oldXOff = xOff;
+    cin.oldYOff = yOff;
+    cin.oldysize = cinTable[currentHandle].ysize;
+    cin.oldxsize = cinTable[currentHandle].xsize;
+
+    numQuadCels = (cinTable[currentHandle].xsize * cinTable[currentHandle].ysize) / (16);
+    numQuadCels += numQuadCels / 4;
+    numQuadCels += 64;  // for overflow
+
+    cinTable[currentHandle].onQuad = 0;
+
+    for (y = 0; y < (long)cinTable[currentHandle].ysize; y += 16)
+        for (x = 0; x < (long)cinTable[currentHandle].xsize; x += 16) recurseQuad(x, y, 16, xOff, yOff);
+
+    temp = NULL;
+
+    for (i = (numQuadCels - 64); i < numQuadCels; i++)
+    {
+        cin.qStatus[0][i] = temp;  // eoq
+        cin.qStatus[1][i] = temp;  // eoq
+    }
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void readQuadInfo(byte *qData)
+{
+    if (currentHandle < 0) return;
+
+    cinTable[currentHandle].xsize = qData[0] + qData[1] * 256;
+    cinTable[currentHandle].ysize = qData[2] + qData[3] * 256;
+    cinTable[currentHandle].maxsize = qData[4] + qData[5] * 256;
+    cinTable[currentHandle].minsize = qData[6] + qData[7] * 256;
+
+    cinTable[currentHandle].CIN_HEIGHT = cinTable[currentHandle].ysize;
+    cinTable[currentHandle].CIN_WIDTH = cinTable[currentHandle].xsize;
+
+    cinTable[currentHandle].samplesPerLine =
+        cinTable[currentHandle].CIN_WIDTH * cinTable[currentHandle].samplesPerPixel;
+    cinTable[currentHandle].screenDelta = cinTable[currentHandle].CIN_HEIGHT * cinTable[currentHandle].samplesPerLine;
+
+    cinTable[currentHandle].half = false;
+    cinTable[currentHandle].smootheddouble = false;
+
+    cinTable[currentHandle].VQ0 = cinTable[currentHandle].VQNormal;
+    cinTable[currentHandle].VQ1 = cinTable[currentHandle].VQBuffer;
+
+    cinTable[currentHandle].t[0] = cinTable[currentHandle].screenDelta;
+    cinTable[currentHandle].t[1] = -cinTable[currentHandle].screenDelta;
+
+    cinTable[currentHandle].drawX = cinTable[currentHandle].CIN_WIDTH;
+    cinTable[currentHandle].drawY = cinTable[currentHandle].CIN_HEIGHT;
+
+    // rage pro is very slow at 512 wide textures, voodoo can't do it at all
+    if (cls.glconfig.hardwareType == GLHW_RAGEPRO || cls.glconfig.maxTextureSize <= 256)
+    {
+        if (cinTable[currentHandle].drawX > 256)
+        {
+            cinTable[currentHandle].drawX = 256;
+        }
+        if (cinTable[currentHandle].drawY > 256)
+        {
+            cinTable[currentHandle].drawY = 256;
+        }
+        if (cinTable[currentHandle].CIN_WIDTH != 256 || cinTable[currentHandle].CIN_HEIGHT != 256)
+        {
+            Com_Printf("HACK: approxmimating cinematic for Rage Pro or Voodoo\n");
+        }
+    }
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void RoQPrepMcomp(long xoff, long yoff)
+{
+    long i, j, x, y, temp, temp2;
+
+    i = cinTable[currentHandle].samplesPerLine;
+    j = cinTable[currentHandle].samplesPerPixel;
+    if (cinTable[currentHandle].xsize == (cinTable[currentHandle].ysize * 4) && !cinTable[currentHandle].half)
+    {
+        j = j + j;
+        i = i + i;
+    }
+
+    for (y = 0; y < 16; y++)
+    {
+        temp2 = (y + yoff - 8) * i;
+        for (x = 0; x < 16; x++)
+        {
+            temp = (x + xoff - 8) * j;
+            cin.mcomp[(x * 16) + y] = cinTable[currentHandle].normalBuffer0 - (temp2 + temp);
+        }
+    }
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void initRoQ(void)
+{
+    if (currentHandle < 0) return;
+
+    cinTable[currentHandle].VQNormal = (void (*)(byte *, void *))blitVQQuad32fs;
+    cinTable[currentHandle].VQBuffer = (void (*)(byte *, void *))blitVQQuad32fs;
+    cinTable[currentHandle].samplesPerPixel = 4;
+    ROQ_GenYUVTables();
+    RllSetupTable();
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+/*
+static byte* RoQFetchInterlaced( byte *source ) {
+        int x, *src, *dst;
+
+        if (currentHandle < 0) return NULL;
+
+        src = (int *)source;
+        dst = (int *)cinTable[currentHandle].buf2;
+
+        for(x=0;x<256*256;x++) {
+                *dst = *src;
+                dst++; src += 2;
+        }
+        return cinTable[currentHandle].buf2;
+}
+*/
+static void RoQReset(void)
+{
+    if (currentHandle < 0) return;
+
+    FS_FCloseFile(cinTable[currentHandle].iFile);
+    FS_FOpenFileRead(cinTable[currentHandle].fileName, &cinTable[currentHandle].iFile, true);
+    // let the background thread start reading ahead
+    FS_Read(cin.file, 16, cinTable[currentHandle].iFile);
+    RoQ_init();
+    cinTable[currentHandle].status = FMV_LOOPED;
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void RoQInterrupt(void)
+{
+    byte *framedata;
+    short sbuf[32768];
+    int ssize;
+
+    if (currentHandle < 0) return;
+
+    FS_Read(cin.file, cinTable[currentHandle].RoQFrameSize + 8, cinTable[currentHandle].iFile);
+    if (cinTable[currentHandle].RoQPlayed >= cinTable[currentHandle].ROQSize)
+    {
+        if (cinTable[currentHandle].holdAtEnd == false)
+        {
+            if (cinTable[currentHandle].looping)
+            {
+                RoQReset();
+            }
+            else
+            {
+                cinTable[currentHandle].status = FMV_EOF;
+            }
+        }
+        else
+        {
+            cinTable[currentHandle].status = FMV_IDLE;
+        }
+        return;
+    }
+
+    framedata = cin.file;
+//
+// new frame is ready
+//
+redump:
+    switch (cinTable[currentHandle].roq_id)
+    {
+        case ROQ_QUAD_VQ:
+            if ((cinTable[currentHandle].numQuads & 1))
+            {
+                cinTable[currentHandle].normalBuffer0 = cinTable[currentHandle].t[1];
+                RoQPrepMcomp(cinTable[currentHandle].roqF0, cinTable[currentHandle].roqF1);
+                cinTable[currentHandle].VQ1((byte *)cin.qStatus[1], framedata);
+                cinTable[currentHandle].buf = cin.linbuf + cinTable[currentHandle].screenDelta;
+            }
+            else
+            {
+                cinTable[currentHandle].normalBuffer0 = cinTable[currentHandle].t[0];
+                RoQPrepMcomp(cinTable[currentHandle].roqF0, cinTable[currentHandle].roqF1);
+                cinTable[currentHandle].VQ0((byte *)cin.qStatus[0], framedata);
+                cinTable[currentHandle].buf = cin.linbuf;
+            }
+            if (cinTable[currentHandle].numQuads == 0)
+            {  // first frame
+                ::memcpy(cin.linbuf + cinTable[currentHandle].screenDelta, cin.linbuf,
+                    cinTable[currentHandle].samplesPerLine * cinTable[currentHandle].ysize);
+            }
+            cinTable[currentHandle].numQuads++;
+            cinTable[currentHandle].dirty = true;
+            break;
+        case ROQ_CODEBOOK:
+            decodeCodeBook(framedata, (unsigned short)cinTable[currentHandle].roq_flags);
+            break;
+        case ZA_SOUND_MONO:
+            if (!cinTable[currentHandle].silent)
+            {
+                ssize = RllDecodeMonoToStereo(framedata, sbuf, cinTable[currentHandle].RoQFrameSize, 0,
+                    (unsigned short)cinTable[currentHandle].roq_flags);
+                S_RawSamples(0, ssize, 22050, 2, 1, (byte *)sbuf, 1.0f, -1);
+            }
+            break;
+        case ZA_SOUND_STEREO:
+            if (!cinTable[currentHandle].silent)
+            {
+                if (cinTable[currentHandle].numQuads == -1)
+                {
+                    S_Update();
+                    s_rawend[0] = s_soundtime;
+                }
+                ssize = RllDecodeStereoToStereo(framedata, sbuf, cinTable[currentHandle].RoQFrameSize, 0,
+                    (unsigned short)cinTable[currentHandle].roq_flags);
+                S_RawSamples(0, ssize, 22050, 2, 2, (byte *)sbuf, 1.0f, -1);
+            }
+            break;
+        case ROQ_QUAD_INFO:
+            if (cinTable[currentHandle].numQuads == -1)
+            {
+                readQuadInfo(framedata);
+                setupQuad(0, 0);
+                cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = CL_ScaledMilliseconds();
+            }
+            if (cinTable[currentHandle].numQuads != 1) cinTable[currentHandle].numQuads = 0;
+            break;
+        case ROQ_PACKET:
+            cinTable[currentHandle].inMemory = (bool)cinTable[currentHandle].roq_flags;
+            cinTable[currentHandle].RoQFrameSize = 0;  // for header
+            break;
+        case ROQ_QUAD_HANG:
+            cinTable[currentHandle].RoQFrameSize = 0;
+            break;
+        case ROQ_QUAD_JPEG:
+            break;
+        default:
+            cinTable[currentHandle].status = FMV_EOF;
+            break;
+    }
+    //
+    // read in next frame data
+    //
+    if (cinTable[currentHandle].RoQPlayed >= cinTable[currentHandle].ROQSize)
+    {
+        if (cinTable[currentHandle].holdAtEnd == false)
+        {
+            if (cinTable[currentHandle].looping)
+            {
+                RoQReset();
+            }
+            else
+            {
+                cinTable[currentHandle].status = FMV_EOF;
+            }
+        }
+        else
+        {
+            cinTable[currentHandle].status = FMV_IDLE;
+        }
+        return;
+    }
+
+    framedata += cinTable[currentHandle].RoQFrameSize;
+    cinTable[currentHandle].roq_id = framedata[0] + framedata[1] * 256;
+    cinTable[currentHandle].RoQFrameSize = framedata[2] + framedata[3] * 256 + framedata[4] * 65536;
+    cinTable[currentHandle].roq_flags = framedata[6] + framedata[7] * 256;
+    cinTable[currentHandle].roqF0 = (signed char)framedata[7];
+    cinTable[currentHandle].roqF1 = (signed char)framedata[6];
+
+    if (cinTable[currentHandle].RoQFrameSize > 65536 || cinTable[currentHandle].roq_id == 0x1084)
+    {
+        Com_DPrintf("roq_size>65536||roq_id==0x1084\n");
+        cinTable[currentHandle].status = FMV_EOF;
+        if (cinTable[currentHandle].looping)
+        {
+            RoQReset();
+        }
+        return;
+    }
+    if (cinTable[currentHandle].inMemory && (cinTable[currentHandle].status != FMV_EOF))
+    {
+        cinTable[currentHandle].inMemory = false;
+        framedata += 8;
+        goto redump;
+    }
+    //
+    // one more frame hits the dust
+    //
+    //	assert(cinTable[currentHandle].RoQFrameSize <= 65536);
+    //	r = FS_Read( cin.file, cinTable[currentHandle].RoQFrameSize+8, cinTable[currentHandle].iFile );
+    cinTable[currentHandle].RoQPlayed += cinTable[currentHandle].RoQFrameSize + 8;
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void RoQ_init(void)
+{
+    cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = CL_ScaledMilliseconds();
+
+    cinTable[currentHandle].RoQPlayed = 24;
+
+    /*	get frame rate */
+    cinTable[currentHandle].roqFPS = cin.file[6] + cin.file[7] * 256;
+
+    if (!cinTable[currentHandle].roqFPS) cinTable[currentHandle].roqFPS = 30;
+
+    cinTable[currentHandle].numQuads = -1;
+
+    cinTable[currentHandle].roq_id = cin.file[8] + cin.file[9] * 256;
+    cinTable[currentHandle].RoQFrameSize = cin.file[10] + cin.file[11] * 256 + cin.file[12] * 65536;
+    cinTable[currentHandle].roq_flags = cin.file[14] + cin.file[15] * 256;
+
+    if (cinTable[currentHandle].RoQFrameSize > 65536 || !cinTable[currentHandle].RoQFrameSize)
+    {
+        return;
+    }
+}
+
+/******************************************************************************
+*
+* Function:
+*
+* Description:
+*
+******************************************************************************/
+
+static void RoQShutdown(void)
+{
+    const char *s;
+
+    if (!cinTable[currentHandle].buf)
+    {
+        return;
+    }
+
+    if (cinTable[currentHandle].status == FMV_IDLE)
+    {
+        return;
+    }
+    Com_DPrintf("finished cinematic\n");
+    cinTable[currentHandle].status = FMV_IDLE;
+
+    if (cinTable[currentHandle].iFile)
+    {
+        FS_FCloseFile(cinTable[currentHandle].iFile);
+        cinTable[currentHandle].iFile = 0;
+    }
+
+    if (cinTable[currentHandle].alterGameState)
+    {
+        clc.state = CA_DISCONNECTED;
+        // we can't just do a vstr nextmap, because
+        // if we are aborting the intro cinematic with
+        // a devmap command, nextmap would be valid by
+        // the time it was referenced
+        s = Cvar_VariableString("nextmap");
+        if (s[0])
+        {
+            Cbuf_ExecuteText(EXEC_APPEND, va("%s\n", s));
+            Cvar_Set("nextmap", "");
+        }
+        CL_handle = -1;
+
+        CL_ProtocolSpecificCommandsInit();
+    }
+    cinTable[currentHandle].fileName[0] = 0;
+    currentHandle = -1;
+}
+
+/*
+==================
+CIN_StopCinematic
+==================
+*/
+e_status CIN_StopCinematic(int handle)
+{
+    if (handle < 0 || handle >= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return FMV_EOF;
+    currentHandle = handle;
+
+    Com_DPrintf("trFMV::stop(), closing %s\n", cinTable[currentHandle].fileName);
+
+    if (!cinTable[currentHandle].buf)
+    {
+        return FMV_EOF;
+    }
+
+    if (cinTable[currentHandle].alterGameState)
+    {
+        if (clc.state != CA_CINEMATIC)
+        {
+            return cinTable[currentHandle].status;
+        }
+    }
+    cinTable[currentHandle].status = FMV_EOF;
+    RoQShutdown();
+
+    return FMV_EOF;
+}
+
+/*
+==================
+CIN_RunCinematic
+
+Fetch and decompress the pending frame
+==================
+*/
+
+e_status CIN_RunCinematic(int handle)
+{
+    int start = 0;
+    int thisTime = 0;
+
+    if (handle < 0 || handle >= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return FMV_EOF;
+
+    if (cin.currentHandle != handle)
+    {
+        currentHandle = handle;
+        cin.currentHandle = currentHandle;
+        cinTable[currentHandle].status = FMV_EOF;
+        RoQReset();
+    }
+
+    if (cinTable[handle].playonwalls < -1)
+    {
+        return cinTable[handle].status;
+    }
+
+    currentHandle = handle;
+
+    if (cinTable[currentHandle].alterGameState)
+    {
+        if (clc.state != CA_CINEMATIC)
+        {
+            return cinTable[currentHandle].status;
+        }
+    }
+
+    if (cinTable[currentHandle].status == FMV_IDLE)
+    {
+        return cinTable[currentHandle].status;
+    }
+
+    thisTime = CL_ScaledMilliseconds();
+    if (cinTable[currentHandle].shader && (abs(thisTime - cinTable[currentHandle].lastTime)) > 100)
+    {
+        cinTable[currentHandle].startTime += thisTime - cinTable[currentHandle].lastTime;
+    }
+    cinTable[currentHandle].tfps = (((CL_ScaledMilliseconds() - cinTable[currentHandle].startTime) * 3) / 100);
+
+    start = cinTable[currentHandle].startTime;
+    while ((cinTable[currentHandle].tfps != cinTable[currentHandle].numQuads) &&
+           (cinTable[currentHandle].status == FMV_PLAY))
+    {
+        RoQInterrupt();
+        if (start != cinTable[currentHandle].startTime)
+        {
+            cinTable[currentHandle].tfps = (((CL_ScaledMilliseconds() - cinTable[currentHandle].startTime) * 3) / 100);
+            start = cinTable[currentHandle].startTime;
+        }
+    }
+
+    cinTable[currentHandle].lastTime = thisTime;
+
+    if (cinTable[currentHandle].status == FMV_LOOPED)
+    {
+        cinTable[currentHandle].status = FMV_PLAY;
+    }
+
+    if (cinTable[currentHandle].status == FMV_EOF)
+    {
+        if (cinTable[currentHandle].looping)
+        {
+            RoQReset();
+        }
+        else
+        {
+            RoQShutdown();
+            return FMV_EOF;
+        }
+    }
+
+    return cinTable[currentHandle].status;
+}
+
+void CIN_SetExtents(int handle, int x, int y, int w, int h)
+{
+    if (handle < 0 || handle >= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return;
+    cinTable[handle].xpos = x;
+    cinTable[handle].ypos = y;
+    cinTable[handle].width = w;
+    cinTable[handle].height = h;
+    cinTable[handle].dirty = true;
+}
+
+static void CIN_SetLooping(int handle, bool loop)
+{
+    if (handle < 0 || handle >= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return;
+    cinTable[handle].looping = loop;
+}
+
+/*
+==================
+CIN_PlayCinematic
+==================
+*/
+int CIN_PlayCinematic(const char *arg, int x, int y, int w, int h, int systemBits)
+{
+    unsigned short RoQID;
+    char name[MAX_OSPATH];
+    int i;
+
+    if (strstr(arg, "/") == NULL && strstr(arg, "\\") == NULL)
+    {
+        Com_sprintf(name, sizeof(name), "video/%s", arg);
+    }
+    else
+    {
+        Com_sprintf(name, sizeof(name), "%s", arg);
+    }
+
+    if (!(systemBits & CIN_system))
+    {
+        for (i = 0; i < MAX_VIDEO_HANDLES; i++)
+        {
+            if (!strcmp(cinTable[i].fileName, name))
+            {
+                return i;
+            }
+        }
+    }
+
+    Com_DPrintf("CIN_PlayCinematic( %s )\n", arg);
+
+    ::memset(&cin, 0, sizeof(cinematics_t));
+    currentHandle = CIN_HandleForVideo();
+
+    cin.currentHandle = currentHandle;
+
+    strcpy(cinTable[currentHandle].fileName, name);
+
+    cinTable[currentHandle].ROQSize = 0;
+    cinTable[currentHandle].ROQSize =
+        FS_FOpenFileRead(cinTable[currentHandle].fileName, &cinTable[currentHandle].iFile, true);
+
+    if (cinTable[currentHandle].ROQSize <= 0)
+    {
+        Com_DPrintf("play(%s), ROQSize<=0\n", arg);
+        cinTable[currentHandle].fileName[0] = 0;
+        return -1;
+    }
+
+    CIN_SetExtents(currentHandle, x, y, w, h);
+    CIN_SetLooping(currentHandle, ((systemBits & CIN_loop) != 0));
+
+    cinTable[currentHandle].CIN_HEIGHT = DEFAULT_CIN_HEIGHT;
+    cinTable[currentHandle].CIN_WIDTH = DEFAULT_CIN_WIDTH;
+    cinTable[currentHandle].holdAtEnd = (systemBits & CIN_hold) != 0;
+    cinTable[currentHandle].alterGameState = (systemBits & CIN_system) != 0;
+    cinTable[currentHandle].playonwalls = 1;
+    cinTable[currentHandle].silent = (systemBits & CIN_silent) != 0;
+    cinTable[currentHandle].shader = (systemBits & CIN_shader) != 0;
+
+    if (cinTable[currentHandle].alterGameState)
+    {
+        // close the menu
+        if (cls.ui)
+        {
+            VM_Call(cls.ui, UI_SET_ACTIVE_MENU - cls.uiInterface == 2 ? 2 : 0, UIMENU_NONE);
+        }
+    }
+    else
+    {
+        cinTable[currentHandle].playonwalls = cl_inGameVideo->integer;
+    }
+
+    initRoQ();
+
+    FS_Read(cin.file, 16, cinTable[currentHandle].iFile);
+
+    RoQID = (unsigned short)(cin.file[0]) + (unsigned short)(cin.file[1]) * 256;
+    if (RoQID == 0x1084)
+    {
+        RoQ_init();
+        //		FS_Read (cin.file, cinTable[currentHandle].RoQFrameSize+8, cinTable[currentHandle].iFile);
+
+        cinTable[currentHandle].status = FMV_PLAY;
+        Com_DPrintf("trFMV::play(), playing %s\n", arg);
+
+        if (cinTable[currentHandle].alterGameState)
+        {
+            clc.state = CA_CINEMATIC;
+        }
+
+        if (!cinTable[currentHandle].silent)
+        {
+            s_rawend[0] = s_soundtime;
+        }
+
+        return currentHandle;
+    }
+    Com_DPrintf("trFMV::play(), invalid RoQ ID\n");
+
+    RoQShutdown();
+    return -1;
+}
+
+/*
+==================
+CIN_ResampleCinematic
+
+Resample cinematic to 256x256 and store in buf2
+==================
+*/
+static void CIN_ResampleCinematic(int handle, int *buf2)
+{
+    int ix, iy, *buf3, xm, ym, ll;
+    byte *buf;
+
+    buf = cinTable[handle].buf;
+
+    xm = cinTable[handle].CIN_WIDTH / 256;
+    ym = cinTable[handle].CIN_HEIGHT / 256;
+    ll = 8;
+    if (cinTable[handle].CIN_WIDTH == 512)
+    {
+        ll = 9;
+    }
+
+    buf3 = (int *)buf;
+    if (xm == 2 && ym == 2)
+    {
+        byte *bc2, *bc3;
+        int ic, iiy;
+
+        bc2 = (byte *)buf2;
+        bc3 = (byte *)buf3;
+        for (iy = 0; iy < 256; iy++)
+        {
+            iiy = iy << 12;
+            for (ix = 0; ix < 2048; ix += 8)
+            {
+                for (ic = ix; ic < (ix + 4); ic++)
+                {
+                    *bc2 = (bc3[iiy + ic] + bc3[iiy + 4 + ic] + bc3[iiy + 2048 + ic] + bc3[iiy + 2048 + 4 + ic]) >> 2;
+                    bc2++;
+                }
+            }
+        }
+    }
+    else if (xm == 2 && ym == 1)
+    {
+        byte *bc2, *bc3;
+        int ic, iiy;
+
+        bc2 = (byte *)buf2;
+        bc3 = (byte *)buf3;
+        for (iy = 0; iy < 256; iy++)
+        {
+            iiy = iy << 11;
+            for (ix = 0; ix < 2048; ix += 8)
+            {
+                for (ic = ix; ic < (ix + 4); ic++)
+                {
+                    *bc2 = (bc3[iiy + ic] + bc3[iiy + 4 + ic]) >> 1;
+                    bc2++;
+                }
+            }
+        }
+    }
+    else
+    {
+        for (iy = 0; iy < 256; iy++)
+        {
+            for (ix = 0; ix < 256; ix++)
+            {
+                buf2[(iy << 8) + ix] = buf3[((iy * ym) << ll) + (ix * xm)];
+            }
+        }
+    }
+}
+
+/*
+==================
+CIN_DrawCinematic
+==================
+*/
+void CIN_DrawCinematic(int handle)
+{
+    float x, y, w, h;
+    byte *buf;
+
+    if (handle < 0 || handle >= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return;
+
+    if (!cinTable[handle].buf)
+    {
+        return;
+    }
+
+    x = cinTable[handle].xpos;
+    y = cinTable[handle].ypos;
+    w = cinTable[handle].width;
+    h = cinTable[handle].height;
+    buf = cinTable[handle].buf;
+    SCR_AdjustFrom640(&x, &y, &w, &h);
+
+    if (cinTable[handle].dirty &&
+        (cinTable[handle].CIN_WIDTH != cinTable[handle].drawX
+         || cinTable[handle].CIN_HEIGHT != cinTable[handle].drawY))
+    {
+        int *buf2 = (int *)Hunk_AllocateTempMemory(256 * 256 * 4);
+
+        CIN_ResampleCinematic(handle, buf2);
+
+        re.DrawStretchRaw(x, y, w, h, 256, 256, (byte *)buf2, handle, true);
+        cinTable[handle].dirty = false;
+        Hunk_FreeTempMemory(buf2);
+        return;
+    }
+
+    re.DrawStretchRaw(x, y, w, h, cinTable[handle].drawX, cinTable[handle].drawY,
+            buf, handle, cinTable[handle].dirty);
+
+    cinTable[handle].dirty = false;
+}
+
+void CL_PlayCinematic_f(void)
+{
+    int bits = CIN_system;
+
+    Com_DPrintf("CL_PlayCinematic_f\n");
+    if (clc.state == CA_CINEMATIC)
+    {
+        SCR_StopCinematic();
+    }
+
+    const char *arg = Cmd_Argv(1);
+    const char *s = Cmd_Argv(2);
+
+    if ((s && s[0] == '1') || Q_stricmp(arg, "demoend.roq") == 0 || Q_stricmp(arg, "end.roq") == 0)
+    {
+        bits |= CIN_hold;
+    }
+    if (s && s[0] == '2')
+    {
+        bits |= CIN_loop;
+    }
+
+    S_StopAllSounds();
+
+    CL_handle = CIN_PlayCinematic(arg, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, bits);
+    if (CL_handle >= 0)
+    {
+        do
+        {
+            SCR_RunCinematic();
+        } while (cinTable[currentHandle].buf == NULL &&
+                 cinTable[currentHandle].status == FMV_PLAY);  // wait for first frame (load codebook and sound)
+    }
+}
+
+void SCR_DrawCinematic(void)
+{
+    if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES)
+    {
+        CIN_DrawCinematic(CL_handle);
+    }
+}
+
+void SCR_RunCinematic(void)
+{
+    if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES)
+    {
+        CIN_RunCinematic(CL_handle);
+    }
+}
+
+void SCR_StopCinematic(void)
+{
+    if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES)
+    {
+        CIN_StopCinematic(CL_handle);
+        S_StopAllSounds();
+        CL_handle = -1;
+    }
+}
+
+void CIN_UploadCinematic(int handle)
+{
+    if (handle >= 0 && handle < MAX_VIDEO_HANDLES)
+    {
+        if (!cinTable[handle].buf)
+        {
+            return;
+        }
+        if (cinTable[handle].playonwalls <= 0 && cinTable[handle].dirty)
+        {
+            if (cinTable[handle].playonwalls == 0)
+            {
+                cinTable[handle].playonwalls = -1;
+            }
+            else
+            {
+                if (cinTable[handle].playonwalls == -1)
+                {
+                    cinTable[handle].playonwalls = -2;
+                }
+                else
+                {
+                    cinTable[handle].dirty = false;
+                }
+            }
+        }
+
+        // Resample the video if needed
+        if (cinTable[handle].dirty && (cinTable[handle].CIN_WIDTH != cinTable[handle].drawX ||
+                                          cinTable[handle].CIN_HEIGHT != cinTable[handle].drawY))
+        {
+            int *buf2 = (int *)Hunk_AllocateTempMemory(256 * 256 * 4);
+
+            CIN_ResampleCinematic(handle, buf2);
+
+            re.UploadCinematic(
+                cinTable[handle].CIN_WIDTH, cinTable[handle].CIN_HEIGHT, 256, 256, (byte *)buf2, handle, true);
+            cinTable[handle].dirty = false;
+            Hunk_FreeTempMemory(buf2);
+        }
+        else
+        {
+            // Upload video at normal resolution
+            re.UploadCinematic(cinTable[handle].CIN_WIDTH, cinTable[handle].CIN_HEIGHT, cinTable[handle].drawX,
+                cinTable[handle].drawY, cinTable[handle].buf, handle, cinTable[handle].dirty);
+            cinTable[handle].dirty = false;
+        }
+
+        if (cl_inGameVideo->integer == 0 && cinTable[handle].playonwalls == 1)
+        {
+            cinTable[handle].playonwalls--;
+        }
+        else if (cl_inGameVideo->integer != 0 && cinTable[handle].playonwalls != 1)
+        {
+            cinTable[handle].playonwalls = 1;
+        }
+    }
+}
diff --git a/src/client/cl_console.cpp b/src/client/cl_console.cpp
new file mode 100644
index 0000000..e3e928c
--- /dev/null
+++ b/src/client/cl_console.cpp
@@ -0,0 +1,877 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+// console.c
+
+#include "client.h"
+
+#include "qcommon/cdefs.h"
+
+int g_console_field_width = 78;
+
+
+#define	NUM_CON_TIMES 4
+
+#define		CON_TEXTSIZE	163840
+typedef struct {
+	bool    initialized;
+
+	short	text[CON_TEXTSIZE];
+	int		current;		// line where next message will be printed
+	int		x;				// offset in current line for next print
+	int		display;		// bottom of console displays this line
+
+	int 	linewidth;		// characters across screen
+	int		totallines;		// total lines in console scrollback
+
+	float	xadjust;		// for wide aspect screens
+
+	float	displayFrac;	// aproaches finalFrac at scr_conspeed
+	float	finalFrac;		// 0.0 to 1.0 lines of console to display
+
+	int		vislines;		// in scanlines
+
+	vec4_t	color;
+} console_t;
+
+console_t	con;
+
+cvar_t		*con_conspeed;
+cvar_t      *con_height;
+cvar_t      *con_useShader;
+cvar_t      *con_colorRed;
+cvar_t      *con_colorGreen;
+cvar_t      *con_colorBlue;
+cvar_t      *con_colorAlpha;
+cvar_t      *con_versionStr;
+
+#define	DEFAULT_CONSOLE_WIDTH	78
+
+
+/*
+================
+Con_ToggleConsole_f
+================
+*/
+void Con_ToggleConsole_f (void) {
+	// Can't toggle the console when it's the only thing available
+	if ( clc.state == CA_DISCONNECTED && Key_GetCatcher( ) == KEYCATCH_CONSOLE ) {
+		return;
+	}
+
+	Field_Clear( &g_consoleField );
+	g_consoleField.widthInChars = g_console_field_width;
+
+	Key_SetCatcher( Key_GetCatcher( ) ^ KEYCATCH_CONSOLE );
+}
+
+/*
+===================
+Con_ToggleMenu_f
+===================
+*/
+void Con_ToggleMenu_f( void ) {
+	CL_KeyEvent( K_ESCAPE, true, Sys_Milliseconds() );
+	CL_KeyEvent( K_ESCAPE, false, Sys_Milliseconds() );
+}
+
+/*
+===================
+Con_MessageMode_f
+===================
+-*/
+void Con_MessageMode_f (void) {
+	chat_playerNum = -1;
+	chat_team = false;
+	chat_admins = false;
+	chat_clans = false;
+	Field_Clear( &chatField );
+	chatField.widthInChars = 30;
+
+	Key_SetCatcher( Key_GetCatcher( ) ^ KEYCATCH_MESSAGE );
+}
+
+/*
+====================
+Con_MessageMode2_f
+====================
+*/
+void Con_MessageMode2_f (void) {
+	chat_playerNum = -1;
+	chat_team = true;
+	chat_admins = false;
+	chat_clans = false;
+	Field_Clear( &chatField );
+	chatField.widthInChars = 25;
+	Key_SetCatcher( Key_GetCatcher( ) ^ KEYCATCH_MESSAGE );
+}
+
+/*
+===================
+Con_MessageMode3_f
+===================
+*/
+void Con_MessageMode3_f (void) {
+	chat_playerNum = VM_Call( cls.cgame, CG_CROSSHAIR_PLAYER );
+	if ( chat_playerNum < 0 || chat_playerNum >= MAX_CLIENTS ) {
+		chat_playerNum = -1;
+		return;
+	}
+	chat_team = false;
+	chat_admins = false;
+	chat_clans = false;
+	Field_Clear( &chatField );
+	chatField.widthInChars = 30;
+	Key_SetCatcher( Key_GetCatcher( ) ^ KEYCATCH_MESSAGE );
+}
+
+/*
+=====================
+Con_MessageMode4_f
+=====================
+*/
+void Con_MessageMode4_f (void) {
+	chat_playerNum = VM_Call( cls.cgame, CG_LAST_ATTACKER );
+	if ( chat_playerNum < 0 || chat_playerNum >= MAX_CLIENTS ) {
+		chat_playerNum = -1;
+		return;
+	}
+	chat_team = false;
+	chat_admins = false;
+	chat_clans = false;
+	Field_Clear( &chatField );
+	chatField.widthInChars = 30;
+	Key_SetCatcher( Key_GetCatcher( ) ^ KEYCATCH_MESSAGE );
+}
+
+/*
+================
+Con_MessageMode5_f
+================
+*/
+void Con_MessageMode5_f (void) {
+	int i;
+	chat_playerNum = -1;
+	chat_team = false;
+	chat_admins = true;
+	chat_clans = false;
+	Field_Clear( &chatField );
+	chatField.widthInChars = 25;
+	Key_SetCatcher( Key_GetCatcher( ) ^ KEYCATCH_MESSAGE );
+}
+
+/*
+================
+Con_MessageMode6_f
+================
+*/
+void Con_MessageMode6_f (void) {
+	int i;
+	chat_playerNum = -1;
+	chat_team = false;
+	chat_admins = false;
+	chat_clans = true;
+	Field_Clear( &chatField );
+	chatField.widthInChars = 25;
+	Key_SetCatcher( Key_GetCatcher( ) ^ KEYCATCH_MESSAGE );
+}
+
+/*
+================
+Con_Clear_f
+================
+*/
+void Con_Clear_f (void) {
+	int		i;
+
+	for ( i = 0 ; i < CON_TEXTSIZE ; i++ ) {
+		con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+	}
+
+	Con_Bottom();		// go to end
+}
+
+
+/*
+================
+Con_Dump_f
+
+Save the console contents out to a file
+================
+*/
+void Con_Dump_f (void)
+{
+	int		l, x, i;
+	short	*line;
+	fileHandle_t	f;
+	int		bufferlen;
+	char	*buffer;
+	char	filename[MAX_QPATH];
+
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf ("usage: condump <filename>\n");
+		return;
+	}
+
+	Q_strncpyz( filename, Cmd_Argv( 1 ), sizeof( filename ) );
+	COM_DefaultExtension( filename, sizeof( filename ), ".txt" );
+
+    if (!COM_CompareExtension(filename, ".txt"))
+    {
+        Com_Printf("Con_Dump_f: Only the \".txt\" extension is supported by this command!\n");
+        return;
+    }
+
+	f = FS_FOpenFileWrite( filename );
+	if (!f)
+	{
+		Com_Printf("ERROR: couldn't open %s.\n", filename);
+		return;
+	}
+
+	Com_Printf("Dumped console text to %s.\n", filename );
+
+	// skip empty lines
+	for (l = con.current - con.totallines + 1 ; l <= con.current ; l++)
+	{
+		line = con.text + (l%con.totallines)*con.linewidth;
+		for (x=0 ; x<con.linewidth ; x++)
+			if ((line[x] & 0xff) != ' ')
+				break;
+		if (x != con.linewidth)
+			break;
+	}
+
+#ifdef _WIN32
+	bufferlen = con.linewidth + 3 * sizeof ( char );
+#else
+	bufferlen = con.linewidth + 2 * sizeof ( char );
+#endif
+
+	buffer = (char*)Hunk_AllocateTempMemory( bufferlen );
+
+	// write the remaining lines
+	buffer[bufferlen-1] = 0;
+	for ( ; l <= con.current ; l++)
+	{
+		line = con.text + (l%con.totallines)*con.linewidth;
+		for(i=0; i<con.linewidth; i++)
+			buffer[i] = line[i] & 0xff;
+		for (x=con.linewidth-1 ; x>=0 ; x--)
+		{
+			if (buffer[x] == ' ')
+				buffer[x] = 0;
+			else
+				break;
+		}
+#ifdef _WIN32
+		Q_strcat(buffer, bufferlen, "\r\n");
+#else
+		Q_strcat(buffer, bufferlen, "\n");
+#endif
+		FS_Write(buffer, strlen(buffer), f);
+	}
+
+	Hunk_FreeTempMemory( buffer );
+	FS_FCloseFile( f );
+}
+
+
+/*
+================
+Con_ClearNotify
+================
+*/
+void Con_ClearNotify( void ) {
+	Cmd_TokenizeString( NULL );
+	CL_GameConsoleText( );
+}
+
+
+
+/*
+================
+Con_CheckResize
+
+If the line width has changed, reformat the buffer.
+================
+*/
+void Con_CheckResize (void)
+{
+	int		i, j, width, oldwidth, oldtotallines, numlines, numchars;
+	short	tbuf[CON_TEXTSIZE];
+
+	width = (SCREEN_WIDTH / SMALLCHAR_WIDTH) - 2;
+
+	if (width == con.linewidth)
+		return;
+
+	if (width < 1)			// video hasn't been initialized yet
+	{
+		width = DEFAULT_CONSOLE_WIDTH;
+		con.linewidth = width;
+		con.totallines = CON_TEXTSIZE / con.linewidth;
+		for(i=0; i<CON_TEXTSIZE; i++)
+
+			con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+	}
+	else
+	{
+		oldwidth = con.linewidth;
+		con.linewidth = width;
+		oldtotallines = con.totallines;
+		con.totallines = CON_TEXTSIZE / con.linewidth;
+		numlines = oldtotallines;
+
+		if (con.totallines < numlines)
+			numlines = con.totallines;
+
+		numchars = oldwidth;
+
+		if (con.linewidth < numchars)
+			numchars = con.linewidth;
+
+		::memcpy(tbuf, con.text, CON_TEXTSIZE * sizeof(short));
+		for(i=0; i<CON_TEXTSIZE; i++)
+
+			con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+
+
+		for (i=0 ; i<numlines ; i++)
+		{
+			for (j=0 ; j<numchars ; j++)
+			{
+				con.text[(con.totallines - 1 - i) * con.linewidth + j] =
+						tbuf[((con.current - i + oldtotallines) %
+							  oldtotallines) * oldwidth + j];
+			}
+		}
+	}
+
+	con.current = con.totallines - 1;
+	con.display = con.current;
+}
+
+/*
+==================
+Cmd_CompleteTxtName
+==================
+*/
+void Cmd_CompleteTxtName( char *args UNUSED, int argNum ) {
+	if( argNum == 2 ) {
+		Field_CompleteFilename( "", "txt", false, true );
+	}
+}
+
+/*
+================
+Con_MessageModesInit
+================
+*/
+void Con_MessageModesInit(void) {
+	if( clc.netchan.alternateProtocol == 2 )
+	{
+		// add the client side message modes for 1.1 servers
+		if( !Cmd_CommadExists( "messagemode" ) )
+			Cmd_AddCommand ("messagemode", Con_MessageMode_f);
+		if( !Cmd_CommadExists( "messagemode2" ) )
+			Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
+		if( !Cmd_CommadExists( "messagemode3" ) )
+			Cmd_AddCommand ("messagemode3", Con_MessageMode3_f);
+		if( !Cmd_CommadExists( "messagemode4" ) )
+			Cmd_AddCommand ("messagemode4", Con_MessageMode4_f);
+		if( !Cmd_CommadExists( "messagemode5" ) )
+			Cmd_AddCommand ("messagemode5", Con_MessageMode5_f);
+		if( !Cmd_CommadExists( "messagemode6" ) )
+			Cmd_AddCommand ("messagemode6", Con_MessageMode6_f);
+	} else
+	{
+		// remove the client side message modes for non-1.1 servers
+		Cmd_RemoveCommand("messagemode");
+		Cmd_RemoveCommand("messagemode2");
+		Cmd_RemoveCommand("messagemode3");
+		Cmd_RemoveCommand("messagemode4");
+		Cmd_RemoveCommand("messagemode5");
+		Cmd_RemoveCommand("messagemode6");
+	}
+}
+
+/*
+================
+Con_Init
+================
+*/
+void Con_Init (void) {
+	int		i;
+
+	con_conspeed    = Cvar_Get ("scr_conspeed", "3", 0);
+	con_useShader   = Cvar_Get ("scr_useShader", "1", CVAR_ARCHIVE);
+	con_height      = Cvar_Get ("scr_height", "50", CVAR_ARCHIVE);
+	con_colorRed    = Cvar_Get ("scr_colorRed", "0", CVAR_ARCHIVE);
+	con_colorBlue   = Cvar_Get ("scr_colorBlue", "0", CVAR_ARCHIVE);
+	con_colorGreen  = Cvar_Get ("scr_colorGreen", "0", CVAR_ARCHIVE);
+	con_colorAlpha  = Cvar_Get ("scr_colorAlpha", ".8", CVAR_ARCHIVE);
+    con_versionStr  = Cvar_Get ("scr_versionString", Q3_VERSION, CVAR_ARCHIVE);
+
+	Field_Clear( &g_consoleField );
+	g_consoleField.widthInChars = g_console_field_width;
+	for ( i = 0 ; i < COMMAND_HISTORY ; i++ ) {
+		Field_Clear( &historyEditLines[i] );
+		historyEditLines[i].widthInChars = g_console_field_width;
+	}
+	CL_LoadConsoleHistory( );
+	if( clc.netchan.alternateProtocol == 2 )
+	{
+		Cmd_AddCommand ("messagemode", Con_MessageMode_f);
+		Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
+		Cmd_AddCommand ("messagemode3", Con_MessageMode3_f);
+		Cmd_AddCommand ("messagemode4", Con_MessageMode4_f);
+		Cmd_AddCommand ("messagemode5", Con_MessageMode5_f);
+		Cmd_AddCommand ("messagemode6", Con_MessageMode6_f);
+	}
+
+	Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
+	Cmd_AddCommand ("togglemenu", Con_ToggleMenu_f);
+	Cmd_AddCommand ("clear", Con_Clear_f);
+	Cmd_AddCommand ("condump", Con_Dump_f);
+	Cmd_SetCommandCompletionFunc( "condump", Cmd_CompleteTxtName );
+}
+
+/*
+================
+Con_Shutdown
+================
+*/
+void Con_Shutdown(void)
+{
+	Cmd_RemoveCommand("toggleconsole");
+	Cmd_RemoveCommand("togglemenu");
+	Cmd_RemoveCommand("clear");
+	Cmd_RemoveCommand("condump");
+}
+
+/*
+===============
+Con_Linefeed
+===============
+*/
+void Con_Linefeed(void)
+{
+	int	i;
+
+	con.x = 0;
+
+	if (con.display == con.current)
+		con.display++;
+
+	con.current++;
+
+	for(i=0; i<con.linewidth; i++)
+		con.text[(con.current%con.totallines)*con.linewidth+i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+}
+
+/*
+================
+CL_ConsolePrint
+
+Handles cursor positioning, line wrapping, etc
+All console printing must go through this in order to be logged to disk
+If no console is visible, the text will appear at the top of the game window
+================
+*/
+void CL_ConsolePrint( const char *txt )
+{
+	int	y, l;
+	unsigned char c;
+	unsigned short color;
+	bool skipnotify = false;		// NERVE - SMF
+
+	// TTimo - prefix for text that shows up in console but not in notify
+	// backported from RTCW
+	if ( !Q_strncmp( txt, "[skipnotify]", 12 ) ) {
+		skipnotify = true;
+		txt += 12;
+	}
+
+	// for some demos we don't want to ever show anything on the console
+	if ( cl_noprint && cl_noprint->integer )
+		return;
+
+	if (!con.initialized) {
+		con.color[0] =
+		con.color[1] =
+		con.color[2] =
+		con.color[3] = 1.0f;
+		con.linewidth = -1;
+		Con_CheckResize ();
+		con.initialized = true;
+	}
+
+	if( !skipnotify && !(Key_GetCatcher( ) & KEYCATCH_CONSOLE) )
+    {
+		Cmd_SaveCmdContext( );
+
+		// feed the text to cgame
+		Cmd_TokenizeString( txt );
+		CL_GameConsoleText( );
+
+		Cmd_RestoreCmdContext( );
+	}
+
+	color = ColorIndex(COLOR_WHITE);
+
+	while ( (c = *((unsigned char *)txt)) != 0 )
+    {
+		if ( Q_IsColorString( txt ) )
+        {
+			color = ColorIndex( *(txt+1) );
+			txt += 2;
+			continue;
+		}
+
+		// count word length
+		for (l=0 ; l< con.linewidth ; l++)
+        {
+			if ( txt[l] <= ' ')
+				break;
+		}
+
+		// word wrap
+		if (l != con.linewidth && (con.x + l >= con.linewidth) )
+			Con_Linefeed();
+
+		txt++;
+
+		switch (c)
+		{
+		case INDENT_MARKER:
+			break;
+		case '\n':
+			Con_Linefeed();
+			break;
+		case '\r':
+			con.x = 0;
+			break;
+		default:	// display character and advance
+			y = con.current % con.totallines;
+			con.text[y*con.linewidth+con.x] = (color << 8) | c;
+			con.x++;
+			if(con.x >= con.linewidth)
+				Con_Linefeed();
+			break;
+		}
+	}
+}
+
+
+/*
+==============================================================================
+
+DRAWING
+
+==============================================================================
+*/
+
+
+/*
+================
+Con_DrawInput
+
+Draw the editline after a ] prompt
+================
+*/
+static void Con_DrawInput (void)
+{
+	int		y;
+
+	if ( clc.state != CA_DISCONNECTED && !(Key_GetCatcher( ) & KEYCATCH_CONSOLE ) ) {
+		return;
+	}
+
+	y = con.vislines - ( SMALLCHAR_HEIGHT * 2 );
+
+	re.SetColor( con.color );
+
+	SCR_DrawSmallChar( con.xadjust + 1 * SMALLCHAR_WIDTH, y, ']' );
+
+	Field_Draw( &g_consoleField,
+            con.xadjust + 2 * SMALLCHAR_WIDTH,
+            y,
+            SCREEN_WIDTH - 3 * SMALLCHAR_WIDTH,
+            true, true );
+}
+
+/*
+================
+Con_DrawSolidConsole
+
+Draws the console with the solid background
+================
+*/
+static void Con_DrawSolidConsole( float frac )
+{
+	int				i, x, y;
+	int				rows;
+	short			*text;
+	int				row;
+	int				lines;
+	int				currentColor;
+	vec4_t			color;
+
+	lines = cls.glconfig.vidHeight * frac;
+	if (lines <= 0)
+		return;
+
+	if (lines > cls.glconfig.vidHeight )
+		lines = cls.glconfig.vidHeight;
+
+	// on wide screens, we will center the text
+	con.xadjust = 0;
+	SCR_AdjustFrom640( &con.xadjust, NULL, NULL, NULL );
+
+	// draw the background
+	y = frac * SCREEN_HEIGHT;
+	if ( y < 1 )
+    {
+		y = 0;
+	}
+	else if (con_useShader->integer)
+    {
+        SCR_DrawPic(0, 0, SCREEN_WIDTH, y, cls.consoleShader);
+    }
+    else
+    {
+        color[0] = con_colorRed->value;
+        color[1] = con_colorGreen->value;
+        color[2] = con_colorBlue->value;
+        color[3] = con_colorAlpha->value;
+        SCR_FillRect(0, 0, SCREEN_WIDTH, y, color);
+	}
+
+	color[0] = 1;
+	color[1] = 0;
+	color[2] = 0;
+	color[3] = 1;
+	SCR_FillRect(0, y, SCREEN_WIDTH, 2, color);
+
+
+	// draw the version number
+
+	re.SetColor( g_color_table[ColorIndex(COLOR_RED)] );
+
+	i = strlen( Q3_VERSION );
+
+	for (x=0 ; x<i ; x++) {
+		SCR_DrawSmallChar( cls.glconfig.vidWidth - ( i - x + 1 ) * SMALLCHAR_WIDTH,
+			lines - SMALLCHAR_HEIGHT, Q3_VERSION[x] );
+	}
+
+	// draw the text
+	con.vislines = lines;
+	rows = (lines-SMALLCHAR_HEIGHT)/SMALLCHAR_HEIGHT;		// rows of text to draw
+
+	y = lines - (SMALLCHAR_HEIGHT*3);
+
+	// draw from the bottom up
+	if (con.display != con.current)
+	{
+	// draw arrows to show the buffer is backscrolled
+		re.SetColor( g_color_table[ColorIndex(COLOR_RED)] );
+		for (x=0 ; x<con.linewidth ; x+=4)
+			SCR_DrawSmallChar( con.xadjust + (x+1)*SMALLCHAR_WIDTH, y, '^' );
+		y -= SMALLCHAR_HEIGHT;
+		rows--;
+	}
+
+	row = con.display;
+
+	if ( con.x == 0 ) {
+		row--;
+	}
+
+	currentColor = 7;
+	re.SetColor( g_color_table[currentColor] );
+
+	for (i=0 ; i<rows ; i++, y -= SMALLCHAR_HEIGHT, row--)
+	{
+		if (row < 0)
+			break;
+		if (con.current - row >= con.totallines) {
+			// past scrollback wrap point
+			continue;
+		}
+
+		text = con.text + (row % con.totallines)*con.linewidth;
+
+		for (x=0 ; x<con.linewidth ; x++) {
+			if ( ( text[x] & 0xff ) == ' ' ) {
+				continue;
+			}
+
+			if ( ColorIndexForNumber( text[x]>>8 ) != currentColor ) {
+				currentColor = ColorIndexForNumber( text[x]>>8 );
+				re.SetColor( g_color_table[currentColor] );
+			}
+			SCR_DrawSmallChar(  con.xadjust + (x+1)*SMALLCHAR_WIDTH, y, text[x] & 0xff );
+		}
+	}
+
+	// draw the input prompt, user text, and cursor if desired
+	Con_DrawInput ();
+
+	re.SetColor( NULL );
+}
+
+
+
+/*
+==================
+Con_DrawConsole
+==================
+*/
+void Con_DrawConsole( void ) {
+	// check for console width changes from a vid mode change
+	Con_CheckResize ();
+
+	// if disconnected, render console full screen
+	if ( clc.state == CA_DISCONNECTED ) {
+		if ( !( Key_GetCatcher( ) & (KEYCATCH_UI | KEYCATCH_CGAME)) ) {
+			Con_DrawSolidConsole( 1.0 );
+			return;
+		}
+	}
+
+	// draw the chat line
+  if( clc.netchan.alternateProtocol == 2 &&
+      ( Key_GetCatcher( ) & KEYCATCH_MESSAGE ) )
+  {
+    int skip;
+
+		if( chatField.buffer[0] == '/' ||
+				chatField.buffer[0] == '\\' )
+		{
+			SCR_DrawBigString( 8, 232, "Command:", 1.0f, qfalse );
+			skip = 10;
+		}
+    else if( chat_team )
+    {
+      SCR_DrawBigString( 8, 232, "Team Say:", 1.0f, qfalse );
+      skip = 11;
+    }
+    else if( chat_admins )
+    {
+      SCR_DrawBigString( 8, 232, "Admin Say:", 1.0f, qfalse );
+      skip = 11;
+    }
+    else if( chat_clans )
+    {
+      SCR_DrawBigString( 8, 232, "Clan Say:", 1.0f, qfalse );
+      skip = 11;
+    }
+    else
+    {
+      SCR_DrawBigString( 8, 232, "Say:", 1.0f, qfalse );
+      skip = 5;
+    }
+
+    Field_BigDraw( &chatField, skip * BIGCHAR_WIDTH, 232,
+                   SCREEN_WIDTH - ( skip + 1 ) * BIGCHAR_WIDTH, qtrue, qtrue );
+	}
+
+	if ( con.displayFrac ) {
+		Con_DrawSolidConsole( con.displayFrac );
+	}
+
+	if( Key_GetCatcher( ) & ( KEYCATCH_UI | KEYCATCH_CGAME ) )
+		return;
+}
+//================================================================
+
+/*
+==================
+Con_RunConsole
+
+Scroll it up or down
+==================
+*/
+void Con_RunConsole (void) {
+	// decide on the destination height of the console
+	if ( Key_GetCatcher( ) & KEYCATCH_CONSOLE )
+		con.finalFrac = MAX(0.10, 0.01 * con_height->integer);
+	else
+		con.finalFrac = 0;				// none visible
+
+	// scroll towards the destination height
+	if (con.finalFrac < con.displayFrac)
+	{
+		con.displayFrac -= con_conspeed->value*cls.realFrametime*0.001;
+		if (con.finalFrac > con.displayFrac)
+			con.displayFrac = con.finalFrac;
+
+	}
+	else if (con.finalFrac > con.displayFrac)
+	{
+		con.displayFrac += con_conspeed->value*cls.realFrametime*0.001;
+		if (con.finalFrac < con.displayFrac)
+			con.displayFrac = con.finalFrac;
+	}
+
+}
+
+
+void Con_PageUp( void ) {
+	con.display -= 2;
+	if ( con.current - con.display >= con.totallines ) {
+		con.display = con.current - con.totallines + 1;
+	}
+}
+
+void Con_PageDown( void ) {
+	con.display += 2;
+	if (con.display > con.current) {
+		con.display = con.current;
+	}
+}
+
+void Con_Top( void ) {
+	con.display = con.totallines;
+	if ( con.current - con.display >= con.totallines ) {
+		con.display = con.current - con.totallines + 1;
+	}
+}
+
+void Con_Bottom( void ) {
+	con.display = con.current;
+}
+
+
+void Con_Close( void ) {
+	if ( !com_cl_running->integer ) {
+		return;
+	}
+	Field_Clear( &g_consoleField );
+	Key_SetCatcher( Key_GetCatcher( ) & ~KEYCATCH_CONSOLE );
+	con.finalFrac = 0;				// none visible
+	con.displayFrac = 0;
+}
diff --git a/src/client/cl_curl.cpp b/src/client/cl_curl.cpp
new file mode 100644
index 0000000..0c81985
--- /dev/null
+++ b/src/client/cl_curl.cpp
@@ -0,0 +1,364 @@
+/*
+===========================================================================
+Copyright (C) 2006 Tony J. White (tjw@tjw.org)
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include "client.h"
+
+#ifdef USE_CURL_DLOPEN
+#include "sys/sys_loadlib.h"
+
+cvar_t *cl_cURLLib;
+
+char* (*qcurl_version)(void);
+
+CURL* (*qcurl_easy_init)(void);
+CURLcode (*qcurl_easy_setopt)(CURL *curl, CURLoption option, ...);
+CURLcode (*qcurl_easy_perform)(CURL *curl);
+void (*qcurl_easy_cleanup)(CURL *curl);
+CURLcode (*qcurl_easy_getinfo)(CURL *curl, CURLINFO info, ...);
+CURL* (*qcurl_easy_duphandle)(CURL *curl);
+void (*qcurl_easy_reset)(CURL *curl);
+const char *(*qcurl_easy_strerror)(CURLcode);
+
+CURLM* (*qcurl_multi_init)(void);
+CURLMcode (*qcurl_multi_add_handle)(CURLM*, CURL*curl_handle);
+CURLMcode (*qcurl_multi_remove_handle)(CURLM*, CURL*);
+CURLMcode (*qcurl_multi_fdset)(CURLM*, fd_set* read_set, fd_set* write_set, fd_set* exc_set, int*);
+CURLMcode (*qcurl_multi_perform)(CURLM*, int*);
+CURLMcode (*qcurl_multi_cleanup)(CURLM*);
+CURLMsg *(*qcurl_multi_info_read)(CURLM*, int*);
+const char *(*qcurl_multi_strerror)(CURLMcode);
+
+struct curl_slist* (*qcurl_slist_append)(struct curl_slist*, const char*);
+void               (*qcurl_slist_free_all)(struct curl_slist*);
+
+CURLcode (*qcurl_global_init)(long);
+void     (*qcurl_global_cleanup)(void);
+
+
+static void *cURLLib = NULL;
+
+/*
+=================
+GPA
+=================
+*/
+static void *GPA(const char *str)
+{
+	void* rv = Sys_LoadFunction(cURLLib, str);
+	if(!rv)
+	{
+		Com_Printf("Can't load symbol %s\n", str);
+		clc.cURLEnabled = false;
+		return NULL;
+	}
+	else
+	{
+		Com_DPrintf("Loaded symbol %s (0x%p)\n", str, rv);
+        return rv;
+	}
+}
+#endif /* USE_CURL_DLOPEN */
+
+/*
+=================
+CL_cURL_Init
+=================
+*/
+bool CL_cURL_Init()
+{
+#ifdef USE_CURL_DLOPEN
+	cl_cURLLib = Cvar_Get("cl_cURLLib", DEFAULT_CURL_LIB, CVAR_ARCHIVE | CVAR_PROTECTED);
+
+	if(cURLLib)
+		return true;
+
+	Com_Printf("Loading \"%s\"...", cl_cURLLib->string);
+	if( !(cURLLib = Sys_LoadDll(cl_cURLLib->string, true)) )
+	{
+#ifdef ALTERNATE_CURL_LIB
+		// On some linux distributions there is no libcurl.so.3, but only libcurl.so.4. That one works too.
+		if( !(cURLLib = Sys_LoadDll(ALTERNATE_CURL_LIB, true)) )
+#endif
+			return false;
+	}
+
+	clc.cURLEnabled = true;
+
+	qcurl_version = (decltype(qcurl_version)) GPA("curl_version");
+
+	qcurl_easy_init = (decltype(qcurl_easy_init)) GPA("curl_easy_init");
+	qcurl_easy_setopt = (decltype(qcurl_easy_setopt)) GPA("curl_easy_setopt");
+	qcurl_easy_perform = (decltype(qcurl_easy_perform)) GPA("curl_easy_perform");
+	qcurl_easy_cleanup = (decltype(qcurl_easy_cleanup)) GPA("curl_easy_cleanup");
+	qcurl_easy_getinfo = (decltype(qcurl_easy_getinfo)) GPA("curl_easy_getinfo");
+	qcurl_easy_duphandle = (decltype(qcurl_easy_duphandle)) GPA("curl_easy_duphandle");
+	qcurl_easy_reset = (decltype(qcurl_easy_reset)) GPA("curl_easy_reset");
+	qcurl_easy_strerror = (decltype(qcurl_easy_strerror)) GPA("curl_easy_strerror");
+	
+	qcurl_multi_init = (decltype(qcurl_multi_init)) GPA("curl_multi_init");
+	qcurl_multi_add_handle = (decltype(qcurl_multi_add_handle)) GPA("curl_multi_add_handle");
+	qcurl_multi_remove_handle = (decltype(qcurl_multi_remove_handle)) GPA("curl_multi_remove_handle");
+	qcurl_multi_fdset = (decltype(qcurl_multi_fdset)) GPA("curl_multi_fdset");
+	qcurl_multi_perform = (decltype(qcurl_multi_perform)) GPA("curl_multi_perform");
+	qcurl_multi_cleanup = (decltype(qcurl_multi_cleanup)) GPA("curl_multi_cleanup");
+	qcurl_multi_info_read = (decltype(qcurl_multi_info_read)) GPA("curl_multi_info_read");
+	qcurl_multi_strerror = (decltype(qcurl_multi_strerror)) GPA("curl_multi_strerror");
+    qcurl_slist_append = (decltype(qcurl_slist_append)) GPA("curl_slist_append");
+    qcurl_slist_free_all = (decltype(qcurl_slist_free_all)) GPA("curl_slist_free_all");
+    qcurl_global_init = (decltype(qcurl_global_init)) GPA("curl_global_init");
+    qcurl_global_cleanup = (decltype(qcurl_global_cleanup)) GPA("curl_global_cleanup");
+
+	if(!clc.cURLEnabled)
+	{
+		CL_cURL_Shutdown();
+		Com_Printf("FAIL One or more symbols not found\n");
+		return false;
+	}
+	Com_Printf("OK\n");
+
+	return true;
+#else
+	clc.cURLEnabled = true;
+	return true;
+#endif /* USE_CURL_DLOPEN */
+}
+
+/*
+=================
+CL_cURL_Shutdown
+=================
+*/
+void CL_cURL_Shutdown( void )
+{
+	CL_cURL_Cleanup();
+#ifdef USE_CURL_DLOPEN
+	if(cURLLib)
+	{
+		Sys_UnloadLibrary(cURLLib);
+		cURLLib = NULL;
+	}
+	qcurl_easy_init = NULL;
+	qcurl_easy_setopt = NULL;
+	qcurl_easy_perform = NULL;
+	qcurl_easy_cleanup = NULL;
+	qcurl_easy_getinfo = NULL;
+	qcurl_easy_duphandle = NULL;
+	qcurl_easy_reset = NULL;
+
+	qcurl_multi_init = NULL;
+	qcurl_multi_add_handle = NULL;
+	qcurl_multi_remove_handle = NULL;
+	qcurl_multi_fdset = NULL;
+	qcurl_multi_perform = NULL;
+	qcurl_multi_cleanup = NULL;
+	qcurl_multi_info_read = NULL;
+	qcurl_multi_strerror = NULL;
+#endif /* USE_CURL_DLOPEN */
+}
+
+void CL_cURL_Cleanup(void)
+{
+	if(clc.downloadCURLM) {
+		CURLMcode result;
+
+		if(clc.downloadCURL) {
+			result = qcurl_multi_remove_handle(clc.downloadCURLM,
+				clc.downloadCURL);
+			if(result != CURLM_OK) {
+				Com_DPrintf("qcurl_multi_remove_handle failed: %s\n", qcurl_multi_strerror(result));
+			}
+			qcurl_easy_cleanup(clc.downloadCURL);
+		}
+		result = qcurl_multi_cleanup(clc.downloadCURLM);
+		if(result != CURLM_OK) {
+			Com_DPrintf("CL_cURL_Cleanup: qcurl_multi_cleanup failed: %s\n", qcurl_multi_strerror(result));
+		}
+		clc.downloadCURLM = NULL;
+		clc.downloadCURL = NULL;
+	}
+	else if(clc.downloadCURL) {
+		qcurl_easy_cleanup(clc.downloadCURL);
+		clc.downloadCURL = NULL;
+	}
+}
+
+static int CL_cURL_CallbackProgress( void *dummy, double dltotal, double dlnow,
+	double ultotal, double ulnow )
+{
+	clc.downloadSize = (int)dltotal;
+	Cvar_SetValue( "cl_downloadSize", clc.downloadSize );
+	clc.downloadCount = (int)dlnow;
+	Cvar_SetValue( "cl_downloadCount", clc.downloadCount );
+	return 0;
+}
+
+static size_t CL_cURL_CallbackWrite(void *buffer, size_t size, size_t nmemb,
+	void *stream)
+{
+	FS_Write( buffer, size*nmemb, ((fileHandle_t*)stream)[0] );
+	return size*nmemb;
+}
+
+CURLcode qcurl_easy_setopt_warn(CURL *curl, CURLoption option, ...)
+{
+	CURLcode result;
+
+	va_list argp;
+	va_start(argp, option);
+
+	if(option < CURLOPTTYPE_OBJECTPOINT) {
+		long longValue = va_arg(argp, long);
+		result = qcurl_easy_setopt(curl, option, longValue);
+	} else if(option < CURLOPTTYPE_OFF_T) {
+		void *pointerValue = va_arg(argp, void *);
+		result = qcurl_easy_setopt(curl, option, pointerValue);
+	} else {
+		curl_off_t offsetValue = va_arg(argp, curl_off_t);
+		result = qcurl_easy_setopt(curl, option, offsetValue);
+	}
+
+	if(result != CURLE_OK) {
+		Com_DPrintf("qcurl_easy_setopt failed: %s\n", qcurl_easy_strerror(result));
+	}
+	va_end(argp);
+
+	return result;
+}
+
+void CL_cURL_BeginDownload( const char *localName, const char *remoteURL )
+{
+	CURLMcode result;
+
+	clc.cURLUsed = true;
+	Com_Printf("URL: %s\n", remoteURL);
+	Com_DPrintf("***** CL_cURL_BeginDownload *****\n"
+		"Localname: %s\n"
+		"RemoteURL: %s\n"
+		"****************************\n", localName, remoteURL);
+	CL_cURL_Cleanup();
+	Q_strncpyz(clc.downloadURL, remoteURL, sizeof(clc.downloadURL));
+	Q_strncpyz(clc.downloadName, localName, sizeof(clc.downloadName));
+	Com_sprintf(clc.downloadTempName, sizeof(clc.downloadTempName),
+		"%s.tmp", localName);
+
+	// Set so UI gets access to it
+	Cvar_Set("cl_downloadName", localName);
+	Cvar_Set("cl_downloadSize", "0");
+	Cvar_Set("cl_downloadCount", "0");
+	Cvar_SetValue("cl_downloadTime", cls.realtime);
+
+	clc.downloadBlock = 0; // Starting new file
+	clc.downloadCount = 0;
+
+	clc.downloadCURL = qcurl_easy_init();
+	if(!clc.downloadCURL) {
+		Com_Error(ERR_DROP, "CL_cURL_BeginDownload: qcurl_easy_init() "
+			"failed");
+		return;
+	}
+	clc.download = FS_SV_FOpenFileWrite(clc.downloadTempName);
+	if(!clc.download) {
+		Com_Error(ERR_DROP, "CL_cURL_BeginDownload: failed to open "
+			"%s for writing", clc.downloadTempName);
+		return;
+	}
+
+	if(com_developer->integer)
+		qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_VERBOSE, 1);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_URL, clc.downloadURL);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_TRANSFERTEXT, 0);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_REFERER, va("Tremulous://%s", NET_AdrToString(clc.serverAddress)));
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_USERAGENT, va("%s %s", Q3_VERSION, qcurl_version()));
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_WRITEFUNCTION, CL_cURL_CallbackWrite);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_WRITEDATA, &clc.download);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_NOPROGRESS, 0);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_PROGRESSFUNCTION, CL_cURL_CallbackProgress);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_PROGRESSDATA, NULL);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_FAILONERROR, 1);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_FOLLOWLOCATION, 1);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_MAXREDIRS, 5);
+	qcurl_easy_setopt_warn(clc.downloadCURL, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS | CURLPROTO_FTP | CURLPROTO_FTPS );
+	clc.downloadCURLM = qcurl_multi_init();	
+	if(!clc.downloadCURLM)
+    {
+		qcurl_easy_cleanup(clc.downloadCURL);
+		clc.downloadCURL = NULL;
+		Com_Error(ERR_DROP, "CL_cURL_BeginDownload: qcurl_multi_init() "
+			"failed");
+		return;
+	}
+
+	result = qcurl_multi_add_handle(clc.downloadCURLM, clc.downloadCURL);
+	if(result != CURLM_OK)
+    {
+		qcurl_easy_cleanup(clc.downloadCURL);
+		clc.downloadCURL = NULL;
+		Com_Error(ERR_DROP,"CL_cURL_BeginDownload: qcurl_multi_add_handle() failed: %s", qcurl_multi_strerror(result));
+		return;
+	}
+
+	if(!(clc.sv_allowDownload & DLF_NO_DISCONNECT) && !clc.cURLDisconnected)
+    {
+		CL_AddReliableCommand("disconnect", true);
+		CL_WritePacket();
+		CL_WritePacket();
+		CL_WritePacket();
+		clc.cURLDisconnected = true;
+	}
+}
+
+void CL_cURL_PerformDownload(void)
+{
+	CURLMcode res;
+	CURLMsg *msg;
+	int c;
+	int i = 0;
+
+	res = qcurl_multi_perform(clc.downloadCURLM, &c);
+	while(res == CURLM_CALL_MULTI_PERFORM && i < 100) {
+		res = qcurl_multi_perform(clc.downloadCURLM, &c);
+		i++;
+	}
+	if(res == CURLM_CALL_MULTI_PERFORM)
+		return;
+	msg = qcurl_multi_info_read(clc.downloadCURLM, &c);
+	if(msg == NULL) {
+		return;
+	}
+	FS_FCloseFile(clc.download);
+	if(msg->msg == CURLMSG_DONE && msg->data.result == CURLE_OK) {
+		FS_SV_Rename(clc.downloadTempName, clc.downloadName, false);
+		clc.downloadRestart = true;
+	}
+	else {
+		long code;
+
+		qcurl_easy_getinfo(msg->easy_handle, CURLINFO_RESPONSE_CODE, &code);	
+		Com_Error(ERR_DROP, "Download Error: %s Code: %ld URL: %s",
+			qcurl_easy_strerror(msg->data.result),
+			code, clc.downloadURL);
+	}
+
+	CL_NextDownload();
+}
diff --git a/src/client/cl_curl.h b/src/client/cl_curl.h
new file mode 100644
index 0000000..2e3b4e3
--- /dev/null
+++ b/src/client/cl_curl.h
@@ -0,0 +1,101 @@
+/*
+===========================================================================
+Copyright (C) 2006 Tony J. White (tjw@tjw.org)
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#ifndef __QCURL_H__
+#define __QCURL_H__
+
+#ifdef USE_LOCAL_HEADERS
+#include "curl/curl.h"
+#else
+#include <curl/curl.h>
+#endif
+
+#include "qcommon/q_shared.h"
+#include "qcommon/qcommon.h"
+
+#ifdef USE_CURL_DLOPEN
+#ifdef _WIN32
+  #define DEFAULT_CURL_LIB "libcurl-4.dll"
+  #define ALTERNATE_CURL_LIB "libcurl-3.dll"
+#elif defined(__APPLE__)
+  #define DEFAULT_CURL_LIB "libcurl.dylib"
+#else
+  #define DEFAULT_CURL_LIB "libcurl.so.4"
+  #define ALTERNATE_CURL_LIB "libcurl.so.3"
+#endif
+
+extern cvar_t *cl_cURLLib;
+
+extern char*        (*qcurl_version)(void);
+extern CURL*        (*qcurl_easy_init)(void);
+extern CURLcode     (*qcurl_easy_setopt)(CURL *curl, CURLoption option, ...);
+extern CURLcode     (*qcurl_easy_perform)(CURL *curl);
+extern void         (*qcurl_easy_cleanup)(CURL *curl);
+extern CURLcode     (*qcurl_easy_getinfo)(CURL *curl, CURLINFO info, ...);
+extern void         (*qcurl_easy_reset)(CURL *curl);
+extern const char*  (*qcurl_easy_strerror)(CURLcode);
+extern CURLM*       (*qcurl_multi_init)(void);
+extern CURLMcode    (*qcurl_multi_add_handle)(CURLM *multi_handle, CURL *curl_handle);
+extern CURLMcode    (*qcurl_multi_remove_handle)(CURLM *multi_handle, CURL *curl_handle);
+extern CURLMcode    (*qcurl_multi_fdset)(CURLM *multi_handle, fd_set *read_fd_set, fd_set *write_fd_set, fd_set *exc_fd_set, int *max_fd);
+extern CURLMcode    (*qcurl_multi_perform)(CURLM *multi_handle, int *running_handles);
+extern CURLMcode    (*qcurl_multi_cleanup)(CURLM *multi_handle);
+extern CURLMsg*     (*qcurl_multi_info_read)(CURLM *multi_handle, int *msgs_in_queue);
+extern const char*  (*qcurl_multi_strerror)(CURLMcode);
+extern struct curl_slist* (*qcurl_slist_append)(struct curl_slist *, const char *);
+extern void         (*qcurl_slist_free_all)(struct curl_slist *);
+extern CURLcode     (*qcurl_global_init)(long flags);
+extern void         (*qcurl_global_cleanup)(void);
+  
+#else
+#define qcurl_version curl_version
+#define qcurl_easy_init curl_easy_init
+#define qcurl_easy_setopt curl_easy_setopt
+#define qcurl_easy_perform curl_easy_perform
+#define qcurl_easy_cleanup curl_easy_cleanup
+#define qcurl_easy_getinfo curl_easy_getinfo
+#define qcurl_easy_duphandle curl_easy_duphandle
+#define qcurl_easy_reset curl_easy_reset
+#define qcurl_easy_strerror curl_easy_strerror
+#define qcurl_multi_init curl_multi_init
+#define qcurl_multi_add_handle curl_multi_add_handle
+#define qcurl_multi_remove_handle curl_multi_remove_handle
+#define qcurl_multi_fdset curl_multi_fdset
+#define qcurl_multi_perform curl_multi_perform
+#define qcurl_multi_cleanup curl_multi_cleanup
+#define qcurl_multi_info_read curl_multi_info_read
+#define qcurl_multi_strerror curl_multi_strerror
+#define qcurl_slist_append curl_slist_append
+#define qcurl_slist_free_all curl_slist_free_all
+#define qcurl_global_init curl_global_init
+#define qcurl_global_cleanup curl_global_cleanup
+#endif
+
+bool CL_cURL_Init( void );
+void CL_cURL_Shutdown( void );
+void CL_cURL_BeginDownload( const char *localName, const char *remoteURL );
+void CL_cURL_PerformDownload( void );
+void CL_cURL_Cleanup( void );
+
+#endif	// __QCURL_H__
diff --git a/src/client/cl_input.cpp b/src/client/cl_input.cpp
new file mode 100644
index 0000000..e134646
--- /dev/null
+++ b/src/client/cl_input.cpp
@@ -0,0 +1,1194 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+// cl.input.c  -- builds an intended movement command to send to the server
+
+#include "client.h"
+
+unsigned frame_msec;
+int old_com_frameTime;
+
+/*
+===============================================================================
+
+KEY BUTTONS
+
+Continuous button event tracking is complicated by the fact that two different
+input sources (say, mouse button 1 and the control key) can both press the
+same button, but the button should only be released when both of the
+pressing key have been released.
+
+When a key event issues a button command (+forward, +attack, etc), it appends
+its key number as argv(1) so it can be matched up with the release.
+
+argv(2) will be set to the time the event happened, which allows exact
+control even at low framerates when the down and up events may both get qued
+at the same time.
+
+===============================================================================
+*/
+
+kbutton_t in_left, in_right, in_forward, in_back;
+kbutton_t in_lookup, in_lookdown, in_moveleft, in_moveright;
+kbutton_t in_strafe, in_speed;
+kbutton_t in_up, in_down;
+
+#ifdef USE_VOIP
+kbutton_t in_voiprecord;
+#endif
+
+kbutton_t in_buttons[16];
+
+bool in_mlooking;
+
+static void IN_CenterView(void)
+{
+    cl.viewangles[PITCH] = -SHORT2ANGLE( (clc.netchan.alternateProtocol == 2
+                                            ? cl.snap.alternatePs.delta_angles 
+                                            : cl.snap.ps.delta_angles)[PITCH] );
+}
+
+static void IN_MLookDown(void) 
+{
+    in_mlooking = true;
+}
+
+static void IN_MLookUp(void)
+{
+    in_mlooking = false;
+    if (!cl_freelook->integer)
+    {
+        IN_CenterView();
+    }
+}
+
+static void IN_KeyDown(kbutton_t *b)
+{
+    int k;
+
+    const char *c = Cmd_Argv(1);
+    if (c[0])
+    {
+        k = atoi(c);
+    }
+    else
+    {
+        k = -1;  // typed manually at the console for continuous down
+    }
+
+    if (k == b->down[0] || k == b->down[1])
+    {
+        return;  // repeating key
+    }
+
+    if (!b->down[0])
+    {
+        b->down[0] = k;
+    }
+    else if (!b->down[1])
+    {
+        b->down[1] = k;
+    }
+    else
+    {
+        Com_Printf("Three keys down for a button!\n");
+        return;
+    }
+
+    if (b->active)
+    {
+        return;  // still down
+    }
+
+    // save timestamp for partial frame summing
+    c = Cmd_Argv(2);
+    b->downtime = atoi(c);
+
+    b->active = true;
+    b->wasPressed = true;
+}
+
+static void IN_KeyUp(kbutton_t *b)
+{
+    int k;
+    unsigned uptime;
+
+    const char *c = Cmd_Argv(1);
+    if (c[0])
+    {
+        k = atoi(c);
+    }
+    else
+    {
+        // typed manually at the console, assume for unsticking, so clear all
+        b->down[0] = b->down[1] = 0;
+        b->active = false;
+        return;
+    }
+
+    if (b->down[0] == k)
+    {
+        b->down[0] = 0;
+    }
+    else if (b->down[1] == k)
+    {
+        b->down[1] = 0;
+    }
+    else
+    {
+        return;  // key up without coresponding down (menu pass through)
+    }
+    if (b->down[0] || b->down[1])
+    {
+        return;  // some other key is still holding it down
+    }
+
+    b->active = false;
+
+    // save timestamp for partial frame summing
+    c = Cmd_Argv(2);
+    uptime = atoi(c);
+    if (uptime)
+    {
+        b->msec += uptime - b->downtime;
+    }
+    else
+    {
+        b->msec += frame_msec / 2;
+    }
+
+    b->active = false;
+}
+
+/*
+===============
+CL_KeyState
+
+Returns the fraction of the frame that the key was down
+===============
+*/
+static float CL_KeyState(kbutton_t *key)
+{
+    float val;
+    int msec;
+
+    msec = key->msec;
+    key->msec = 0;
+
+    if (key->active)
+    {
+        // still down
+        if (!key->downtime)
+        {
+            msec = com_frameTime;
+        }
+        else
+        {
+            msec += com_frameTime - key->downtime;
+        }
+        key->downtime = com_frameTime;
+    }
+
+#if 0
+	if (msec) {
+		Com_Printf ("%i ", msec);
+	}
+#endif
+
+    val = (float)msec / frame_msec;
+    if (val < 0)
+    {
+        val = 0;
+    }
+    if (val > 1)
+    {
+        val = 1;
+    }
+
+    return val;
+}
+
+static void IN_UpDown(void) { IN_KeyDown(&in_up); }
+static void IN_UpUp(void) { IN_KeyUp(&in_up); }
+static void IN_DownDown(void) { IN_KeyDown(&in_down); }
+static void IN_DownUp(void) { IN_KeyUp(&in_down); }
+static void IN_LeftDown(void) { IN_KeyDown(&in_left); }
+static void IN_LeftUp(void) { IN_KeyUp(&in_left); }
+static void IN_RightDown(void) { IN_KeyDown(&in_right); }
+static void IN_RightUp(void) { IN_KeyUp(&in_right); }
+static void IN_ForwardDown(void) { IN_KeyDown(&in_forward); }
+static void IN_ForwardUp(void) { IN_KeyUp(&in_forward); }
+static void IN_BackDown(void) { IN_KeyDown(&in_back); }
+static void IN_BackUp(void) { IN_KeyUp(&in_back); }
+static void IN_LookupDown(void) { IN_KeyDown(&in_lookup); }
+static void IN_LookupUp(void) { IN_KeyUp(&in_lookup); }
+static void IN_LookdownDown(void) { IN_KeyDown(&in_lookdown); }
+static void IN_LookdownUp(void) { IN_KeyUp(&in_lookdown); }
+static void IN_MoveleftDown(void) { IN_KeyDown(&in_moveleft); }
+static void IN_MoveleftUp(void) { IN_KeyUp(&in_moveleft); }
+static void IN_MoverightDown(void) { IN_KeyDown(&in_moveright); }
+static void IN_MoverightUp(void) { IN_KeyUp(&in_moveright); }
+static void IN_SpeedDown(void) { IN_KeyDown(&in_speed); }
+static void IN_SpeedUp(void) { IN_KeyUp(&in_speed); }
+static void IN_StrafeDown(void) { IN_KeyDown(&in_strafe); }
+static void IN_StrafeUp(void) { IN_KeyUp(&in_strafe); }
+
+#ifdef USE_VOIP
+static void IN_VoipRecordDown(void)
+{
+    IN_KeyDown(&in_voiprecord);
+    Cvar_Set("cl_voipSend", "1");
+}
+
+static void IN_VoipRecordUp(void)
+{
+    IN_KeyUp(&in_voiprecord);
+    Cvar_Set("cl_voipSend", "0");
+}
+#endif
+
+static void IN_Button0Down(void) { IN_KeyDown(&in_buttons[0]); }
+static void IN_Button0Up(void) { IN_KeyUp(&in_buttons[0]); }
+static void IN_Button1Down(void) { IN_KeyDown(&in_buttons[1]); }
+static void IN_Button1Up(void) { IN_KeyUp(&in_buttons[1]); }
+static void IN_Button2Down(void) { IN_KeyDown(&in_buttons[2]); }
+static void IN_Button2Up(void) { IN_KeyUp(&in_buttons[2]); }
+static void IN_Button3Down(void) { IN_KeyDown(&in_buttons[3]); }
+static void IN_Button3Up(void) { IN_KeyUp(&in_buttons[3]); }
+static void IN_Button4Down(void) { IN_KeyDown(&in_buttons[4]); }
+static void IN_Button4Up(void) { IN_KeyUp(&in_buttons[4]); }
+static void IN_Button5Down(void) { IN_KeyDown(&in_buttons[5]); }
+static void IN_Button5Up(void) { IN_KeyUp(&in_buttons[5]); }
+static void IN_Button6Down(void) { IN_KeyDown(&in_buttons[6]); }
+static void IN_Button6Up(void) { IN_KeyUp(&in_buttons[6]); }
+static void IN_Button7Down(void) { IN_KeyDown(&in_buttons[7]); }
+static void IN_Button7Up(void) { IN_KeyUp(&in_buttons[7]); }
+static void IN_Button8Down(void) { IN_KeyDown(&in_buttons[8]); }
+static void IN_Button8Up(void) { IN_KeyUp(&in_buttons[8]); }
+static void IN_Button9Down(void) { IN_KeyDown(&in_buttons[9]); }
+static void IN_Button9Up(void) { IN_KeyUp(&in_buttons[9]); }
+static void IN_Button10Down(void) { IN_KeyDown(&in_buttons[10]); }
+static void IN_Button10Up(void) { IN_KeyUp(&in_buttons[10]); }
+static void IN_Button11Down(void) { IN_KeyDown(&in_buttons[11]); }
+static void IN_Button11Up(void) { IN_KeyUp(&in_buttons[11]); }
+static void IN_Button12Down(void) { IN_KeyDown(&in_buttons[12]); }
+static void IN_Button12Up(void) { IN_KeyUp(&in_buttons[12]); }
+static void IN_Button13Down(void) { IN_KeyDown(&in_buttons[13]); }
+static void IN_Button13Up(void) { IN_KeyUp(&in_buttons[13]); }
+static void IN_Button14Down(void) { IN_KeyDown(&in_buttons[14]); }
+static void IN_Button14Up(void) { IN_KeyUp(&in_buttons[14]); }
+static void IN_Button15Down(void) { IN_KeyDown(&in_buttons[15]); }
+static void IN_Button15Up(void) { IN_KeyUp(&in_buttons[15]); }
+
+//==========================================================================
+
+cvar_t *cl_yawspeed;
+cvar_t *cl_pitchspeed;
+
+cvar_t *cl_run;
+
+cvar_t *cl_anglespeedkey;
+
+/*
+================
+CL_AdjustAngles
+
+Moves the local angle positions
+================
+*/
+static void CL_AdjustAngles(void)
+{
+    float speed;
+
+    if (in_speed.active)
+    {
+        speed = 0.001 * cls.frametime * cl_anglespeedkey->value;
+    }
+    else
+    {
+        speed = 0.001 * cls.frametime;
+    }
+
+    if (!in_strafe.active)
+    {
+        cl.viewangles[YAW] -= speed * cl_yawspeed->value * CL_KeyState(&in_right);
+        cl.viewangles[YAW] += speed * cl_yawspeed->value * CL_KeyState(&in_left);
+    }
+
+    cl.viewangles[PITCH] -= speed * cl_pitchspeed->value * CL_KeyState(&in_lookup);
+    cl.viewangles[PITCH] += speed * cl_pitchspeed->value * CL_KeyState(&in_lookdown);
+}
+
+/*
+================
+CL_KeyMove
+
+Sets the usercmd_t based on key states
+================
+*/
+static void CL_KeyMove(usercmd_t *cmd)
+{
+    int movespeed;
+    int forward, side, up;
+
+    //
+    // adjust for speed key / running
+    // the walking flag is to keep animations consistant
+    // even during acceleration and develeration
+    //
+    if (in_speed.active ^ cl_run->integer)
+    {
+        movespeed = 127;
+        cmd->buttons &= ~BUTTON_WALKING;
+    }
+    else
+    {
+        cmd->buttons |= BUTTON_WALKING;
+        movespeed = 64;
+    }
+
+    forward = 0;
+    side = 0;
+    up = 0;
+    if (in_strafe.active)
+    {
+        side += movespeed * CL_KeyState(&in_right);
+        side -= movespeed * CL_KeyState(&in_left);
+    }
+
+    side += movespeed * CL_KeyState(&in_moveright);
+    side -= movespeed * CL_KeyState(&in_moveleft);
+
+    up += movespeed * CL_KeyState(&in_up);
+    up -= movespeed * CL_KeyState(&in_down);
+
+    forward += movespeed * CL_KeyState(&in_forward);
+    forward -= movespeed * CL_KeyState(&in_back);
+
+    cmd->forwardmove = ClampChar(forward);
+    cmd->rightmove = ClampChar(side);
+    cmd->upmove = ClampChar(up);
+}
+
+/*
+=================
+CL_MouseEvent
+=================
+*/
+void CL_MouseEvent(int dx, int dy, int time)
+{
+    if (Key_GetCatcher() & KEYCATCH_UI)
+    {
+        VM_Call(cls.ui, UI_MOUSE_EVENT, dx, dy);
+    }
+    else if (Key_GetCatcher() & KEYCATCH_CGAME)
+    {
+        VM_Call(cls.cgame, CG_MOUSE_EVENT, dx, dy);
+    }
+    else
+    {
+        cl.mouseDx[cl.mouseIndex] += dx;
+        cl.mouseDy[cl.mouseIndex] += dy;
+    }
+}
+
+/*
+=================
+CL_JoystickEvent
+
+Joystick values stay set until changed
+=================
+*/
+void CL_JoystickEvent(int axis, int value, int time)
+{
+    if (axis < 0 || axis >= MAX_JOYSTICK_AXIS)
+    {
+        Com_Error(ERR_DROP, "CL_JoystickEvent: bad axis %i", axis);
+    }
+    cl.joystickAxis[axis] = value;
+}
+
+/*
+=================
+CL_JoystickMove
+=================
+*/
+static void CL_JoystickMove(usercmd_t *cmd)
+{
+    float anglespeed;
+
+    float yaw = j_yaw->value * cl.joystickAxis[j_yaw_axis->integer];
+    float right = j_side->value * cl.joystickAxis[j_side_axis->integer];
+    float forward = j_forward->value * cl.joystickAxis[j_forward_axis->integer];
+    float pitch = j_pitch->value * cl.joystickAxis[j_pitch_axis->integer];
+    float up = j_up->value * cl.joystickAxis[j_up_axis->integer];
+
+    if (!(in_speed.active ^ cl_run->integer))
+    {
+        cmd->buttons |= BUTTON_WALKING;
+    }
+
+    if (in_speed.active)
+    {
+        anglespeed = 0.001 * cls.frametime * cl_anglespeedkey->value;
+    }
+    else
+    {
+        anglespeed = 0.001 * cls.frametime;
+    }
+
+    if (!in_strafe.active)
+    {
+        cl.viewangles[YAW] += anglespeed * yaw;
+        cmd->rightmove = ClampChar(cmd->rightmove + (int)right);
+    }
+    else
+    {
+        cl.viewangles[YAW] += anglespeed * right;
+        cmd->rightmove = ClampChar(cmd->rightmove + (int)yaw);
+    }
+
+    if (in_mlooking)
+    {
+        cl.viewangles[PITCH] += anglespeed * forward;
+        cmd->forwardmove = ClampChar(cmd->forwardmove + (int)pitch);
+    }
+    else
+    {
+        cl.viewangles[PITCH] += anglespeed * pitch;
+        cmd->forwardmove = ClampChar(cmd->forwardmove + (int)forward);
+    }
+
+    cmd->upmove = ClampChar(cmd->upmove + (int)up);
+}
+
+/*
+=================
+CL_MouseMove
+=================
+*/
+
+static void CL_MouseMove(usercmd_t *cmd)
+{
+    float mx, my;
+
+    // allow mouse smoothing
+    if (m_filter->integer)
+    {
+        mx = (cl.mouseDx[0] + cl.mouseDx[1]) * 0.5f;
+        my = (cl.mouseDy[0] + cl.mouseDy[1]) * 0.5f;
+    }
+    else
+    {
+        mx = cl.mouseDx[cl.mouseIndex];
+        my = cl.mouseDy[cl.mouseIndex];
+    }
+
+    cl.mouseIndex ^= 1;
+    cl.mouseDx[cl.mouseIndex] = 0;
+    cl.mouseDy[cl.mouseIndex] = 0;
+
+    if (mx == 0.0f && my == 0.0f) return;
+
+    if (cl_mouseAccel->value != 0.0f)
+    {
+        if (cl_mouseAccelStyle->integer == 0)
+        {
+            float accelSensitivity;
+            float rate;
+
+            rate = sqrt(mx * mx + my * my) / (float)frame_msec;
+
+            accelSensitivity = cl_sensitivity->value + rate * cl_mouseAccel->value;
+            mx *= accelSensitivity;
+            my *= accelSensitivity;
+
+            if (cl_showMouseRate->integer) Com_Printf("rate: %f, accelSensitivity: %f\n", rate, accelSensitivity);
+        }
+        else
+        {
+            float rate[2];
+            float power[2];
+
+            // sensitivity remains pretty much unchanged at low speeds
+            // cl_mouseAccel is a power value to how the acceleration is shaped
+            // cl_mouseAccelOffset is the rate for which the acceleration will have doubled the non accelerated
+            // amplification
+            // NOTE: decouple the config cvars for independent acceleration setup along X and Y?
+
+            rate[0] = fabs(mx) / (float)frame_msec;
+            rate[1] = fabs(my) / (float)frame_msec;
+            power[0] = powf(rate[0] / cl_mouseAccelOffset->value, cl_mouseAccel->value);
+            power[1] = powf(rate[1] / cl_mouseAccelOffset->value, cl_mouseAccel->value);
+
+            mx = cl_sensitivity->value * (mx + ((mx < 0) ? -power[0] : power[0]) * cl_mouseAccelOffset->value);
+            my = cl_sensitivity->value * (my + ((my < 0) ? -power[1] : power[1]) * cl_mouseAccelOffset->value);
+
+            if (cl_showMouseRate->integer)
+                Com_Printf("ratex: %f, ratey: %f, powx: %f, powy: %f\n", rate[0], rate[1], power[0], power[1]);
+        }
+    }
+    else
+    {
+        mx *= cl_sensitivity->value;
+        my *= cl_sensitivity->value;
+    }
+
+    // ingame FOV
+    mx *= cl.cgameSensitivity;
+    my *= cl.cgameSensitivity;
+
+    // add mouse X/Y movement to cmd
+    if (in_strafe.active)
+        cmd->rightmove = ClampChar(cmd->rightmove + m_side->value * mx);
+    else
+        cl.viewangles[YAW] -= m_yaw->value * mx;
+
+    if ((in_mlooking || cl_freelook->integer) && !in_strafe.active)
+        cl.viewangles[PITCH] += m_pitch->value * my;
+    else
+        cmd->forwardmove = ClampChar(cmd->forwardmove - m_forward->value * my);
+}
+
+/*
+==============
+CL_CmdButtons
+==============
+*/
+static void CL_CmdButtons(usercmd_t *cmd)
+{
+    int i;
+
+    //
+    // figure button bits
+    // send a button bit even if the key was pressed and released in
+    // less than a frame
+    //
+    for (i = 0; i < 15; i++)
+    {
+        if (in_buttons[i].active || in_buttons[i].wasPressed)
+        {
+            cmd->buttons |= 1 << i;
+        }
+        in_buttons[i].wasPressed = false;
+    }
+
+    if (Key_GetCatcher())
+    {
+        cmd->buttons |= BUTTON_TALK;
+    }
+
+    // allow the game to know if any key at all is
+    // currently pressed, even if it isn't bound to anything
+    if (anykeydown && Key_GetCatcher() == 0)
+    {
+        cmd->buttons |= BUTTON_ANY;
+    }
+}
+
+/*
+==============
+CL_FinishMove
+==============
+*/
+static void CL_FinishMove(usercmd_t *cmd)
+{
+    int i;
+
+    // copy the state that the cgame is currently sending
+    cmd->weapon = cl.cgameUserCmdValue;
+
+    // send the current server time so the amount of movement
+    // can be determined without allowing cheating
+    cmd->serverTime = cl.serverTime;
+
+    for (i = 0; i < 3; i++)
+    {
+        cmd->angles[i] = ANGLE2SHORT(cl.viewangles[i]);
+    }
+}
+
+/*
+=================
+CL_CreateCmd
+=================
+*/
+static usercmd_t CL_CreateCmd(void)
+{
+    usercmd_t cmd;
+    vec3_t oldAngles;
+
+    VectorCopy(cl.viewangles, oldAngles);
+
+    // keyboard angle adjustment
+    CL_AdjustAngles();
+
+    ::memset(&cmd, 0, sizeof(cmd));
+
+    CL_CmdButtons(&cmd);
+
+    // get basic movement from keyboard
+    CL_KeyMove(&cmd);
+
+    // get basic movement from mouse
+    CL_MouseMove(&cmd);
+
+    // get basic movement from joystick
+    CL_JoystickMove(&cmd);
+
+    // check to make sure the angles haven't wrapped
+    if (cl.viewangles[PITCH] - oldAngles[PITCH] > 90)
+    {
+        cl.viewangles[PITCH] = oldAngles[PITCH] + 90;
+    }
+    else if (oldAngles[PITCH] - cl.viewangles[PITCH] > 90)
+    {
+        cl.viewangles[PITCH] = oldAngles[PITCH] - 90;
+    }
+
+    // store out the final values
+    CL_FinishMove(&cmd);
+
+    // draw debug graphs of turning for mouse testing
+    if (cl_debugMove->integer)
+    {
+        if (cl_debugMove->integer == 1)
+        {
+            SCR_DebugGraph(fabs(cl.viewangles[YAW] - oldAngles[YAW]));
+        }
+        if (cl_debugMove->integer == 2)
+        {
+            SCR_DebugGraph(fabs(cl.viewangles[PITCH] - oldAngles[PITCH]));
+        }
+    }
+
+    return cmd;
+}
+
+/*
+=================
+CL_CreateNewCommands
+
+Create a new usercmd_t structure for this frame
+=================
+*/
+static void CL_CreateNewCommands(void)
+{
+    int cmdNum;
+
+    // no need to create usercmds until we have a gamestate
+    if (clc.state < CA_PRIMED)
+    {
+        return;
+    }
+
+    frame_msec = com_frameTime - old_com_frameTime;
+
+    // if running over 1000fps, act as if each frame is 1ms
+    // prevents divisions by zero
+    if (frame_msec < 1)
+    {
+        frame_msec = 1;
+    }
+
+    // if running less than 5fps, truncate the extra time to prevent
+    // unexpected moves after a hitch
+    if (frame_msec > 200)
+    {
+        frame_msec = 200;
+    }
+    old_com_frameTime = com_frameTime;
+
+    // generate a command for this frame
+    cl.cmdNumber++;
+    cmdNum = cl.cmdNumber & CMD_MASK;
+    cl.cmds[cmdNum] = CL_CreateCmd();
+}
+
+/*
+=================
+CL_ReadyToSendPacket
+
+Returns false if we are over the maxpackets limit
+and should choke back the bandwidth a bit by not sending
+a packet this frame.  All the commands will still get
+delivered in the next packet, but saving a header and
+getting more delta compression will reduce total bandwidth.
+=================
+*/
+static bool CL_ReadyToSendPacket(void)
+{
+    int oldPacketNum;
+    int delta;
+
+    // don't send anything if playing back a demo
+    if (clc.demoplaying || clc.state == CA_CINEMATIC)
+    {
+        return false;
+    }
+
+    // If we are downloading, we send no less than 50ms between packets
+    if (*clc.downloadTempName && cls.realtime - clc.lastPacketSentTime < 50)
+    {
+        return false;
+    }
+
+    // if we don't have a valid gamestate yet, only send
+    // one packet a second
+    if (clc.state != CA_ACTIVE && clc.state != CA_PRIMED && !*clc.downloadTempName &&
+        cls.realtime - clc.lastPacketSentTime < 1000)
+    {
+        return false;
+    }
+
+    // send every frame for loopbacks
+    if (clc.netchan.remoteAddress.type == NA_LOOPBACK)
+    {
+        return true;
+    }
+
+    // send every frame for LAN
+    if (cl_lanForcePackets->integer && Sys_IsLANAddress(clc.netchan.remoteAddress))
+    {
+        return true;
+    }
+
+    // check for exceeding cl_maxpackets
+    if (cl_maxpackets->integer < 15)
+    {
+        Cvar_Set("cl_maxpackets", "15");
+    }
+    else if (cl_maxpackets->integer > 125)
+    {
+        Cvar_Set("cl_maxpackets", "125");
+    }
+    oldPacketNum = (clc.netchan.outgoingSequence - 1) & PACKET_MASK;
+    delta = cls.realtime - cl.outPackets[oldPacketNum].p_realtime;
+    if (delta < 1000 / cl_maxpackets->integer)
+    {
+        // the accumulated commands will go out in the next packet
+        return false;
+    }
+
+    return true;
+}
+
+/*
+===================
+CL_WritePacket
+
+Create and send the command packet to the server
+Including both the reliable commands and the usercmds
+
+During normal gameplay, a client packet will contain something like:
+
+4	sequence number
+2	qport
+4	serverid
+4	acknowledged sequence number
+4	clc.serverCommandSequence
+<optional reliable commands>
+1	clc_move or clc_moveNoDelta
+1	command count
+<count * usercmds>
+
+===================
+*/
+void CL_WritePacket(void)
+{
+    msg_t buf;
+    byte data[MAX_MSGLEN];
+    int i, j;
+    usercmd_t *cmd, *oldcmd;
+    usercmd_t nullcmd;
+    int packetNum;
+    int oldPacketNum;
+    int count, key;
+
+    // don't send anything if playing back a demo
+    if (clc.demoplaying || clc.state == CA_CINEMATIC)
+    {
+        return;
+    }
+
+    ::memset(&nullcmd, 0, sizeof(nullcmd));
+    oldcmd = &nullcmd;
+
+    MSG_Init(&buf, data, sizeof(data));
+
+    MSG_Bitstream(&buf);
+    // write the current serverId so the server
+    // can tell if this is from the current gameState
+    MSG_WriteLong(&buf, cl.serverId);
+
+    // write the last message we received, which can
+    // be used for delta compression, and is also used
+    // to tell if we dropped a gamestate
+    MSG_WriteLong(&buf, clc.serverMessageSequence);
+
+    // write the last reliable message we received
+    MSG_WriteLong(&buf, clc.serverCommandSequence);
+
+    // write any unacknowledged clientCommands
+    for (i = clc.reliableAcknowledge + 1; i <= clc.reliableSequence; i++)
+    {
+        MSG_WriteByte(&buf, clc_clientCommand);
+        MSG_WriteLong(&buf, i);
+        MSG_WriteString(&buf, clc.reliableCommands[i & (MAX_RELIABLE_COMMANDS - 1)]);
+    }
+
+    // we want to send all the usercmds that were generated in the last
+    // few packet, so even if a couple packets are dropped in a row,
+    // all the cmds will make it to the server
+    if (cl_packetdup->integer < 0)
+    {
+        Cvar_Set("cl_packetdup", "0");
+    }
+    else if (cl_packetdup->integer > 5)
+    {
+        Cvar_Set("cl_packetdup", "5");
+    }
+    oldPacketNum = (clc.netchan.outgoingSequence - 1 - cl_packetdup->integer) & PACKET_MASK;
+    count = cl.cmdNumber - cl.outPackets[oldPacketNum].p_cmdNumber;
+    if (count > MAX_PACKET_USERCMDS)
+    {
+        count = MAX_PACKET_USERCMDS;
+        Com_Printf("MAX_PACKET_USERCMDS\n");
+    }
+
+#ifdef USE_VOIP
+    if (clc.voipOutgoingDataSize > 0)
+    {
+        if ((clc.voipFlags & VOIP_SPATIAL) || Com_IsVoipTarget(clc.voipTargets, sizeof(clc.voipTargets), -1))
+        {
+            if (clc.netchan.alternateProtocol != 0)
+            {
+                MSG_WriteByte(&buf, clc_EOF);
+            }
+            MSG_WriteByte(&buf, clc_voipSpeex);
+            if (clc.netchan.alternateProtocol != 0)
+            {
+                MSG_WriteByte(&buf, clc_voipSpeex + 1);
+            }
+            MSG_WriteByte(&buf, clc.voipOutgoingGeneration);
+            MSG_WriteLong(&buf, clc.voipOutgoingSequence);
+            MSG_WriteByte(&buf, clc.voipOutgoingDataFrames);
+            if (clc.netchan.alternateProtocol == 0)
+            {
+                MSG_WriteData(&buf, clc.voipTargets, sizeof(clc.voipTargets));
+                MSG_WriteByte(&buf, clc.voipFlags);
+            }
+            else
+            {
+                MSG_WriteLong(&buf, clc.voipTargets[0] | (clc.voipTargets[1] << 8) | (clc.voipTargets[2] << 16) |
+                                        ((clc.voipTargets[3] & 0x7F) << 24));
+                MSG_WriteLong(&buf, (clc.voipTargets[3] >> 7) | (clc.voipTargets[4] << 1) | (clc.voipTargets[5] << 9) |
+                                        (clc.voipTargets[6] << 17) | ((clc.voipTargets[7] & 0x3F) << 25));
+                MSG_WriteLong(&buf, clc.voipTargets[7] >> 6);
+            }
+            MSG_WriteShort(&buf, clc.voipOutgoingDataSize);
+            MSG_WriteData(&buf, clc.voipOutgoingData, clc.voipOutgoingDataSize);
+
+            // If we're recording a demo, we have to fake a server packet with
+            //  this VoIP data so it gets to disk; the server doesn't send it
+            //  back to us, and we might as well eliminate concerns about dropped
+            //  and misordered packets here.
+            if (clc.demorecording && !clc.demowaiting)
+            {
+                const int voipSize = clc.voipOutgoingDataSize;
+                msg_t fakemsg;
+                byte fakedata[MAX_MSGLEN];
+                MSG_Init(&fakemsg, fakedata, sizeof(fakedata));
+                MSG_Bitstream(&fakemsg);
+                MSG_WriteLong(&fakemsg, clc.reliableAcknowledge);
+                MSG_WriteByte(&fakemsg, svc_voipOpus);
+                MSG_WriteShort(&fakemsg, clc.clientNum);
+                MSG_WriteByte(&fakemsg, clc.voipOutgoingGeneration);
+                MSG_WriteLong(&fakemsg, clc.voipOutgoingSequence);
+                MSG_WriteByte(&fakemsg, clc.voipOutgoingDataFrames);
+                MSG_WriteShort(&fakemsg, clc.voipOutgoingDataSize);
+                if (clc.netchan.alternateProtocol == 0)
+                {
+                    MSG_WriteBits(&fakemsg, clc.voipFlags, VOIP_FLAGCNT);
+                }
+                MSG_WriteData(&fakemsg, clc.voipOutgoingData, voipSize);
+                MSG_WriteByte(&fakemsg, svc_EOF);
+                CL_WriteDemoMessage(&fakemsg, 0);
+            }
+
+            clc.voipOutgoingSequence += clc.voipOutgoingDataFrames;
+            clc.voipOutgoingDataSize = 0;
+            clc.voipOutgoingDataFrames = 0;
+        }
+        else
+        {
+            // We have data, but no targets. Silently discard all data
+            clc.voipOutgoingDataSize = 0;
+            clc.voipOutgoingDataFrames = 0;
+        }
+    }
+#endif
+
+    if (count >= 1)
+    {
+        if (cl_showSend->integer)
+        {
+            Com_Printf("(%i)", count);
+        }
+
+        // begin a client move command
+        if (cl_nodelta->integer || !cl.snap.valid || clc.demowaiting || clc.serverMessageSequence != cl.snap.messageNum)
+        {
+            MSG_WriteByte(&buf, clc_moveNoDelta);
+        }
+        else
+        {
+            MSG_WriteByte(&buf, clc_move);
+        }
+
+        // write the command count
+        MSG_WriteByte(&buf, count);
+
+        // use the checksum feed in the key
+        key = clc.checksumFeed;
+        // also use the message acknowledge
+        key ^= clc.serverMessageSequence;
+        // also use the last acknowledged server command in the key
+        key ^= MSG_HashKey(clc.netchan.alternateProtocol,
+            clc.serverCommands[clc.serverCommandSequence & (MAX_RELIABLE_COMMANDS - 1)], 32);
+
+        // write all the commands, including the predicted command
+        for (i = 0; i < count; i++)
+        {
+            j = (cl.cmdNumber - count + i + 1) & CMD_MASK;
+            cmd = &cl.cmds[j];
+            MSG_WriteDeltaUsercmdKey(&buf, key, oldcmd, cmd);
+            oldcmd = cmd;
+        }
+    }
+
+    //
+    // deliver the message
+    //
+    packetNum = clc.netchan.outgoingSequence & PACKET_MASK;
+    cl.outPackets[packetNum].p_realtime = cls.realtime;
+    cl.outPackets[packetNum].p_serverTime = oldcmd->serverTime;
+    cl.outPackets[packetNum].p_cmdNumber = cl.cmdNumber;
+    clc.lastPacketSentTime = cls.realtime;
+
+    if (cl_showSend->integer)
+    {
+        Com_Printf("%i ", buf.cursize);
+    }
+
+    CL_Netchan_Transmit(&clc.netchan, &buf);
+}
+
+/*
+=================
+CL_SendCmd
+
+Called every frame to builds and sends a command packet to the server.
+=================
+*/
+void CL_SendCmd(void)
+{
+    // don't send any message if not connected
+    if (clc.state < CA_CONNECTED)
+    {
+        return;
+    }
+
+    // don't send commands if paused
+    if (com_sv_running->integer && sv_paused->integer && cl_paused->integer)
+    {
+        return;
+    }
+
+    // we create commands even if a demo is playing,
+    CL_CreateNewCommands();
+
+    // don't send a packet if the last packet was sent too recently
+    if (!CL_ReadyToSendPacket())
+    {
+        if (cl_showSend->integer)
+        {
+            Com_Printf(". ");
+        }
+        return;
+    }
+
+    CL_WritePacket();
+}
+
+/*
+============
+CL_InitInput
+============
+*/
+void CL_InitInput(void)
+{
+    Cmd_AddCommand("centerview", IN_CenterView);
+
+    Cmd_AddCommand("+moveup", IN_UpDown);
+    Cmd_AddCommand("-moveup", IN_UpUp);
+    Cmd_AddCommand("+movedown", IN_DownDown);
+    Cmd_AddCommand("-movedown", IN_DownUp);
+    Cmd_AddCommand("+left", IN_LeftDown);
+    Cmd_AddCommand("-left", IN_LeftUp);
+    Cmd_AddCommand("+right", IN_RightDown);
+    Cmd_AddCommand("-right", IN_RightUp);
+    Cmd_AddCommand("+forward", IN_ForwardDown);
+    Cmd_AddCommand("-forward", IN_ForwardUp);
+    Cmd_AddCommand("+back", IN_BackDown);
+    Cmd_AddCommand("-back", IN_BackUp);
+    Cmd_AddCommand("+lookup", IN_LookupDown);
+    Cmd_AddCommand("-lookup", IN_LookupUp);
+    Cmd_AddCommand("+lookdown", IN_LookdownDown);
+    Cmd_AddCommand("-lookdown", IN_LookdownUp);
+    Cmd_AddCommand("+strafe", IN_StrafeDown);
+    Cmd_AddCommand("-strafe", IN_StrafeUp);
+    Cmd_AddCommand("+moveleft", IN_MoveleftDown);
+    Cmd_AddCommand("-moveleft", IN_MoveleftUp);
+    Cmd_AddCommand("+moveright", IN_MoverightDown);
+    Cmd_AddCommand("-moveright", IN_MoverightUp);
+    Cmd_AddCommand("+speed", IN_SpeedDown);
+    Cmd_AddCommand("-speed", IN_SpeedUp);
+    Cmd_AddCommand("+attack", IN_Button0Down);
+    Cmd_AddCommand("-attack", IN_Button0Up);
+    Cmd_AddCommand("+button0", IN_Button0Down);
+    Cmd_AddCommand("-button0", IN_Button0Up);
+    Cmd_AddCommand("+button1", IN_Button1Down);
+    Cmd_AddCommand("-button1", IN_Button1Up);
+    Cmd_AddCommand("+button2", IN_Button2Down);
+    Cmd_AddCommand("-button2", IN_Button2Up);
+    Cmd_AddCommand("+button3", IN_Button3Down);
+    Cmd_AddCommand("-button3", IN_Button3Up);
+    Cmd_AddCommand("+button4", IN_Button4Down);
+    Cmd_AddCommand("-button4", IN_Button4Up);
+    Cmd_AddCommand("+button5", IN_Button5Down);
+    Cmd_AddCommand("-button5", IN_Button5Up);
+    Cmd_AddCommand("+button6", IN_Button6Down);
+    Cmd_AddCommand("-button6", IN_Button6Up);
+    Cmd_AddCommand("+button7", IN_Button7Down);
+    Cmd_AddCommand("-button7", IN_Button7Up);
+    Cmd_AddCommand("+button8", IN_Button8Down);
+    Cmd_AddCommand("-button8", IN_Button8Up);
+    Cmd_AddCommand("+button9", IN_Button9Down);
+    Cmd_AddCommand("-button9", IN_Button9Up);
+    Cmd_AddCommand("+button10", IN_Button10Down);
+    Cmd_AddCommand("-button10", IN_Button10Up);
+    Cmd_AddCommand("+button11", IN_Button11Down);
+    Cmd_AddCommand("-button11", IN_Button11Up);
+    Cmd_AddCommand("+button12", IN_Button12Down);
+    Cmd_AddCommand("-button12", IN_Button12Up);
+    Cmd_AddCommand("+button13", IN_Button13Down);
+    Cmd_AddCommand("-button13", IN_Button13Up);
+    Cmd_AddCommand("+button14", IN_Button14Down);
+    Cmd_AddCommand("-button14", IN_Button14Up);
+    Cmd_AddCommand("+mlook", IN_MLookDown);
+    Cmd_AddCommand("-mlook", IN_MLookUp);
+
+#ifdef USE_VOIP
+    Cmd_AddCommand("+voiprecord", IN_VoipRecordDown);
+    Cmd_AddCommand("-voiprecord", IN_VoipRecordUp);
+#endif
+
+    cl_nodelta = Cvar_Get("cl_nodelta", "0", 0);
+    cl_debugMove = Cvar_Get("cl_debugMove", "0", 0);
+}
+
+/*
+============
+CL_ShutdownInput
+============
+*/
+void CL_ShutdownInput(void)
+{
+    Cmd_RemoveCommand("centerview");
+
+    Cmd_RemoveCommand("+moveup");
+    Cmd_RemoveCommand("-moveup");
+    Cmd_RemoveCommand("+movedown");
+    Cmd_RemoveCommand("-movedown");
+    Cmd_RemoveCommand("+left");
+    Cmd_RemoveCommand("-left");
+    Cmd_RemoveCommand("+right");
+    Cmd_RemoveCommand("-right");
+    Cmd_RemoveCommand("+forward");
+    Cmd_RemoveCommand("-forward");
+    Cmd_RemoveCommand("+back");
+    Cmd_RemoveCommand("-back");
+    Cmd_RemoveCommand("+lookup");
+    Cmd_RemoveCommand("-lookup");
+    Cmd_RemoveCommand("+lookdown");
+    Cmd_RemoveCommand("-lookdown");
+    Cmd_RemoveCommand("+strafe");
+    Cmd_RemoveCommand("-strafe");
+    Cmd_RemoveCommand("+moveleft");
+    Cmd_RemoveCommand("-moveleft");
+    Cmd_RemoveCommand("+moveright");
+    Cmd_RemoveCommand("-moveright");
+    Cmd_RemoveCommand("+speed");
+    Cmd_RemoveCommand("-speed");
+    Cmd_RemoveCommand("+attack");
+    Cmd_RemoveCommand("-attack");
+    Cmd_RemoveCommand("+button0");
+    Cmd_RemoveCommand("-button0");
+    Cmd_RemoveCommand("+button1");
+    Cmd_RemoveCommand("-button1");
+    Cmd_RemoveCommand("+button2");
+    Cmd_RemoveCommand("-button2");
+    Cmd_RemoveCommand("+button3");
+    Cmd_RemoveCommand("-button3");
+    Cmd_RemoveCommand("+button4");
+    Cmd_RemoveCommand("-button4");
+    Cmd_RemoveCommand("+button5");
+    Cmd_RemoveCommand("-button5");
+    Cmd_RemoveCommand("+button6");
+    Cmd_RemoveCommand("-button6");
+    Cmd_RemoveCommand("+button7");
+    Cmd_RemoveCommand("-button7");
+    Cmd_RemoveCommand("+button8");
+    Cmd_RemoveCommand("-button8");
+    Cmd_RemoveCommand("+button9");
+    Cmd_RemoveCommand("-button9");
+    Cmd_RemoveCommand("+button10");
+    Cmd_RemoveCommand("-button10");
+    Cmd_RemoveCommand("+button11");
+    Cmd_RemoveCommand("-button11");
+    Cmd_RemoveCommand("+button12");
+    Cmd_RemoveCommand("-button12");
+    Cmd_RemoveCommand("+button13");
+    Cmd_RemoveCommand("-button13");
+    Cmd_RemoveCommand("+button14");
+    Cmd_RemoveCommand("-button14");
+    Cmd_RemoveCommand("+mlook");
+    Cmd_RemoveCommand("-mlook");
+
+#ifdef USE_VOIP
+    Cmd_RemoveCommand("+voiprecord");
+    Cmd_RemoveCommand("-voiprecord");
+#endif
+}
diff --git a/src/client/cl_keys.cpp b/src/client/cl_keys.cpp
new file mode 100644
index 0000000..82f5666
--- /dev/null
+++ b/src/client/cl_keys.cpp
@@ -0,0 +1,1665 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include "client.h"
+
+/*
+
+key up events are sent even if in console mode
+
+*/
+
+field_t	historyEditLines[COMMAND_HISTORY];
+
+int nextHistoryLine; // the last line in the history buffer, not masked
+int historyLine;	// the line being displayed from history buffer will be <= nextHistoryLine
+
+field_t g_consoleField;
+
+field_t chatField;
+bool chat_team;
+bool chat_admins;
+bool chat_clans;
+int chat_playerNum;
+
+bool key_overstrikeMode;
+
+int anykeydown;
+qkey_t keys[MAX_KEYS];
+
+struct keyname_t {
+	const char* name;
+	int keynum;
+};
+
+// names not in this list can either be lowercase ascii, or '0xnn' hex sequences
+keyname_t keynames[] =
+{
+	{"TAB", K_TAB},
+	{"ENTER", K_ENTER},
+	{"ESCAPE", K_ESCAPE},
+	{"SPACE", K_SPACE},
+	{"BACKSPACE", K_BACKSPACE},
+	{"UPARROW", K_UPARROW},
+	{"DOWNARROW", K_DOWNARROW},
+	{"LEFTARROW", K_LEFTARROW},
+	{"RIGHTARROW", K_RIGHTARROW},
+
+	{"ALT", K_ALT},
+	{"CTRL", K_CTRL},
+	{"SHIFT", K_SHIFT},
+
+	{"COMMAND", K_COMMAND},
+
+	{"CAPSLOCK", K_CAPSLOCK},
+
+	{"F1", K_F1},
+	{"F2", K_F2},
+	{"F3", K_F3},
+	{"F4", K_F4},
+	{"F5", K_F5},
+	{"F6", K_F6},
+	{"F7", K_F7},
+	{"F8", K_F8},
+	{"F9", K_F9},
+	{"F10", K_F10},
+	{"F11", K_F11},
+	{"F12", K_F12},
+	{"F13", K_F13},
+	{"F14", K_F14},
+	{"F15", K_F15},
+
+	{"INS", K_INS},
+	{"DEL", K_DEL},
+	{"PGDN", K_PGDN},
+	{"PGUP", K_PGUP},
+	{"HOME", K_HOME},
+	{"END", K_END},
+
+	{"MOUSE1", K_MOUSE1},
+	{"MOUSE2", K_MOUSE2},
+	{"MOUSE3", K_MOUSE3},
+	{"MOUSE4", K_MOUSE4},
+	{"MOUSE5", K_MOUSE5},
+
+	{"MWHEELUP",	K_MWHEELUP },
+	{"MWHEELDOWN",	K_MWHEELDOWN },
+
+	{"JOY1", K_JOY1},
+	{"JOY2", K_JOY2},
+	{"JOY3", K_JOY3},
+	{"JOY4", K_JOY4},
+	{"JOY5", K_JOY5},
+	{"JOY6", K_JOY6},
+	{"JOY7", K_JOY7},
+	{"JOY8", K_JOY8},
+	{"JOY9", K_JOY9},
+	{"JOY10", K_JOY10},
+	{"JOY11", K_JOY11},
+	{"JOY12", K_JOY12},
+	{"JOY13", K_JOY13},
+	{"JOY14", K_JOY14},
+	{"JOY15", K_JOY15},
+	{"JOY16", K_JOY16},
+	{"JOY17", K_JOY17},
+	{"JOY18", K_JOY18},
+	{"JOY19", K_JOY19},
+	{"JOY20", K_JOY20},
+	{"JOY21", K_JOY21},
+	{"JOY22", K_JOY22},
+	{"JOY23", K_JOY23},
+	{"JOY24", K_JOY24},
+	{"JOY25", K_JOY25},
+	{"JOY26", K_JOY26},
+	{"JOY27", K_JOY27},
+	{"JOY28", K_JOY28},
+	{"JOY29", K_JOY29},
+	{"JOY30", K_JOY30},
+	{"JOY31", K_JOY31},
+	{"JOY32", K_JOY32},
+
+	{"AUX1", K_AUX1},
+	{"AUX2", K_AUX2},
+	{"AUX3", K_AUX3},
+	{"AUX4", K_AUX4},
+	{"AUX5", K_AUX5},
+	{"AUX6", K_AUX6},
+	{"AUX7", K_AUX7},
+	{"AUX8", K_AUX8},
+	{"AUX9", K_AUX9},
+	{"AUX10", K_AUX10},
+	{"AUX11", K_AUX11},
+	{"AUX12", K_AUX12},
+	{"AUX13", K_AUX13},
+	{"AUX14", K_AUX14},
+	{"AUX15", K_AUX15},
+	{"AUX16", K_AUX16},
+
+	{"KP_HOME",			K_KP_HOME },
+	{"KP_UPARROW",		K_KP_UPARROW },
+	{"KP_PGUP",			K_KP_PGUP },
+	{"KP_LEFTARROW",	K_KP_LEFTARROW },
+	{"KP_5",			K_KP_5 },
+	{"KP_RIGHTARROW",	K_KP_RIGHTARROW },
+	{"KP_END",			K_KP_END },
+	{"KP_DOWNARROW",	K_KP_DOWNARROW },
+	{"KP_PGDN",			K_KP_PGDN },
+	{"KP_ENTER",		K_KP_ENTER },
+	{"KP_INS",			K_KP_INS },
+	{"KP_DEL",			K_KP_DEL },
+	{"KP_SLASH",		K_KP_SLASH },
+	{"KP_MINUS",		K_KP_MINUS },
+	{"KP_PLUS",			K_KP_PLUS },
+	{"KP_NUMLOCK",		K_KP_NUMLOCK },
+	{"KP_STAR",			K_KP_STAR },
+	{"KP_EQUALS",		K_KP_EQUALS },
+
+	{"PAUSE", K_PAUSE},
+
+	{"SEMICOLON", ';'},	// because a raw semicolon seperates commands
+
+	{"WORLD_0", K_WORLD_0},
+	{"WORLD_1", K_WORLD_1},
+	{"WORLD_2", K_WORLD_2},
+	{"WORLD_3", K_WORLD_3},
+	{"WORLD_4", K_WORLD_4},
+	{"WORLD_5", K_WORLD_5},
+	{"WORLD_6", K_WORLD_6},
+	{"WORLD_7", K_WORLD_7},
+	{"WORLD_8", K_WORLD_8},
+	{"WORLD_9", K_WORLD_9},
+	{"WORLD_10", K_WORLD_10},
+	{"WORLD_11", K_WORLD_11},
+	{"WORLD_12", K_WORLD_12},
+	{"WORLD_13", K_WORLD_13},
+	{"WORLD_14", K_WORLD_14},
+	{"WORLD_15", K_WORLD_15},
+	{"WORLD_16", K_WORLD_16},
+	{"WORLD_17", K_WORLD_17},
+	{"WORLD_18", K_WORLD_18},
+	{"WORLD_19", K_WORLD_19},
+	{"WORLD_20", K_WORLD_20},
+	{"WORLD_21", K_WORLD_21},
+	{"WORLD_22", K_WORLD_22},
+	{"WORLD_23", K_WORLD_23},
+	{"WORLD_24", K_WORLD_24},
+	{"WORLD_25", K_WORLD_25},
+	{"WORLD_26", K_WORLD_26},
+	{"WORLD_27", K_WORLD_27},
+	{"WORLD_28", K_WORLD_28},
+	{"WORLD_29", K_WORLD_29},
+	{"WORLD_30", K_WORLD_30},
+	{"WORLD_31", K_WORLD_31},
+	{"WORLD_32", K_WORLD_32},
+	{"WORLD_33", K_WORLD_33},
+	{"WORLD_34", K_WORLD_34},
+	{"WORLD_35", K_WORLD_35},
+	{"WORLD_36", K_WORLD_36},
+	{"WORLD_37", K_WORLD_37},
+	{"WORLD_38", K_WORLD_38},
+	{"WORLD_39", K_WORLD_39},
+	{"WORLD_40", K_WORLD_40},
+	{"WORLD_41", K_WORLD_41},
+	{"WORLD_42", K_WORLD_42},
+	{"WORLD_43", K_WORLD_43},
+	{"WORLD_44", K_WORLD_44},
+	{"WORLD_45", K_WORLD_45},
+	{"WORLD_46", K_WORLD_46},
+	{"WORLD_47", K_WORLD_47},
+	{"WORLD_48", K_WORLD_48},
+	{"WORLD_49", K_WORLD_49},
+	{"WORLD_50", K_WORLD_50},
+	{"WORLD_51", K_WORLD_51},
+	{"WORLD_52", K_WORLD_52},
+	{"WORLD_53", K_WORLD_53},
+	{"WORLD_54", K_WORLD_54},
+	{"WORLD_55", K_WORLD_55},
+	{"WORLD_56", K_WORLD_56},
+	{"WORLD_57", K_WORLD_57},
+	{"WORLD_58", K_WORLD_58},
+	{"WORLD_59", K_WORLD_59},
+	{"WORLD_60", K_WORLD_60},
+	{"WORLD_61", K_WORLD_61},
+	{"WORLD_62", K_WORLD_62},
+	{"WORLD_63", K_WORLD_63},
+	{"WORLD_64", K_WORLD_64},
+	{"WORLD_65", K_WORLD_65},
+	{"WORLD_66", K_WORLD_66},
+	{"WORLD_67", K_WORLD_67},
+	{"WORLD_68", K_WORLD_68},
+	{"WORLD_69", K_WORLD_69},
+	{"WORLD_70", K_WORLD_70},
+	{"WORLD_71", K_WORLD_71},
+	{"WORLD_72", K_WORLD_72},
+	{"WORLD_73", K_WORLD_73},
+	{"WORLD_74", K_WORLD_74},
+	{"WORLD_75", K_WORLD_75},
+	{"WORLD_76", K_WORLD_76},
+	{"WORLD_77", K_WORLD_77},
+	{"WORLD_78", K_WORLD_78},
+	{"WORLD_79", K_WORLD_79},
+	{"WORLD_80", K_WORLD_80},
+	{"WORLD_81", K_WORLD_81},
+	{"WORLD_82", K_WORLD_82},
+	{"WORLD_83", K_WORLD_83},
+	{"WORLD_84", K_WORLD_84},
+	{"WORLD_85", K_WORLD_85},
+	{"WORLD_86", K_WORLD_86},
+	{"WORLD_87", K_WORLD_87},
+	{"WORLD_88", K_WORLD_88},
+	{"WORLD_89", K_WORLD_89},
+	{"WORLD_90", K_WORLD_90},
+	{"WORLD_91", K_WORLD_91},
+	{"WORLD_92", K_WORLD_92},
+	{"WORLD_93", K_WORLD_93},
+	{"WORLD_94", K_WORLD_94},
+	{"WORLD_95", K_WORLD_95},
+
+	{"WINDOWS", K_SUPER},
+	{"COMPOSE", K_COMPOSE},
+	{"MODE", K_MODE},
+	{"HELP", K_HELP},
+	{"PRINT", K_PRINT},
+	{"SYSREQ", K_SYSREQ},
+	{"SCROLLOCK", K_SCROLLOCK },
+	{"BREAK", K_BREAK},
+	{"MENU", K_MENU},
+	{"POWER", K_POWER},
+	{"EURO", K_EURO},
+	{"UNDO", K_UNDO},
+
+	{"PAD0_A", K_PAD0_A },
+	{"PAD0_B", K_PAD0_B },
+	{"PAD0_X", K_PAD0_X },
+	{"PAD0_Y", K_PAD0_Y },
+	{"PAD0_BACK", K_PAD0_BACK },
+	{"PAD0_GUIDE", K_PAD0_GUIDE },
+	{"PAD0_START", K_PAD0_START },
+	{"PAD0_LEFTSTICK_CLICK", K_PAD0_LEFTSTICK_CLICK },
+	{"PAD0_RIGHTSTICK_CLICK", K_PAD0_RIGHTSTICK_CLICK },
+	{"PAD0_LEFTSHOULDER", K_PAD0_LEFTSHOULDER },
+	{"PAD0_RIGHTSHOULDER", K_PAD0_RIGHTSHOULDER },
+	{"PAD0_DPAD_UP", K_PAD0_DPAD_UP },
+	{"PAD0_DPAD_DOWN", K_PAD0_DPAD_DOWN },
+	{"PAD0_DPAD_LEFT", K_PAD0_DPAD_LEFT },
+	{"PAD0_DPAD_RIGHT", K_PAD0_DPAD_RIGHT },
+
+	{"PAD0_LEFTSTICK_LEFT", K_PAD0_LEFTSTICK_LEFT },
+	{"PAD0_LEFTSTICK_RIGHT", K_PAD0_LEFTSTICK_RIGHT },
+	{"PAD0_LEFTSTICK_UP", K_PAD0_LEFTSTICK_UP },
+	{"PAD0_LEFTSTICK_DOWN", K_PAD0_LEFTSTICK_DOWN },
+	{"PAD0_RIGHTSTICK_LEFT", K_PAD0_RIGHTSTICK_LEFT },
+	{"PAD0_RIGHTSTICK_RIGHT", K_PAD0_RIGHTSTICK_RIGHT },
+	{"PAD0_RIGHTSTICK_UP", K_PAD0_RIGHTSTICK_UP },
+	{"PAD0_RIGHTSTICK_DOWN", K_PAD0_RIGHTSTICK_DOWN },
+	{"PAD0_LEFTTRIGGER", K_PAD0_LEFTTRIGGER },
+	{"PAD0_RIGHTTRIGGER", K_PAD0_RIGHTTRIGGER },
+
+	{NULL,0}
+};
+
+/*
+=============================================================================
+
+EDIT FIELDS
+
+=============================================================================
+*/
+
+
+/*
+===================
+Field_Draw
+
+Handles horizontal scrolling and cursor blinking
+x, y, and width are in pixels
+===================
+*/
+static void Field_VariableSizeDraw( field_t *edit, int x, int y, int width, int size,
+        bool showCursor, bool noColorEscape )
+{
+	int		len;
+	int		drawLen;
+	int		prestep;
+	int		cursorChar;
+	char	str[MAX_STRING_CHARS];
+	int		i;
+
+	drawLen = edit->widthInChars - 1; // - 1 so there is always a space for the cursor
+	len = strlen( edit->buffer );
+
+	// guarantee that cursor will be visible
+	if ( len <= drawLen ) {
+		prestep = 0;
+	} else {
+		if ( edit->scroll + drawLen > len ) {
+			edit->scroll = len - drawLen;
+			if ( edit->scroll < 0 ) {
+				edit->scroll = 0;
+			}
+		}
+		prestep = edit->scroll;
+	}
+
+	if ( prestep + drawLen > len ) {
+		drawLen = len - prestep;
+	}
+
+	// extract <drawLen> characters from the field at <prestep>
+	if ( drawLen >= MAX_STRING_CHARS ) {
+		Com_Error( ERR_DROP, "drawLen >= MAX_STRING_CHARS" );
+	}
+
+	::memcpy( str, edit->buffer + prestep, drawLen );
+	str[ drawLen ] = 0;
+
+	// draw it
+	if ( size == SMALLCHAR_WIDTH ) {
+		float	color[4];
+
+		color[0] = color[1] = color[2] = color[3] = 1.0;
+		SCR_DrawSmallStringExt( x, y, str, color, false, noColorEscape );
+	} else {
+		// draw big string with drop shadow
+		SCR_DrawBigString( x, y, str, 1.0, noColorEscape );
+	}
+
+	// draw the cursor
+	if ( showCursor ) {
+		if ( (int)( cls.realtime >> 8 ) & 1 ) {
+			return;		// off blink
+		}
+
+		if ( key_overstrikeMode ) {
+			cursorChar = 11;
+		} else {
+			cursorChar = 10;
+		}
+
+		i = drawLen - strlen( str );
+
+		if ( size == SMALLCHAR_WIDTH ) {
+			SCR_DrawSmallChar( x + ( edit->cursor - prestep - i ) * size, y, cursorChar );
+		} else {
+			str[0] = cursorChar;
+			str[1] = 0;
+			SCR_DrawBigString( x + ( edit->cursor - prestep - i ) * size, y, str, 1.0, false );
+
+		}
+	}
+}
+
+void Field_Draw( field_t *edit, int x, int y, int width, bool showCursor, bool noColorEscape )
+{
+	Field_VariableSizeDraw( edit, x, y, width, SMALLCHAR_WIDTH, showCursor, noColorEscape );
+}
+
+void Field_BigDraw( field_t *edit, int x, int y, int width, bool showCursor, bool noColorEscape )
+{
+	Field_VariableSizeDraw( edit, x, y, width, BIGCHAR_WIDTH, showCursor, noColorEscape );
+}
+
+/*
+================
+Field_Paste
+================
+*/
+static void Field_Paste( field_t *edit )
+{
+	char	*cbd;
+	int		pasteLen, i;
+
+	cbd = Sys_GetClipboardData();
+
+	if ( !cbd ) {
+		return;
+	}
+
+	// send as if typed, so insert / overstrike works properly
+	pasteLen = strlen( cbd );
+	for ( i = 0 ; i < pasteLen ; i++ ) {
+		Field_CharEvent( edit, cbd[i] );
+	}
+
+	Z_Free( cbd );
+}
+
+/*
+=================
+Field_KeyDownEvent
+
+Performs the basic line editing functions for the console,
+in-game talk, and menu fields
+
+Key events are used for non-printable characters, others are gotten from char events.
+=================
+*/
+void Field_KeyDownEvent( field_t *edit, int key )
+{
+    int len;
+
+    // shift-insert is paste
+    if ( ( ( key == K_INS ) || ( key == K_KP_INS ) ) && keys[K_SHIFT].down )
+    {
+        Field_Paste( edit );
+        return;
+    }
+
+    key = tolower( key );
+    len = strlen( edit->buffer );
+
+    switch ( key )
+    {
+        case K_DEL:
+            if ( edit->cursor < len )
+            {
+                memmove( edit->buffer + edit->cursor,
+                         edit->buffer + edit->cursor + 1,
+                         len - edit->cursor );
+            }
+            break;
+
+        case K_RIGHTARROW:
+            if ( edit->cursor < len ) {
+                edit->cursor++;
+            }
+            break;
+
+        case K_LEFTARROW:
+            if ( edit->cursor > 0 ) {
+                edit->cursor--;
+            }
+            break;
+
+        case K_HOME:
+            edit->cursor = 0;
+            break;
+
+        case K_END:
+            edit->cursor = len;
+            break;
+
+        case K_INS:
+            key_overstrikeMode = !key_overstrikeMode;
+            break;
+
+        default:
+            break;
+    }
+
+    // Change scroll if cursor is no longer visible
+    if ( edit->cursor < edit->scroll )
+    {
+        edit->scroll = edit->cursor;
+    }
+    else if ( edit->cursor >= edit->scroll + edit->widthInChars && edit->cursor <= len )
+    {
+        edit->scroll = edit->cursor - edit->widthInChars + 1;
+    }
+}
+
+/*
+==================
+Field_CharEvent
+==================
+*/
+void Field_CharEvent( field_t *edit, int ch )
+{
+	int		len;
+
+	if ( ch == 'v' - 'a' + 1 ) {	// ctrl-v is paste
+		Field_Paste( edit );
+		return;
+	}
+
+	if ( ch == 'c' - 'a' + 1 ) {	// ctrl-c clears the field
+		Field_Clear( edit );
+		return;
+	}
+
+	len = strlen( edit->buffer );
+
+	if ( ch == 'h' - 'a' + 1 )	{	// ctrl-h is backspace
+		if ( edit->cursor > 0 ) {
+			memmove( edit->buffer + edit->cursor - 1,
+				edit->buffer + edit->cursor, len + 1 - edit->cursor );
+			edit->cursor--;
+			if ( edit->cursor < edit->scroll )
+			{
+				edit->scroll--;
+			}
+		}
+		return;
+	}
+
+	if ( ch == 'a' - 'a' + 1 ) {	// ctrl-a is home
+		edit->cursor = 0;
+		edit->scroll = 0;
+		return;
+	}
+
+	if ( ch == 'e' - 'a' + 1 ) {	// ctrl-e is end
+		edit->cursor = len;
+		edit->scroll = edit->cursor - edit->widthInChars;
+		return;
+	}
+
+	//
+	// ignore any other non printable chars
+	//
+	if ( ch < 32 ) {
+		return;
+	}
+
+	if ( key_overstrikeMode ) {
+		// - 2 to leave room for the leading slash and trailing \0
+		if ( edit->cursor == MAX_EDIT_LINE - 2 )
+			return;
+		edit->buffer[edit->cursor] = ch;
+		edit->cursor++;
+	} else {	// insert mode
+		// - 2 to leave room for the leading slash and trailing \0
+		if ( len == MAX_EDIT_LINE - 2 ) {
+			return; // all full
+		}
+		memmove( edit->buffer + edit->cursor + 1,
+			edit->buffer + edit->cursor, len + 1 - edit->cursor );
+		edit->buffer[edit->cursor] = ch;
+		edit->cursor++;
+	}
+
+
+	if ( edit->cursor >= edit->widthInChars ) {
+		edit->scroll++;
+	}
+
+	if ( edit->cursor == len + 1) {
+		edit->buffer[edit->cursor] = 0;
+	}
+}
+
+/*
+=============================================================================
+
+CONSOLE LINE EDITING
+
+==============================================================================
+*/
+
+/*
+====================
+Console_Key
+
+Handles history and console scrollback
+====================
+*/
+static void Console_Key(int key)
+{
+    // ctrl-L clears screen
+    if ( key == 'l' && keys[K_CTRL].down )
+    {
+        Cbuf_AddText ("clear\n");
+        return;
+    }
+
+    // enter finishes the line
+    if ( key == K_ENTER || key == K_KP_ENTER )
+    {
+        // if not in the game explicitly prepend a slash if needed
+        if ( clc.state != CA_ACTIVE
+            && g_consoleField.buffer[0]
+            && g_consoleField.buffer[0] != '\\'
+            && g_consoleField.buffer[0] != '/' )
+        {
+            char  temp[MAX_EDIT_LINE-1];
+
+            Q_strncpyz( temp, g_consoleField.buffer, sizeof( temp ) );
+            Com_sprintf( g_consoleField.buffer, sizeof( g_consoleField.buffer ), "\\%s", temp );
+            g_consoleField.cursor++;
+        }
+
+        Com_Printf ( "]%s\n", g_consoleField.buffer );
+
+        // leading slash is an explicit command
+        if ( g_consoleField.buffer[0] == '\\' || g_consoleField.buffer[0] == '/' )
+        {
+            Cbuf_AddText( g_consoleField.buffer+1 );    // valid command
+            Cbuf_AddText ("\n");
+        }
+        else
+        {
+            // other text will be chat messages
+            if ( !g_consoleField.buffer[0] )
+            {
+                return; // empty lines just scroll the console without adding to history
+            }
+            else
+            {
+                Cbuf_AddText ("cmd say ");
+                Cbuf_AddText( g_consoleField.buffer );
+                Cbuf_AddText ("\n");
+            }
+        }
+
+        // copy line to history buffer
+        historyEditLines[nextHistoryLine % COMMAND_HISTORY] = g_consoleField;
+        nextHistoryLine++;
+        historyLine = nextHistoryLine;
+
+        Field_Clear( &g_consoleField );
+
+        g_consoleField.widthInChars = g_console_field_width;
+
+        CL_SaveConsoleHistory( );
+
+        if ( clc.state == CA_DISCONNECTED ) {
+            SCR_UpdateScreen ();    // force an update, because the command
+        }                            // may take some time
+        return;
+    }
+
+    // command completion
+
+    if (key == K_TAB) {
+        Field_AutoComplete(&g_consoleField);
+        return;
+    }
+
+    // command history (ctrl-p ctrl-n for unix style)
+
+    if ( (key == K_MWHEELUP && keys[K_SHIFT].down) || ( key == K_UPARROW ) || ( key == K_KP_UPARROW ) ||
+            ( ( tolower(key) == 'p' ) && keys[K_CTRL].down ) ) {
+        if ( nextHistoryLine - historyLine < COMMAND_HISTORY
+                && historyLine > 0 ) {
+            historyLine--;
+        }
+        g_consoleField = historyEditLines[ historyLine % COMMAND_HISTORY ];
+        return;
+    }
+
+    if ( (key == K_MWHEELDOWN && keys[K_SHIFT].down) || ( key == K_DOWNARROW ) || ( key == K_KP_DOWNARROW ) ||
+            ( ( tolower(key) == 'n' ) && keys[K_CTRL].down ) ) {
+        historyLine++;
+        if (historyLine >= nextHistoryLine) {
+            historyLine = nextHistoryLine;
+            Field_Clear( &g_consoleField );
+            g_consoleField.widthInChars = g_console_field_width;
+            return;
+        }
+        g_consoleField = historyEditLines[ historyLine % COMMAND_HISTORY ];
+        return;
+    }
+
+    // console scrolling
+    if ( key == K_PGUP ) {
+        Con_PageUp();
+        return;
+    }
+
+    if ( key == K_PGDN) {
+        Con_PageDown();
+        return;
+    }
+
+    if ( key == K_MWHEELUP) {    //----(SA)    added some mousewheel functionality to the console
+        Con_PageUp();
+        if(keys[K_CTRL].down) {    // hold <ctrl> to accelerate scrolling
+            Con_PageUp();
+            Con_PageUp();
+        }
+        return;
+    }
+
+    if ( key == K_MWHEELDOWN) {    //----(SA)    added some mousewheel functionality to the console
+        Con_PageDown();
+        if(keys[K_CTRL].down) {    // hold <ctrl> to accelerate scrolling
+            Con_PageDown();
+            Con_PageDown();
+        }
+        return;
+    }
+
+    // ctrl-home = top of console
+    if ( key == K_HOME && keys[K_CTRL].down ) {
+        Con_Top();
+        return;
+    }
+
+    // ctrl-end = bottom of console
+    if ( key == K_END && keys[K_CTRL].down ) {
+        Con_Bottom();
+        return;
+    }
+
+    // pass to the normal editline routine
+    Field_KeyDownEvent( &g_consoleField, key );
+}
+//============================================================================
+
+
+
+/*
+=================
+Message_Key
+
+In game talk message
+=================
+*/
+static void Message_Key( int key ) {
+
+	char		buffer[MAX_STRING_CHARS];
+
+	if (key == K_ESCAPE) {
+					Key_SetCatcher( Key_GetCatcher( ) & ~KEYCATCH_MESSAGE );
+					Field_Clear( &chatField);
+					return;
+	}
+
+	if ( key == K_ENTER || key == K_KP_ENTER ) {
+		if ( chatField.buffer[0] && clc.state == CA_ACTIVE ){
+
+			if( chatField.buffer[0] == '/' ||
+					chatField.buffer[0] == '\\' )
+				{
+					Com_sprintf( buffer, sizeof( buffer ), "%s\n", &chatField.buffer[1] );
+				}
+
+			 else if (chat_playerNum != -1 ) {
+				Com_sprintf( buffer, sizeof( buffer ),
+				             "tell %i \"%s\"\n",
+										 chat_playerNum,
+										 chatField.buffer );
+			}
+			else if (chat_team) {
+				Com_sprintf( buffer, sizeof( buffer ),
+				             "say_team \"%s\"\n",
+										 chatField.buffer );
+			}
+			else if (chat_admins) {
+				Com_sprintf( buffer, sizeof( buffer ), 
+										 "a \"%s\"\n",
+										 chatField.buffer );
+			}
+			else if (chat_clans) {
+				char clantagDecolored[ 32 ];
+
+				Q_strncpyz( clantagDecolored, cl_clantag->string,
+										sizeof(clantagDecolored) );
+				Q_CleanStr( clantagDecolored );
+
+				if( strlen(clantagDecolored) > 2 && strlen(clantagDecolored) < 11 ) {
+					Com_sprintf( buffer, sizeof( buffer ),
+											 "m \"%s\" \"%s\"\n", clantagDecolored,
+											 chatField.buffer );
+				} else {
+					//string isnt long enough
+					Com_Printf ( 
+						"^3Error:your cl_clantag has to be Between 3 and 10 chars long. current value is:^7 %s^7\n",
+						clantagDecolored );
+					return;
+				}
+			}
+			else {
+				Com_sprintf( buffer, sizeof( buffer ),
+				             "say \"%s\"\n", chatField.buffer );
+			}
+
+			CL_AddReliableCommand( buffer, false );
+		}
+		Key_SetCatcher( Key_GetCatcher( ) & ~KEYCATCH_MESSAGE );
+		Field_Clear( &chatField );
+		return;
+	}
+
+	Field_KeyDownEvent( &chatField, key);
+}
+
+//============================================================================
+
+
+bool Key_GetOverstrikeMode( void )
+{
+	return key_overstrikeMode;
+}
+
+
+void Key_SetOverstrikeMode( bool state )
+{
+	key_overstrikeMode = state;
+}
+
+
+/*
+===================
+Key_IsDown
+===================
+*/
+bool Key_IsDown( int keynum )
+{
+	if ( keynum < 0 || keynum >= MAX_KEYS )
+		return false;
+
+	return keys[keynum].down;
+}
+
+/*
+===================
+Key_StringToKeynum
+
+Returns a key number to be used to index keys[] by looking at
+the given string.  Single ascii characters return themselves, while
+the K_* names are matched up.
+
+0x11 will be interpreted as raw hex, which will allow new controlers
+
+to be configured even if they don't have defined names.
+===================
+*/
+int Key_StringToKeynum( const char *str ) {
+	keyname_t	*kn;
+
+	if ( !str || !str[0] ) {
+		return -1;
+	}
+	if ( !str[1] ) {
+		return tolower( str[0] );
+	}
+
+	// check for hex code
+	if ( strlen( str ) == 4 ) {
+		int n = Com_HexStrToInt( str );
+
+		if ( n >= 0 ) {
+			return n;
+		}
+	}
+
+	// scan for a text match
+	for ( kn=keynames ; kn->name ; kn++ ) {
+		if ( !Q_stricmp( str,kn->name ) )
+			return kn->keynum;
+	}
+
+	return -1;
+}
+
+/*
+===================
+Key_KeynumToString
+
+Returns a string (either a single ascii char, a K_* name, or a 0x11 hex string) for the
+given keynum.
+===================
+*/
+const char *Key_KeynumToString( int keynum ) {
+	keyname_t	*kn;
+	static	char	tinystr[5];
+	int			i, j;
+
+	if ( keynum == -1 ) {
+		return "<KEY NOT FOUND>";
+	}
+
+	if ( keynum < 0 || keynum >= MAX_KEYS ) {
+		return "<OUT OF RANGE>";
+	}
+
+	// check for printable ascii (don't use quote)
+	if ( keynum > 32 && keynum < 127 && keynum != '"' && keynum != ';' ) {
+		tinystr[0] = keynum;
+		tinystr[1] = 0;
+		return tinystr;
+	}
+
+	// check for a key string
+	for ( kn=keynames ; kn->name ; kn++ ) {
+		if (keynum == kn->keynum) {
+			return kn->name;
+		}
+	}
+
+	// make a hex string
+	i = keynum >> 4;
+	j = keynum & 15;
+
+	tinystr[0] = '0';
+	tinystr[1] = 'x';
+	tinystr[2] = i > 9 ? i - 10 + 'a' : i + '0';
+	tinystr[3] = j > 9 ? j - 10 + 'a' : j + '0';
+	tinystr[4] = 0;
+
+	return tinystr;
+}
+
+
+/*
+===================
+Key_SetBinding
+===================
+*/
+void Key_SetBinding( int keynum, const char *binding ) {
+	if ( keynum < 0 || keynum >= MAX_KEYS ) {
+		return;
+	}
+
+	// free old bindings
+	if ( keys[ keynum ].binding ) {
+		Z_Free( keys[ keynum ].binding );
+	}
+
+	// allocate memory for new binding
+	keys[keynum].binding = CopyString( binding );
+
+	// consider this like modifying an archived cvar, so the
+	// file write will be triggered at the next oportunity
+	cvar_modifiedFlags |= CVAR_ARCHIVE;
+}
+
+
+/*
+===================
+Key_GetBinding
+===================
+*/
+const char *Key_GetBinding( int keynum ) {
+	if ( keynum < 0 || keynum >= MAX_KEYS ) {
+		return "";
+	}
+
+	return keys[ keynum ].binding;
+}
+
+/*
+===================
+Key_GetKey
+===================
+*/
+
+int Key_GetKey(const char *binding) {
+  int i;
+
+  if (binding) {
+  	for (i=0 ; i < MAX_KEYS ; i++) {
+      if (keys[i].binding && Q_stricmp(binding, keys[i].binding) == 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+
+/*
+===================
+Key_Unbind_f
+===================
+*/
+void Key_Unbind_f (void)
+{
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf ("unbind <key> : remove commands from a key\n");
+		return;
+	}
+
+	int b = Key_StringToKeynum(Cmd_Argv(1));
+	if ( b == -1 )
+	{
+		Com_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
+		return;
+	}
+
+	Key_SetBinding (b, "");
+}
+
+/*
+===================
+Key_Unbindall_f
+===================
+*/
+void Key_Unbindall_f (void)
+{
+	int		i;
+
+	for (i=0 ; i < MAX_KEYS; i++)
+		if (keys[i].binding)
+			Key_SetBinding (i, "");
+}
+
+
+/*
+===================
+Key_Bind_f
+===================
+*/
+void Key_Bind_f (void)
+{
+	int			i, c, b;
+	char		cmd[1024];
+
+	c = Cmd_Argc();
+
+	if (c < 2)
+	{
+		Com_Printf ("bind <key> [command] : attach a command to a key\n");
+		return;
+	}
+	b = Key_StringToKeynum (Cmd_Argv(1));
+	if (b==-1)
+	{
+		Com_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
+		return;
+	}
+
+	if (c == 2)
+	{
+		if (keys[b].binding && keys[b].binding[0])
+			Com_Printf ("\"%s\" = \"%s\"\n", Key_KeynumToString(b), keys[b].binding );
+		else
+			Com_Printf ("\"%s\" is not bound\n", Key_KeynumToString(b) );
+		return;
+	}
+
+// copy the rest of the command line
+	cmd[0] = 0;		// start out with a null string
+	for (i=2 ; i< c ; i++)
+	{
+		strcat (cmd, Cmd_Argv(i));
+		if (i != (c-1))
+			strcat (cmd, " ");
+	}
+
+	Key_SetBinding (b, cmd);
+}
+
+/*
+============
+Key_WriteBindings
+
+Writes lines containing "bind key value"
+============
+*/
+void Key_WriteBindings( fileHandle_t f ) {
+	int		i;
+
+	FS_Printf (f, "unbindall\n" );
+
+	for (i=0 ; i<MAX_KEYS ; i++) {
+		if (keys[i].binding && keys[i].binding[0] ) {
+			FS_Printf (f, "bind %s \"%s\"\n", Key_KeynumToString(i), keys[i].binding);
+
+		}
+
+	}
+}
+
+
+/*
+============
+Key_Bindlist_f
+
+============
+*/
+void Key_Bindlist_f( void ) {
+	int		i;
+
+	for ( i = 0 ; i < MAX_KEYS ; i++ ) {
+		if ( keys[i].binding && keys[i].binding[0] ) {
+			Com_Printf( "%s \"%s\"\n", Key_KeynumToString(i), keys[i].binding );
+		}
+	}
+}
+
+/*
+============
+Key_KeynameCompletion
+============
+*/
+void Key_KeynameCompletion( void(*callback)(const char *s) ) {
+	int		i;
+
+	for( i = 0; keynames[ i ].name != NULL; i++ )
+		callback( keynames[ i ].name );
+}
+
+/*
+====================
+Key_CompleteUnbind
+====================
+*/
+static void Key_CompleteUnbind( char *args, int argNum )
+{
+	if( argNum == 2 )
+	{
+		// Skip "unbind "
+		char *p = Com_SkipTokens( args, 1, " " );
+
+		if( p > args )
+			Field_CompleteKeyname( );
+	}
+}
+
+/*
+====================
+Key_CompleteBind
+====================
+*/
+static void Key_CompleteBind( char *args, int argNum )
+{
+	char *p;
+
+	if( argNum == 2 )
+	{
+		// Skip "bind "
+		p = Com_SkipTokens( args, 1, " " );
+
+		if( p > args )
+			Field_CompleteKeyname( );
+	}
+	else if( argNum >= 3 )
+	{
+		// Skip "bind <key> "
+		p = Com_SkipTokens( args, 2, " " );
+
+		if( p > args )
+			Field_CompleteCommand( p, true, true );
+	}
+}
+
+/*
+===================
+CL_InitKeyCommands
+===================
+*/
+void CL_InitKeyCommands( void )
+{
+	// register our functions
+	Cmd_AddCommand ("bind",Key_Bind_f);
+	Cmd_SetCommandCompletionFunc( "bind", Key_CompleteBind );
+	Cmd_AddCommand ("unbind",Key_Unbind_f);
+	Cmd_SetCommandCompletionFunc( "unbind", Key_CompleteUnbind );
+	Cmd_AddCommand ("unbindall",Key_Unbindall_f);
+	Cmd_AddCommand ("bindlist",Key_Bindlist_f);
+}
+
+/*
+===================
+CL_BindUICommand
+
+Returns true if bind command should be executed while user interface is shown
+===================
+*/
+static bool CL_BindUICommand( const char *cmd )
+{
+	if ( Key_GetCatcher( ) & KEYCATCH_CONSOLE )
+		return false;
+
+	if ( !Q_stricmp( cmd, "toggleconsole" ) )
+		return true;
+	if ( !Q_stricmp( cmd, "togglemenu" ) )
+		return true;
+
+	return false;
+}
+
+/*
+===================
+CL_ParseBinding
+
+Execute the commands in the bind string
+===================
+*/
+static void CL_ParseBinding( int key, bool down, unsigned time )
+{
+	char buf[ MAX_STRING_CHARS ], *p = buf, *end;
+	bool allCommands, allowUpCmds;
+
+	if( clc.state == CA_DISCONNECTED && Key_GetCatcher( ) == 0 )
+		return;
+	if( !keys[key].binding || !keys[key].binding[0] )
+		return;
+	Q_strncpyz( buf, keys[key].binding, sizeof( buf ) );
+
+	// run all bind commands if console, ui, etc aren't reading keys
+	allCommands = ( Key_GetCatcher( ) == 0 );
+
+	// allow button up commands if in game even if key catcher is set
+	allowUpCmds = ( clc.state != CA_DISCONNECTED );
+
+	while( 1 )
+	{
+		while( isspace( *p ) )
+			p++;
+		end = strchr( p, ';' );
+		if( end )
+			*end = '\0';
+		if( *p == '+' )
+		{
+			// button commands add keynum and time as parameters
+			// so that multiple sources can be discriminated and
+			// subframe corrected
+			if ( allCommands || ( allowUpCmds && !down ) ) {
+				char cmd[1024];
+				Com_sprintf( cmd, sizeof( cmd ), "%c%s %d %d\n",
+					( down ) ? '+' : '-', p + 1, key, time );
+				Cbuf_AddText( cmd );
+			}
+		}
+		else if( down )
+		{
+			// normal commands only execute on key press
+			if ( allCommands || CL_BindUICommand( p ) ) {
+				Cbuf_AddText( p );
+				Cbuf_AddText( "\n" );
+			}
+		}
+		if( !end )
+			break;
+		p = end + 1;
+	}
+}
+
+/*
+===================
+CL_KeyDownEvent
+
+Called by CL_KeyEvent to handle a keypress
+===================
+*/
+static void CL_KeyDownEvent( int key, unsigned time )
+{
+	keys[key].down = true;
+	keys[key].repeats++;
+	if( keys[key].repeats == 1 )
+		anykeydown++;
+
+	if( keys[K_ALT].down && key == K_ENTER )
+	{
+		Cvar_SetValue( "r_fullscreen",
+			!Cvar_VariableIntegerValue( "r_fullscreen" ) );
+		return;
+	}
+
+	// console key is hardcoded, so the user can never unbind it
+	if( key == K_CONSOLE || ( keys[K_SHIFT].down && key == K_ESCAPE ) )
+	{
+		Con_ToggleConsole_f ();
+		Key_ClearStates ();
+		return;
+	}
+
+
+	// keys can still be used for bound actions
+	if ( ( key < 128 || key == K_MOUSE1 ) &&
+		( clc.demoplaying || clc.state == CA_CINEMATIC ) && Key_GetCatcher( ) == 0 ) {
+
+		if (Cvar_VariableValue ("com_cameraMode") == 0) {
+			if( clc.demoplaying && key != K_ESCAPE ) {
+				// avoid accidental stopping of demos from pressing a random key by opening the console
+				Con_ToggleConsole_f ();
+				Key_ClearStates ();
+				return;
+			}
+			Cvar_Set ("nextdemo","");
+			key = K_ESCAPE;
+		}
+	}
+
+	// escape is always handled special
+	if ( key == K_ESCAPE ) {
+		if ( clc.netchan.alternateProtocol == 2 &&
+			   ( Key_GetCatcher( ) & KEYCATCH_MESSAGE ) ) {
+			// clear message mode
+			Message_Key( key );
+			return;
+		}
+
+		// escape always gets out of CGAME stuff
+		if (Key_GetCatcher( ) & KEYCATCH_CGAME) {
+			Key_SetCatcher( Key_GetCatcher( ) & ~KEYCATCH_CGAME );
+			VM_Call (cls.cgame, CG_EVENT_HANDLING, CGAME_EVENT_NONE);
+			return;
+		}
+
+		if ( !( Key_GetCatcher( ) & KEYCATCH_UI ) ) {
+			if ( clc.state == CA_ACTIVE && !clc.demoplaying ) {
+				VM_Call( cls.ui, UI_SET_ACTIVE_MENU - ( cls.uiInterface == 2 ? 2 : 0 ), UIMENU_INGAME );
+			}
+			else if ( clc.state != CA_DISCONNECTED ) {
+				CL_Disconnect_f();
+				S_StopAllSounds();
+				VM_Call( cls.ui, UI_SET_ACTIVE_MENU - ( cls.uiInterface == 2 ? 2 : 0 ), UIMENU_MAIN );
+			}
+			return;
+		}
+
+		VM_Call( cls.ui, UI_KEY_EVENT, key, true );
+		return;
+	}
+
+	// send the bound action
+	CL_ParseBinding( key, true, time );
+
+	// distribute the key down event to the apropriate handler
+	if ( Key_GetCatcher( ) & KEYCATCH_CONSOLE ) {
+		Console_Key( key );
+	} else if ( Key_GetCatcher( ) & KEYCATCH_UI ) {
+		if ( cls.ui ) {
+			VM_Call( cls.ui, UI_KEY_EVENT, key, true );
+		}
+	} else if ( Key_GetCatcher( ) & KEYCATCH_CGAME ) {
+		if ( cls.cgame ) {
+			VM_Call( cls.cgame, CG_KEY_EVENT, key, true );
+		}
+	} else if ( clc.netchan.alternateProtocol == 2 &&
+			        ( Key_GetCatcher( ) & KEYCATCH_MESSAGE ) ) {
+			Message_Key( key );
+	} else if ( clc.state == CA_DISCONNECTED ) {
+		Console_Key( key );
+	}
+}
+
+/*
+===================
+CL_KeyUpEvent
+
+Called by CL_KeyEvent to handle a keyrelease
+===================
+*/
+static void CL_KeyUpEvent( int key, unsigned time )
+{
+	keys[key].repeats = 0;
+	keys[key].down = false;
+	anykeydown--;
+
+	if (anykeydown < 0) {
+		anykeydown = 0;
+	}
+
+	// don't process key-up events for the console key
+	if ( key == K_CONSOLE || ( key == K_ESCAPE && keys[K_SHIFT].down ) )
+		return;
+
+	//
+	// key up events only perform actions if the game key binding is
+	// a button command (leading + sign).  These will be processed even in
+	// console mode and menu mode, to keep the character from continuing
+	// an action started before a mode switch.
+	//
+	CL_ParseBinding( key, false, time );
+
+	if ( Key_GetCatcher( ) & KEYCATCH_UI && cls.ui ) {
+		VM_Call( cls.ui, UI_KEY_EVENT, key, false );
+	} else if ( Key_GetCatcher( ) & KEYCATCH_CGAME && cls.cgame ) {
+		VM_Call( cls.cgame, CG_KEY_EVENT, key, false );
+	}
+}
+
+/*
+===================
+CL_KeyEvent
+
+Called by the system for both key up and key down events
+===================
+*/
+void CL_KeyEvent(int key, bool down, unsigned time)
+{
+	if( down )
+		CL_KeyDownEvent( key, time );
+	else
+		CL_KeyUpEvent( key, time );
+}
+
+/*
+===================
+CL_CharEvent
+
+Normal keyboard characters, already shifted / capslocked / etc
+===================
+*/
+void CL_CharEvent( int key )
+{
+    // delete is not a printable character and is otherwise handled by
+    // Field_KeyDownEvent
+	if ( key == 127 )
+		return;
+
+	// distribute the key down event to the apropriate handler
+	if ( Key_GetCatcher( ) & KEYCATCH_CONSOLE )
+		Field_CharEvent( &g_consoleField, key );
+
+	else if ( Key_GetCatcher( ) & KEYCATCH_UI )
+		VM_Call( cls.ui, UI_KEY_EVENT, key | K_CHAR_FLAG, true );
+
+	else if ( clc.netchan.alternateProtocol == 2 &&
+		        ( Key_GetCatcher( ) & KEYCATCH_MESSAGE ) )
+		Field_CharEvent( &chatField, key );
+
+	else if ( clc.state == CA_DISCONNECTED )
+		Field_CharEvent( &g_consoleField, key );
+}
+
+
+/*
+===================
+Key_ClearStates
+===================
+*/
+void Key_ClearStates(void)
+{
+	anykeydown = 0;
+
+	for ( int i = 0 ; i < MAX_KEYS ; i++ )
+    {
+		if ( keys[i].down )
+			CL_KeyEvent( i, false, 0 );
+
+		keys[i].down = 0;
+		keys[i].repeats = 0;
+	}
+}
+
+/*
+====================
+Key_KeynumToStringBuf
+====================
+*/
+void Key_KeynumToStringBuf( int keynum, char *buf, int buflen )
+{
+	Q_strncpyz( buf, Key_KeynumToString( keynum ), buflen );
+}
+
+/*
+====================
+Key_GetBindingBuf
+====================
+*/
+void Key_GetBindingBuf( int keynum, char *buf, int buflen )
+{
+	const char* value = Key_GetBinding( keynum );
+	if ( value )
+    {
+		Q_strncpyz( buf, value, buflen );
+	}
+	else
+    {
+		*buf = 0;
+	}
+}
+
+static int keyCatchers = 0;
+
+/*
+====================
+Key_GetCatcher
+====================
+*/
+int Key_GetCatcher( void )
+{
+	return keyCatchers;
+}
+
+/*
+====================
+Key_SetCatcher
+====================
+*/
+void Key_SetCatcher( int catcher )
+{
+	// If the catcher state is changing, clear all key states
+	if( catcher != keyCatchers )
+		Key_ClearStates( );
+
+	keyCatchers = catcher;
+}
+
+// This must not exceed MAX_CMD_LINE
+#define			MAX_CONSOLE_SAVE_BUFFER	1024
+#define			CONSOLE_HISTORY_FILE    "q3history"
+static char	consoleSaveBuffer[ MAX_CONSOLE_SAVE_BUFFER ];
+static int	consoleSaveBufferSize = 0;
+
+/*
+================
+CL_LoadConsoleHistory
+
+Load the console history from cl_consoleHistory
+================
+*/
+void CL_LoadConsoleHistory( void )
+{
+	char					*token, *text_p;
+	int						i, numChars, numLines = 0;
+	fileHandle_t	f;
+
+	consoleSaveBufferSize = FS_FOpenFileRead( CONSOLE_HISTORY_FILE, &f, false );
+	if( !f )
+	{
+		Com_Printf( "Couldn't read %s.\n", CONSOLE_HISTORY_FILE );
+		return;
+	}
+
+	if( consoleSaveBufferSize <= MAX_CONSOLE_SAVE_BUFFER &&
+			FS_Read( consoleSaveBuffer, consoleSaveBufferSize, f ) == consoleSaveBufferSize )
+	{
+		text_p = consoleSaveBuffer;
+
+		for( i = COMMAND_HISTORY - 1; i >= 0; i-- )
+		{
+			if( !*( token = COM_Parse( &text_p ) ) )
+				break;
+
+			historyEditLines[ i ].cursor = atoi( token );
+
+			if( !*( token = COM_Parse( &text_p ) ) )
+				break;
+
+			historyEditLines[ i ].scroll = atoi( token );
+
+			if( !*( token = COM_Parse( &text_p ) ) )
+				break;
+
+			numChars = atoi( token );
+			text_p++;
+			if( numChars > ( strlen( consoleSaveBuffer ) -	( text_p - consoleSaveBuffer ) ) )
+			{
+				Com_DPrintf( S_COLOR_YELLOW "WARNING: probable corrupt history\n" );
+				break;
+			}
+			::memcpy( historyEditLines[ i ].buffer, text_p, numChars );
+			historyEditLines[ i ].buffer[ numChars ] = '\0';
+			text_p += numChars;
+
+			numLines++;
+		}
+
+		memmove( &historyEditLines[ 0 ], &historyEditLines[ i + 1 ],
+				numLines * sizeof( field_t ) );
+		for( i = numLines; i < COMMAND_HISTORY; i++ )
+			Field_Clear( &historyEditLines[ i ] );
+
+		historyLine = nextHistoryLine = numLines;
+	}
+	else
+		Com_Printf( "Couldn't read %s.\n", CONSOLE_HISTORY_FILE );
+
+	FS_FCloseFile( f );
+}
+
+/*
+================
+CL_SaveConsoleHistory
+
+Save the console history into the cvar cl_consoleHistory
+so that it persists across invocations of q3
+================
+*/
+void CL_SaveConsoleHistory( void )
+{
+	int						i;
+	int						lineLength, saveBufferLength, additionalLength;
+	fileHandle_t	f;
+
+	consoleSaveBuffer[ 0 ] = '\0';
+
+	i = ( nextHistoryLine - 1 ) % COMMAND_HISTORY;
+	do
+	{
+		if( historyEditLines[ i ].buffer[ 0 ] )
+		{
+			lineLength = strlen( historyEditLines[ i ].buffer );
+			saveBufferLength = strlen( consoleSaveBuffer );
+
+			//ICK
+			additionalLength = lineLength + strlen( "999 999 999  " );
+
+			if( saveBufferLength + additionalLength < MAX_CONSOLE_SAVE_BUFFER )
+			{
+				Q_strcat( consoleSaveBuffer, MAX_CONSOLE_SAVE_BUFFER,
+						va( "%d %d %d %s ",
+						historyEditLines[ i ].cursor,
+						historyEditLines[ i ].scroll,
+						lineLength,
+						historyEditLines[ i ].buffer ) );
+			}
+			else
+				break;
+		}
+		i = ( i - 1 + COMMAND_HISTORY ) % COMMAND_HISTORY;
+	}
+	while( i != ( nextHistoryLine - 1 ) % COMMAND_HISTORY );
+
+	consoleSaveBufferSize = strlen( consoleSaveBuffer );
+
+	f = FS_FOpenFileWrite( CONSOLE_HISTORY_FILE );
+	if( !f )
+	{
+		Com_Printf( "Couldn't write %s.\n", CONSOLE_HISTORY_FILE );
+		return;
+	}
+
+	if( FS_Write( consoleSaveBuffer, consoleSaveBufferSize, f ) < consoleSaveBufferSize )
+		Com_Printf( "Couldn't write %s.\n", CONSOLE_HISTORY_FILE );
+
+	FS_FCloseFile( f );
+}
diff --git a/src/client/cl_main.cpp b/src/client/cl_main.cpp
new file mode 100644
index 0000000..8b33acd
--- /dev/null
+++ b/src/client/cl_main.cpp
@@ -0,0 +1,5083 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+// cl_main.c  -- client main loop
+
+#include "client.h"
+
+#ifndef _WIN32
+#include <sys/stat.h>
+#endif
+
+#include <climits>
+
+#include "sys/sys_loadlib.h"
+#include "sys/sys_local.h"
+
+#include "cl_updates.h"
+#ifdef USE_MUMBLE
+#include "libmumblelink.h"
+#endif
+
+#ifdef USE_MUMBLE
+cvar_t *cl_useMumble;
+cvar_t *cl_mumbleScale;
+#endif
+
+#ifdef USE_VOIP
+cvar_t *cl_voipUseVAD;
+cvar_t *cl_voipVADThreshold;
+cvar_t *cl_voipSend;
+cvar_t *cl_voipSendTarget;
+cvar_t *cl_voipGainDuringCapture;
+cvar_t *cl_voipCaptureMult;
+cvar_t *cl_voipShowMeter;
+cvar_t *cl_voipProtocol;
+cvar_t *cl_voip;
+#endif
+
+#ifdef USE_RENDERER_DLOPEN
+cvar_t *cl_renderer;
+#endif
+
+cvar_t *cl_nodelta;
+cvar_t *cl_debugMove;
+
+cvar_t *cl_noprint;
+cvar_t *cl_motd;
+
+cvar_t *rcon_client_password;
+cvar_t *rconAddress;
+
+cvar_t *cl_timeout;
+cvar_t *cl_maxpackets;
+cvar_t *cl_packetdup;
+cvar_t *cl_timeNudge;
+cvar_t *cl_showTimeDelta;
+cvar_t *cl_freezeDemo;
+
+cvar_t *cl_shownet;
+cvar_t *cl_showSend;
+cvar_t *cl_timedemo;
+cvar_t *cl_timedemoLog;
+cvar_t *cl_autoRecordDemo;
+cvar_t *cl_aviFrameRate;
+cvar_t *cl_aviMotionJpeg;
+cvar_t *cl_forceavidemo;
+
+cvar_t *cl_freelook;
+cvar_t *cl_sensitivity;
+
+cvar_t *cl_mouseAccel;
+cvar_t *cl_mouseAccelOffset;
+cvar_t *cl_mouseAccelStyle;
+cvar_t *cl_showMouseRate;
+
+cvar_t *m_pitch;
+cvar_t *m_yaw;
+cvar_t *m_forward;
+cvar_t *m_side;
+cvar_t *m_filter;
+
+cvar_t *j_pitch;
+cvar_t *j_yaw;
+cvar_t *j_forward;
+cvar_t *j_side;
+cvar_t *j_up;
+cvar_t *j_pitch_axis;
+cvar_t *j_yaw_axis;
+cvar_t *j_forward_axis;
+cvar_t *j_side_axis;
+cvar_t *j_up_axis;
+
+cvar_t *cl_activeAction;
+
+cvar_t *cl_motdString;
+
+cvar_t *cl_allowDownload;
+cvar_t *com_downloadPrompt;
+cvar_t *cl_conXOffset;
+cvar_t *cl_inGameVideo;
+
+cvar_t *cl_serverStatusResendTime;
+
+cvar_t *cl_lanForcePackets;
+
+cvar_t *cl_guidServerUniq;
+
+cvar_t *cl_clantag;
+
+cvar_t *cl_consoleKeys;
+
+cvar_t *cl_rate;
+
+cvar_t *cl_rsaAuth;
+
+clientActive_t cl;
+clientConnection_t clc;
+clientStatic_t cls;
+
+char cl_reconnectArgs[MAX_OSPATH];
+char cl_oldGame[MAX_QPATH];
+bool cl_oldGameSet;
+
+// Structure containing functions exported from refresh DLL
+refexport_t re;
+#ifdef USE_RENDERER_DLOPEN
+static void *rendererLib = NULL;
+#endif
+
+ping_t cl_pinglist[MAX_PINGREQUESTS];
+
+typedef struct serverStatus_s {
+    char string[BIG_INFO_STRING];
+    netadr_t address;
+    int time, startTime;
+    bool pending;
+    bool print;
+    bool retrieved;
+} serverStatus_t;
+
+serverStatus_t cl_serverStatusList[MAX_SERVERSTATUSREQUESTS];
+
+static void CL_InitRef(void);
+
+#if defined __USEA3D && defined __A3D_GEOM
+void hA3Dg_ExportRenderGeom(refexport_t *incoming_re);
+#endif
+
+static bool noGameRestart = false;
+
+static void CL_DownloadUpdate_f() { CL_DownloadRelease(); }
+
+static void CL_InstallUpdate_f()
+{
+    if (Cmd_Argc() > 1)
+        CL_ExecuteInstaller();
+    else
+        CL_ExecuteInstaller();
+}
+
+static void CL_CheckForUpdate_f() { CL_GetLatestRelease(); }
+
+static void CL_BrowseHomepath_f() { FS_BrowseHomepath(); }
+
+static void CL_BrowseDemos_f() { FS_OpenBaseGamePath( "demos/" ); }
+
+static void CL_BrowseScreenShots_f() { FS_OpenBaseGamePath( "screenshots/" ); }
+
+#ifdef USE_MUMBLE
+static void CL_UpdateMumble(void)
+{
+    vec3_t pos, forward, up;
+    float scale = cl_mumbleScale->value;
+    float tmp;
+
+    if (!cl_useMumble->integer) return;
+
+    // !!! FIXME: not sure if this is even close to correct.
+    if (clc.netchan.alternateProtocol == 2)
+    {
+        AngleVectors(cl.snap.alternatePs.viewangles, forward, NULL, up);
+
+        pos[0] = cl.snap.alternatePs.origin[0] * scale;
+        pos[1] = cl.snap.alternatePs.origin[2] * scale;
+        pos[2] = cl.snap.alternatePs.origin[1] * scale;
+    }
+    else
+    {
+        AngleVectors(cl.snap.ps.viewangles, forward, NULL, up);
+
+        pos[0] = cl.snap.ps.origin[0] * scale;
+        pos[1] = cl.snap.ps.origin[2] * scale;
+        pos[2] = cl.snap.ps.origin[1] * scale;
+    }
+
+    tmp = forward[1];
+    forward[1] = forward[2];
+    forward[2] = tmp;
+
+    tmp = up[1];
+    up[1] = up[2];
+    up[2] = tmp;
+
+    if (cl_useMumble->integer > 1)
+    {
+        fprintf(stderr, "%f %f %f, %f %f %f, %f %f %f\n",
+                pos[0], pos[1], pos[2],
+                forward[0], forward[1], forward[2],
+                up[0], up[1], up[2]);
+    }
+
+    mumble_update_coordinates(pos, forward, up);
+}
+#endif
+
+#ifdef USE_VOIP
+static void CL_UpdateVoipIgnore(const char *idstr, bool ignore)
+{
+    if ((*idstr >= '0') && (*idstr <= '9'))
+    {
+        const int id = atoi(idstr);
+        if ((id >= 0) && (id < MAX_CLIENTS))
+        {
+            clc.voipIgnore[id] = ignore;
+            CL_AddReliableCommand(va("voip %s %d", ignore ? "ignore" : "unignore", id), false);
+            Com_Printf("VoIP: %s ignoring player #%d\n", ignore ? "Now" : "No longer", id);
+            return;
+        }
+    }
+    Com_Printf("VoIP: invalid player ID#\n");
+}
+
+static void CL_UpdateVoipGain(const char *idstr, float gain)
+{
+    if ((*idstr >= '0') && (*idstr <= '9'))
+    {
+        const int id = atoi(idstr);
+        if (gain < 0.0f) gain = 0.0f;
+        if ((id >= 0) && (id < MAX_CLIENTS))
+        {
+            clc.voipGain[id] = gain;
+            Com_Printf("VoIP: player #%d gain now set to %f\n", id, gain);
+        }
+    }
+}
+
+void CL_Voip_f(void)
+{
+    const char *cmd = Cmd_Argv(1);
+    const char *reason = NULL;
+
+    if (clc.state != CA_ACTIVE)
+        reason = "Not connected to a server";
+    else if (!clc.voipCodecInitialized)
+        reason = "Voip codec not initialized";
+    else if (!clc.voipEnabled)
+        reason = "Server doesn't support VoIP";
+
+    if (reason != NULL)
+    {
+        Com_Printf("VoIP: command ignored: %s\n", reason);
+        return;
+    }
+
+    if (strcmp(cmd, "ignore") == 0)
+    {
+        CL_UpdateVoipIgnore(Cmd_Argv(2), true);
+    }
+    else if (strcmp(cmd, "unignore") == 0)
+    {
+        CL_UpdateVoipIgnore(Cmd_Argv(2), false);
+    }
+    else if (strcmp(cmd, "gain") == 0)
+    {
+        if (Cmd_Argc() > 3)
+        {
+            CL_UpdateVoipGain(Cmd_Argv(2), atof(Cmd_Argv(3)));
+        }
+        else if (Q_isanumber(Cmd_Argv(2)))
+        {
+            int id = atoi(Cmd_Argv(2));
+            if (id >= 0 && id < MAX_CLIENTS)
+            {
+                Com_Printf(
+                    "VoIP: current gain for player #%d "
+                    "is %f\n",
+                    id, clc.voipGain[id]);
+            }
+            else
+            {
+                Com_Printf("VoIP: invalid player ID#\n");
+            }
+        }
+        else
+        {
+            Com_Printf("usage: voip gain <playerID#> [value]\n");
+        }
+    }
+    else if (strcmp(cmd, "muteall") == 0)
+    {
+        Com_Printf("VoIP: muting incoming voice\n");
+        CL_AddReliableCommand("voip muteall", false);
+        clc.voipMuteAll = true;
+    }
+    else if (strcmp(cmd, "unmuteall") == 0)
+    {
+        Com_Printf("VoIP: unmuting incoming voice\n");
+        CL_AddReliableCommand("voip unmuteall", false);
+        clc.voipMuteAll = false;
+    }
+    else
+    {
+        Com_Printf(
+            "usage: voip [un]ignore <playerID#>\n"
+            "       voip [un]muteall\n"
+            "       voip gain <playerID#> [value]\n");
+    }
+}
+
+static void CL_VoipNewGeneration(void)
+{
+    // don't have a zero generation so new clients won't match, and don't
+    //  wrap to negative so MSG_ReadLong() doesn't "fail."
+    clc.voipOutgoingGeneration++;
+    if (clc.voipOutgoingGeneration <= 0) clc.voipOutgoingGeneration = 1;
+    clc.voipPower = 0.0f;
+    clc.voipOutgoingSequence = 0;
+
+    opus_encoder_ctl(clc.opusEncoder, OPUS_RESET_STATE);
+}
+
+/*
+===============
+CL_VoipParseTargets
+
+sets clc.voipTargets according to cl_voipSendTarget
+Generally we don't want who's listening to change during a transmission,
+so this is only called when the key is first pressed
+===============
+*/
+static void CL_VoipParseTargets(void)
+{
+    const char *target = cl_voipSendTarget->string;
+    char *end;
+    int val;
+
+    ::memset(clc.voipTargets, 0, sizeof(clc.voipTargets));
+    clc.voipFlags &= ~VOIP_SPATIAL;
+
+    while (target)
+    {
+        while (*target == ',' || *target == ' ') target++;
+
+        if (!*target) break;
+
+        if (isdigit(*target))
+        {
+            val = strtol(target, &end, 10);
+            target = end;
+        }
+        else
+        {
+            if (!Q_stricmpn(target, "all", 3))
+            {
+                ::memset(clc.voipTargets, ~0, sizeof(clc.voipTargets));
+                return;
+            }
+            if (!Q_stricmpn(target, "spatial", 7))
+            {
+                clc.voipFlags |= VOIP_SPATIAL;
+                target += 7;
+                continue;
+            }
+            else
+            {
+                if (!Q_stricmpn(target, "attacker", 8))
+                {
+                    val = VM_Call(cls.cgame, CG_LAST_ATTACKER);
+                    target += 8;
+                }
+                else if (!Q_stricmpn(target, "crosshair", 9))
+                {
+                    val = VM_Call(cls.cgame, CG_CROSSHAIR_PLAYER);
+                    target += 9;
+                }
+                else
+                {
+                    while (*target && *target != ',' && *target != ' ') target++;
+
+                    continue;
+                }
+
+                if (val < 0) continue;
+            }
+        }
+
+        if (val < 0 || val >= MAX_CLIENTS)
+        {
+            Com_Printf(S_COLOR_YELLOW
+                "WARNING: VoIP "
+                "target %d is not a valid client "
+                "number\n",
+                val);
+
+            continue;
+        }
+
+        clc.voipTargets[val / 8] |= 1 << (val % 8);
+    }
+}
+
+/*
+===============
+CL_CaptureVoip
+
+Record more audio from the hardware if required and encode it into Opus
+ data for later transmission.
+===============
+*/
+static void CL_CaptureVoip(void)
+{
+    const float audioMult = cl_voipCaptureMult->value;
+    const bool useVad = (cl_voipUseVAD->integer != 0);
+    bool initialFrame = false;
+    bool finalFrame = false;
+
+#if USE_MUMBLE
+    // if we're using Mumble, don't try to handle VoIP transmission ourselves.
+    if (cl_useMumble->integer) return;
+#endif
+
+    // If your data rate is too low, you'll get Connection Interrupted warnings
+    //  when VoIP packets arrive, even if you have a broadband connection.
+    //  This might work on rates lower than 25000, but for safety's sake, we'll
+    //  just demand it. Who doesn't have at least a DSL line now, anyhow? If
+    //  you don't, you don't need VoIP.  :)
+    if (cl_voip->modified || cl_rate->modified)
+    {
+        if ((cl_voip->integer) && (cl_rate->integer < 25000))
+        {
+            Com_Printf(S_COLOR_YELLOW "Your network rate is too slow for VoIP.\n");
+            Com_Printf("Set 'Data Rate' to 'LAN/Cable/xDSL' in 'Setup/System/Network'.\n");
+            Com_Printf("Until then, VoIP is disabled.\n");
+            Cvar_Set("cl_voip", "0");
+        }
+        Cvar_Set("cl_voipProtocol", cl_voip->integer ? "opus" : "");
+        cl_voip->modified = false;
+        cl_rate->modified = false;
+    }
+
+    if (!clc.voipCodecInitialized) return;  // just in case this gets called at a bad time.
+
+    if (clc.voipOutgoingDataSize > 0) return;  // packet is pending transmission, don't record more yet.
+
+    if (cl_voipUseVAD->modified)
+    {
+        Cvar_Set("cl_voipSend", (useVad) ? "1" : "0");
+        cl_voipUseVAD->modified = false;
+    }
+
+    if ((useVad) && (!cl_voipSend->integer)) Cvar_Set("cl_voipSend", "1");  // lots of things reset this.
+
+    if (cl_voipSend->modified)
+    {
+        bool dontCapture = false;
+        if (clc.state != CA_ACTIVE)
+            dontCapture = true;  // not connected to a server.
+        else if (!clc.voipEnabled)
+            dontCapture = true;  // server doesn't support VoIP.
+        else if (clc.demoplaying)
+            dontCapture = true;  // playing back a demo.
+        else if (cl_voip->integer == 0)
+            dontCapture = true;  // client has VoIP support disabled.
+        else if (audioMult == 0.0f)
+            dontCapture = true;  // basically silenced incoming audio.
+
+        cl_voipSend->modified = false;
+
+        if (dontCapture)
+        {
+            Cvar_Set("cl_voipSend", "0");
+            return;
+        }
+
+        if (cl_voipSend->integer)
+        {
+            initialFrame = true;
+        }
+        else
+        {
+            finalFrame = true;
+        }
+    }
+
+    // try to get more audio data from the sound card...
+
+    if (initialFrame)
+    {
+        S_MasterGain(Com_Clamp(0.0f, 1.0f, cl_voipGainDuringCapture->value));
+        S_StartCapture();
+        CL_VoipNewGeneration();
+        CL_VoipParseTargets();
+    }
+
+    if ((cl_voipSend->integer) || (finalFrame))
+    {  // user wants to capture audio?
+        int samples = S_AvailableCaptureSamples();
+        const int packetSamples = (finalFrame) ? VOIP_MAX_FRAME_SAMPLES : VOIP_MAX_PACKET_SAMPLES;
+
+        // enough data buffered in audio hardware to process yet?
+        if (samples >= packetSamples)
+        {
+            // audio capture is always MONO16.
+            static int16_t sampbuffer[VOIP_MAX_PACKET_SAMPLES];
+            float voipPower = 0.0f;
+            int voipFrames;
+            int i, bytes;
+
+            if (samples > VOIP_MAX_PACKET_SAMPLES) samples = VOIP_MAX_PACKET_SAMPLES;
+
+            // !!! FIXME: maybe separate recording from encoding, so voipPower
+            // !!! FIXME:  updates faster than 4Hz?
+
+            samples -= samples % VOIP_MAX_FRAME_SAMPLES;
+            if (samples != 120 && samples != 240 && samples != 480 && samples != 960 && samples != 1920 &&
+                samples != 2880)
+            {
+                Com_Printf("Voip: bad number of samples %d\n", samples);
+                return;
+            }
+            voipFrames = samples / VOIP_MAX_FRAME_SAMPLES;
+
+            S_Capture(samples, (byte *)sampbuffer);  // grab from audio card.
+
+            // check the "power" of this packet...
+            for (i = 0; i < samples; i++)
+            {
+                const float flsamp = (float)sampbuffer[i];
+                const float s = fabs(flsamp);
+                voipPower += s * s;
+                sampbuffer[i] = (int16_t)((flsamp)*audioMult);
+            }
+
+            // encode raw audio samples into Opus data...
+            bytes = opus_encode(clc.opusEncoder, sampbuffer, samples, (unsigned char *)clc.voipOutgoingData,
+                sizeof(clc.voipOutgoingData));
+            if (bytes <= 0)
+            {
+                Com_DPrintf("VoIP: Error encoding %d samples\n", samples);
+                bytes = 0;
+            }
+
+            clc.voipPower = (voipPower / (32768.0f * 32768.0f * ((float)samples))) * 100.0f;
+
+            if ((useVad) && (clc.voipPower < cl_voipVADThreshold->value))
+            {
+                CL_VoipNewGeneration();  // no "talk" for at least 1/4 second.
+            }
+            else
+            {
+                clc.voipOutgoingDataSize = bytes;
+                clc.voipOutgoingDataFrames = voipFrames;
+
+                Com_DPrintf("VoIP: Send %d frames, %d bytes, %f power\n", voipFrames, bytes, clc.voipPower);
+
+#if 0
+				static FILE *encio = NULL;
+				if (encio == NULL) encio = fopen("voip-outgoing-encoded.bin", "wb");
+				if (encio != NULL) { fwrite(clc.voipOutgoingData, bytes, 1, encio); fflush(encio); }
+				static FILE *decio = NULL;
+				if (decio == NULL) decio = fopen("voip-outgoing-decoded.bin", "wb");
+				if (decio != NULL) { fwrite(sampbuffer, voipFrames * VOIP_MAX_FRAME_SAMPLES * 2, 1, decio); fflush(decio); }
+#endif
+            }
+        }
+    }
+
+    // User requested we stop recording, and we've now processed the last of
+    //  any previously-buffered data. Pause the capture device, etc.
+    if (finalFrame)
+    {
+        S_StopCapture();
+        S_MasterGain(1.0f);
+        clc.voipPower = 0.0f;  // force this value so it doesn't linger.
+    }
+}
+#endif
+
+/*
+=======================================================================
+
+CLIENT RELIABLE COMMAND COMMUNICATION
+
+=======================================================================
+*/
+
+/*
+======================
+CL_AddReliableCommand
+
+The given command will be transmitted to the server, and is gauranteed to
+not have future usercmd_t executed before it is executed
+======================
+*/
+void CL_AddReliableCommand(const char *cmd, bool isDisconnectCmd)
+{
+    int unacknowledged = clc.reliableSequence - clc.reliableAcknowledge;
+
+    // if we would be losing an old command that hasn't been acknowledged,
+    // we must drop the connection
+    // also leave one slot open for the disconnect command in this case.
+
+    if ((isDisconnectCmd && unacknowledged > MAX_RELIABLE_COMMANDS) ||
+        (!isDisconnectCmd && unacknowledged >= MAX_RELIABLE_COMMANDS))
+    {
+        if (com_errorEntered)
+            return;
+        else
+            Com_Error(ERR_DROP, "Client command overflow");
+    }
+
+    Q_strncpyz(
+        clc.reliableCommands[++clc.reliableSequence & (MAX_RELIABLE_COMMANDS - 1)], cmd, sizeof(*clc.reliableCommands));
+}
+
+/*
+=======================================================================
+
+CLIENT SIDE DEMO RECORDING
+
+=======================================================================
+*/
+
+/*
+====================
+CL_WriteDemoMessage
+
+Dumps the current net message, prefixed by the length
+====================
+*/
+void CL_WriteDemoMessage(msg_t *msg, int headerBytes)
+{
+    int len, swlen;
+
+    // write the packet sequence
+    len = clc.serverMessageSequence;
+    swlen = LittleLong(len);
+    FS_Write(&swlen, 4, clc.demofile);
+    // skip the packet sequencing information
+    len = msg->cursize - headerBytes;
+    swlen = LittleLong(len);
+    FS_Write(&swlen, 4, clc.demofile);
+    FS_Write(msg->data + headerBytes, len, clc.demofile);
+}
+
+/*
+====================
+CL_StopRecording_f
+
+stop recording a demo
+====================
+*/
+void CL_StopRecord_f(void)
+{
+    int len;
+
+    if (!clc.demorecording)
+    {
+        Com_Printf("Not recording a demo.\n");
+        return;
+    }
+
+    // finish up
+    len = -1;
+    FS_Write(&len, 4, clc.demofile);
+    FS_Write(&len, 4, clc.demofile);
+    FS_FCloseFile(clc.demofile);
+    clc.demofile = 0;
+    clc.demorecording = false;
+    clc.spDemoRecording = false;
+    Com_Printf("Stopped demo.\n");
+}
+
+/*
+==================
+CL_DemoFilename
+==================
+*/
+static void CL_DemoFilename(int number, char *fileName, int fileNameSize)
+{
+    int a, b, c, d;
+
+    if (number < 0 || number > 9999) number = 9999;
+
+    a = number / 1000;
+    number -= a * 1000;
+    b = number / 100;
+    number -= b * 100;
+    c = number / 10;
+    number -= c * 10;
+    d = number;
+
+    Com_sprintf(fileName, fileNameSize, "demo%i%i%i%i", a, b, c, d);
+}
+
+/*
+====================
+CL_Record_f
+
+record <demoname>
+
+Begins recording a demo from the current position
+====================
+*/
+static char demoName[MAX_QPATH];  // compiler bug workaround
+
+static void CL_Record_f(void)
+{
+    char name[MAX_OSPATH];
+    byte bufData[MAX_MSGLEN];
+    msg_t buf;
+    int i;
+    int len;
+    entityState_t *ent;
+    entityState_t nullstate;
+
+    if (Cmd_Argc() > 2)
+    {
+        Com_Printf("record <demoname>\n");
+        return;
+    }
+
+    if (clc.demorecording)
+    {
+        if (!clc.spDemoRecording)
+        {
+            Com_Printf("Already recording.\n");
+        }
+        return;
+    }
+
+    if (clc.state != CA_ACTIVE)
+    {
+        Com_Printf("You must be in a level to record.\n");
+        return;
+    }
+
+    // sync 0 doesn't prevent recording, so not forcing it off .. everyone does g_sync 1 ; record ; g_sync 0 ..
+    if (NET_IsLocalAddress(clc.serverAddress) && !Cvar_VariableValue("g_synchronousClients"))
+    {
+        Com_Printf(S_COLOR_YELLOW "WARNING: You should set 'g_synchronousClients 1' for smoother demo recording\n");
+    }
+
+    if (Cmd_Argc() == 2)
+    {
+        const char *s = Cmd_Argv(1);
+        Q_strncpyz(demoName, s, sizeof(demoName));
+        Com_sprintf(
+          name, sizeof(name),
+          "demos/%s.%s%d", demoName, DEMOEXT,
+            (clc.netchan.alternateProtocol == 0 ?
+              PROTOCOL_VERSION : clc.netchan.alternateProtocol == 1 ? 70 : 69));
+    }
+    else
+    {
+        int number;
+
+        // scan for a free demo name
+        for (number = 0; number <= 9999; number++)
+        {
+            CL_DemoFilename(number, demoName, sizeof(demoName));
+            Com_sprintf(name, sizeof(name), "demos/%s.%s%d", demoName, DEMOEXT, PROTOCOL_VERSION);
+
+            if (!FS_FileExists(name)) break;  // file doesn't exist
+        }
+    }
+
+    // open the demo file
+
+    Com_Printf("recording to %s.\n", name);
+    clc.demofile = FS_FOpenFileWrite(name);
+    if (!clc.demofile)
+    {
+        Com_Printf("ERROR: couldn't open.\n");
+        return;
+    }
+    clc.demorecording = true;
+    if (Cvar_VariableValue("ui_recordSPDemo"))
+    {
+        clc.spDemoRecording = true;
+    }
+    else
+    {
+        clc.spDemoRecording = false;
+    }
+
+    Q_strncpyz(clc.demoName, demoName, sizeof(clc.demoName));
+
+    // don't start saving messages until a non-delta compressed message is received
+    clc.demowaiting = true;
+
+    // write out the gamestate message
+    MSG_Init(&buf, bufData, sizeof(bufData));
+    MSG_Bitstream(&buf);
+
+    // NOTE, MRE: all server->client messages now acknowledge
+    MSG_WriteLong(&buf, clc.reliableSequence);
+
+    MSG_WriteByte(&buf, svc_gamestate);
+    MSG_WriteLong(&buf, clc.serverCommandSequence);
+
+    // configstrings
+    for (i = 0; i < MAX_CONFIGSTRINGS; i++)
+    {
+        if (!cl.gameState.stringOffsets[i])
+        {
+            continue;
+        }
+        const char *s = cl.gameState.stringData + cl.gameState.stringOffsets[i];
+        MSG_WriteByte(&buf, svc_configstring);
+        MSG_WriteShort(&buf, i);
+        MSG_WriteBigString(&buf, s);
+    }
+
+    // baselines
+    ::memset(&nullstate, 0, sizeof(nullstate));
+    for (i = 0; i < MAX_GENTITIES; i++)
+    {
+        ent = &cl.entityBaselines[i];
+        if (!ent->number)
+        {
+            continue;
+        }
+        MSG_WriteByte(&buf, svc_baseline);
+        MSG_WriteDeltaEntity(clc.netchan.alternateProtocol, &buf, &nullstate, ent, true);
+    }
+
+    MSG_WriteByte(&buf, svc_EOF);
+
+    // finished writing the gamestate stuff
+
+    // write the client num
+    MSG_WriteLong(&buf, clc.clientNum);
+    // write the checksum feed
+    MSG_WriteLong(&buf, clc.checksumFeed);
+
+    // finished writing the client packet
+    MSG_WriteByte(&buf, svc_EOF);
+
+    // write it to the demo file
+    len = LittleLong(clc.serverMessageSequence - 1);
+    FS_Write(&len, 4, clc.demofile);
+
+    len = LittleLong(buf.cursize);
+    FS_Write(&len, 4, clc.demofile);
+    FS_Write(buf.data, buf.cursize, clc.demofile);
+
+    // the rest of the demo file will be copied from net messages
+}
+
+/*
+=======================================================================
+
+CLIENT SIDE DEMO PLAYBACK
+
+=======================================================================
+*/
+
+/*
+=================
+CL_DemoFrameDurationSDev
+=================
+*/
+static float CL_DemoFrameDurationSDev(void)
+{
+    int i;
+    int numFrames;
+    float mean = 0.0f;
+    float variance = 0.0f;
+
+    if ((clc.timeDemoFrames - 1) > MAX_TIMEDEMO_DURATIONS)
+        numFrames = MAX_TIMEDEMO_DURATIONS;
+    else
+        numFrames = clc.timeDemoFrames - 1;
+
+    for (i = 0; i < numFrames; i++) mean += clc.timeDemoDurations[i];
+    mean /= numFrames;
+
+    for (i = 0; i < numFrames; i++)
+    {
+        float x = clc.timeDemoDurations[i];
+
+        variance += ((x - mean) * (x - mean));
+    }
+    variance /= numFrames;
+
+    return sqrt(variance);
+}
+
+/*
+=================
+CL_DemoCompleted
+=================
+*/
+void CL_DemoCompleted(void)
+{
+    char buffer[MAX_STRING_CHARS];
+
+    if (cl_timedemo && cl_timedemo->integer)
+    {
+        int time;
+
+        time = Sys_Milliseconds() - clc.timeDemoStart;
+        if (time > 0)
+        {
+            // Millisecond times are frame durations:
+            // minimum/average/maximum/std deviation
+            Com_sprintf(buffer, sizeof(buffer), "%i frames %3.1f seconds %3.1f fps %d.0/%.1f/%d.0/%.1f ms\n",
+                clc.timeDemoFrames, time / 1000.0, clc.timeDemoFrames * 1000.0 / time, clc.timeDemoMinDuration,
+                time / (float)clc.timeDemoFrames, clc.timeDemoMaxDuration, CL_DemoFrameDurationSDev());
+            Com_Printf("%s", buffer);
+
+            // Write a log of all the frame durations
+            if (cl_timedemoLog && strlen(cl_timedemoLog->string) > 0)
+            {
+                int i;
+                int numFrames;
+                fileHandle_t f;
+
+                if ((clc.timeDemoFrames - 1) > MAX_TIMEDEMO_DURATIONS)
+                    numFrames = MAX_TIMEDEMO_DURATIONS;
+                else
+                    numFrames = clc.timeDemoFrames - 1;
+
+                f = FS_FOpenFileWrite(cl_timedemoLog->string);
+                if (f)
+                {
+                    FS_Printf(f, "# %s", buffer);
+
+                    for (i = 0; i < numFrames; i++) FS_Printf(f, "%d\n", clc.timeDemoDurations[i]);
+
+                    FS_FCloseFile(f);
+                    Com_Printf("%s written\n", cl_timedemoLog->string);
+                }
+                else
+                {
+                    Com_Printf("Couldn't open %s for writing\n", cl_timedemoLog->string);
+                }
+            }
+        }
+    }
+
+    CL_Disconnect(true);
+    CL_NextDemo();
+}
+
+/*
+=================
+CL_ReadDemoMessage
+=================
+*/
+void CL_ReadDemoMessage(void)
+{
+    int r;
+    msg_t buf;
+    byte bufData[MAX_MSGLEN];
+    int s;
+
+    if (!clc.demofile)
+    {
+        CL_DemoCompleted();
+        return;
+    }
+
+    // get the sequence number
+    r = FS_Read(&s, 4, clc.demofile);
+    if (r != 4)
+    {
+        CL_DemoCompleted();
+        return;
+    }
+    clc.serverMessageSequence = LittleLong(s);
+
+    // init the message
+    MSG_Init(&buf, bufData, sizeof(bufData));
+
+    // get the length
+    r = FS_Read(&buf.cursize, 4, clc.demofile);
+    if (r != 4)
+    {
+        CL_DemoCompleted();
+        return;
+    }
+    buf.cursize = LittleLong(buf.cursize);
+    if (buf.cursize == -1)
+    {
+        CL_DemoCompleted();
+        return;
+    }
+    if (buf.cursize > buf.maxsize)
+    {
+        Com_Error(ERR_DROP, "CL_ReadDemoMessage: demoMsglen > MAX_MSGLEN");
+    }
+    r = FS_Read(buf.data, buf.cursize, clc.demofile);
+    if (r != buf.cursize)
+    {
+        Com_Printf("Demo file was truncated.\n");
+        CL_DemoCompleted();
+        return;
+    }
+
+    clc.lastPacketTime = cls.realtime;
+    buf.readcount = 0;
+    CL_ParseServerMessage(&buf);
+}
+
+/*
+====================
+CL_WalkDemoExt
+====================
+*/
+static int CL_WalkDemoExt(const char *arg, char *name, int *demofile)
+{
+    int i;
+    *demofile = 0;
+
+    Com_sprintf(name, MAX_OSPATH, "demos/%s.%s%d", arg, DEMOEXT, PROTOCOL_VERSION);
+    FS_FOpenFileRead(name, demofile, true);
+
+    if (*demofile)
+    {
+        Com_Printf("Demo file: %s\n", name);
+        return PROTOCOL_VERSION;
+    }
+
+    Com_Printf("Not found: %s\n", name);
+
+    for (i = 0; demo_protocols[i]; ++i)
+    {
+        if (demo_protocols[i] == PROTOCOL_VERSION) continue;
+
+        Com_sprintf(name, MAX_OSPATH, "demos/%s.%s%d", arg, DEMOEXT, demo_protocols[i]);
+        FS_FOpenFileRead(name, demofile, true);
+        if (*demofile)
+        {
+            Com_Printf("Demo file: %s\n", name);
+
+            return demo_protocols[i];
+        }
+        else
+            Com_Printf("Not found: %s\n", name);
+    }
+
+    return -1;
+}
+
+/*
+====================
+CL_CompleteDemoName
+====================
+*/
+static void CL_CompleteDemoName(char *args, int argNum)
+{
+    if (argNum == 2)
+    {
+        char demoExt[16];
+
+        Com_sprintf(demoExt, sizeof(demoExt), ".%s%d", DEMOEXT, PROTOCOL_VERSION);
+        Field_CompleteFilename("demos", demoExt, true, true);
+    }
+}
+
+/*
+====================
+CL_PlayDemo_f
+
+demo <demoname>
+
+====================
+*/
+void CL_PlayDemo_f(void)
+{
+    char name[MAX_OSPATH];
+    const char *ext_test;
+    int protocol, i;
+    char retry[MAX_OSPATH];
+
+    if (Cmd_Argc() != 2)
+    {
+        Com_Printf("demo <demoname>\n");
+        return;
+    }
+
+    // make sure a local server is killed
+    // 2 means don't force disconnect of local client
+    Cvar_Set("sv_killserver", "2");
+
+    // open the demo file
+    const char *arg = Cmd_Argv(1);
+
+    CL_Disconnect(true);
+
+    // check for an extension .DEMOEXT_?? (?? is protocol)
+    ext_test = strrchr(arg, '.');
+
+    if (ext_test && !Q_stricmpn(ext_test + 1, DEMOEXT, ARRAY_LEN(DEMOEXT) - 1))
+    {
+        protocol = atoi(ext_test + ARRAY_LEN(DEMOEXT));
+
+        for (i = 0; demo_protocols[i]; i++)
+        {
+            if (demo_protocols[i] == protocol) break;
+        }
+
+        if (demo_protocols[i] || protocol == PROTOCOL_VERSION)
+        {
+            Com_sprintf(name, sizeof(name), "demos/%s", arg);
+            FS_FOpenFileRead(name, &clc.demofile, true);
+        }
+        else
+        {
+            int len;
+
+            Com_Printf("Protocol %d not supported for demos\n", protocol);
+            len = ext_test - arg;
+
+            if (len >= ARRAY_LEN(retry)) len = ARRAY_LEN(retry) - 1;
+
+            Q_strncpyz(retry, arg, len + 1);
+            retry[len] = '\0';
+            protocol = CL_WalkDemoExt(retry, name, &clc.demofile);
+        }
+    }
+    else
+        protocol = CL_WalkDemoExt(arg, name, &clc.demofile);
+
+    if (!clc.demofile)
+    {
+        Com_Error(ERR_DROP, "couldn't open %s", name);
+        return;
+    }
+    Q_strncpyz(clc.demoName, arg, sizeof(clc.demoName));
+
+    clc.state = CA_CONNECTED;
+    clc.demoplaying = true;
+    Q_strncpyz(clc.servername, arg, sizeof(clc.servername));
+    clc.netchan.alternateProtocol = (protocol == 69 ? 2 : protocol == 70 ? 1 : 0);
+
+    // read demo messages until connected
+    while (clc.state >= CA_CONNECTED && clc.state < CA_PRIMED)
+    {
+        CL_ReadDemoMessage();
+    }
+    // don't get the first snapshot this frame, to prevent the long
+    // time from the gamestate load from messing causing a time skip
+    clc.firstDemoFrameSkipped = false;
+}
+
+/*
+====================
+CL_StartDemoLoop
+
+Closing the main menu will restart the demo loop
+====================
+*/
+static void CL_StartDemoLoop(void)
+{
+    // start the demo loop again
+    Cbuf_AddText("d1\n");
+    Key_SetCatcher(Key_GetCatcher() & KEYCATCH_CONSOLE);
+}
+
+/*
+==================
+CL_NextDemo
+
+Called when a demo or cinematic finishes
+If the "nextdemo" cvar is set, that command will be issued
+==================
+*/
+void CL_NextDemo(void)
+{
+    char v[MAX_STRING_CHARS];
+
+    Q_strncpyz(v, Cvar_VariableString("nextdemo"), sizeof(v));
+    v[MAX_STRING_CHARS - 1] = 0;
+    Com_DPrintf("CL_NextDemo: %s\n", v);
+    if (!v[0])
+    {
+        return;
+    }
+
+    Cvar_Set("nextdemo", "");
+    Cbuf_AddText(v);
+    Cbuf_AddText("\n");
+    Cbuf_Execute();
+}
+
+/*
+==================
+CL_DemoState
+
+Returns the current state of the demo system
+==================
+*/
+demoState_t CL_DemoState(void)
+{
+    if (clc.demoplaying)
+    {
+        return DS_PLAYBACK;
+    }
+    else if (clc.demorecording)
+    {
+        return DS_RECORDING;
+    }
+    else
+    {
+        return DS_NONE;
+    }
+}
+
+/*
+==================
+CL_DemoPos
+
+Returns the current position of the demo
+==================
+*/
+int CL_DemoPos(void)
+{
+    if (clc.demoplaying || clc.demorecording)
+    {
+        return FS_FTell(clc.demofile);
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+/*
+==================
+CL_DemoName
+
+Returns the name of the demo
+==================
+*/
+void CL_DemoName(char *buffer, int size)
+{
+    if (clc.demoplaying || clc.demorecording)
+    {
+        Q_strncpyz(buffer, clc.demoName, size);
+    }
+    else if (size >= 1)
+    {
+        buffer[0] = '\0';
+    }
+}
+
+//======================================================================
+
+/*
+=====================
+CL_ClearState
+
+Called before parsing a gamestate
+=====================
+*/
+void CL_ClearState(void)
+{
+    //	S_StopAllSounds();
+
+    ::memset(&cl, 0, sizeof(cl));
+}
+
+/*
+====================
+CL_UpdateGUID
+
+update cl_guid using QKEY_FILE and optional prefix
+====================
+*/
+static void CL_UpdateGUID(const char *prefix, int prefix_len)
+{
+    fileHandle_t f;
+    int len;
+
+    len = FS_SV_FOpenFileRead(QKEY_FILE, &f);
+    FS_FCloseFile(f);
+
+    if (len != QKEY_SIZE)
+        Cvar_Set("cl_guid", "");
+    else
+        Cvar_Set("cl_guid", Com_MD5File(QKEY_FILE, QKEY_SIZE, prefix, prefix_len));
+}
+
+static void CL_OldGame(void)
+{
+    if (cl_oldGameSet)
+    {
+        // change back to previous fs_game
+        cl_oldGameSet = false;
+        Cvar_Set2("fs_game", cl_oldGame, true);
+        FS_ConditionalRestart(clc.checksumFeed, false);
+    }
+}
+
+/*
+=====================
+CL_Disconnect
+
+Called when a connection, demo, or cinematic is being terminated.
+Goes from a connected state to either a menu state or a console state
+Sends a disconnect message to the server
+This is also called on Com_Error and Com_Quit, so it shouldn't cause any errors
+=====================
+*/
+void CL_Disconnect(bool showMainMenu)
+{
+    if (!com_cl_running || !com_cl_running->integer)
+    {
+        return;
+    }
+
+    // shutting down the client so enter full screen ui mode
+    Cvar_Set("r_uiFullScreen", "1");
+
+    if (clc.demorecording)
+    {
+        CL_StopRecord_f();
+    }
+
+    if (clc.download)
+    {
+        FS_FCloseFile(clc.download);
+        clc.download = 0;
+    }
+    *clc.downloadTempName = *clc.downloadName = 0;
+    Cvar_Set("cl_downloadName", "");
+
+#ifdef USE_MUMBLE
+    if (cl_useMumble->integer && mumble_islinked())
+    {
+        Com_Printf("Mumble: Unlinking from Mumble application\n");
+        mumble_unlink();
+    }
+#endif
+
+#ifdef USE_VOIP
+    if (cl_voipSend->integer)
+    {
+        int tmp = cl_voipUseVAD->integer;
+        cl_voipUseVAD->integer = 0;  // disable this for a moment.
+        clc.voipOutgoingDataSize = 0;  // dump any pending VoIP transmission.
+        Cvar_Set("cl_voipSend", "0");
+        CL_CaptureVoip();  // clean up any state...
+        cl_voipUseVAD->integer = tmp;
+    }
+
+    if (clc.voipCodecInitialized)
+    {
+        int i;
+        opus_encoder_destroy(clc.opusEncoder);
+        for (i = 0; i < MAX_CLIENTS; i++)
+        {
+            opus_decoder_destroy(clc.opusDecoder[i]);
+        }
+    }
+    Cmd_RemoveCommand("voip");
+#endif
+
+    if (clc.demofile)
+    {
+        FS_FCloseFile(clc.demofile);
+        clc.demofile = 0;
+    }
+
+    if (cls.ui && showMainMenu)
+    {
+        VM_Call(cls.ui, UI_SET_ACTIVE_MENU - (cls.uiInterface == 2 ? 2 : 0), UIMENU_NONE);
+    }
+
+    SCR_StopCinematic();
+    S_ClearSoundBuffer();
+
+    // send a disconnect message to the server
+    // send it a few times in case one is dropped
+    if (clc.state >= CA_CONNECTED)
+    {
+        CL_AddReliableCommand("disconnect", true);
+        CL_WritePacket();
+        CL_WritePacket();
+        CL_WritePacket();
+    }
+
+    // Remove pure paks
+    FS_PureServerSetLoadedPaks("", "");
+    FS_PureServerSetReferencedPaks("", "");
+
+    CL_ClearState();
+
+    // wipe the client connection
+    ::memset(&clc, 0, sizeof(clc));
+
+    clc.state = CA_DISCONNECTED;
+
+    CL_ProtocolSpecificCommandsInit();
+
+    // allow cheats locally
+    Cvar_Set("sv_cheats", "1");
+
+    // not connected to a pure server anymore
+    cl_connectedToPureServer = false;
+
+#ifdef USE_VOIP
+    // not connected to voip server anymore.
+    clc.voipEnabled = false;
+#endif
+
+    // Stop recording any video
+    if (CL_VideoRecording())
+    {
+        // Finish rendering current frame
+        SCR_UpdateScreen();
+        CL_CloseAVI();
+    }
+
+    CL_UpdateGUID(NULL, 0);
+
+    if (!noGameRestart)
+        CL_OldGame();
+    else
+        noGameRestart = false;
+}
+
+/*
+===================
+CL_ForwardCommandToServer
+
+adds the current command line as a clientCommand
+things like godmode, noclip, etc, are commands directed to the server,
+so when they are typed in at the console, they will need to be forwarded.
+===================
+*/
+void CL_ForwardCommandToServer(const char *string)
+{
+    const char *cmd = Cmd_Argv(0);
+
+    // ignore key up commands
+    if (cmd[0] == '-')
+    {
+        return;
+    }
+
+    if (clc.demoplaying || clc.state < CA_CONNECTED || cmd[0] == '+')
+    {
+        Com_Printf("Unknown command \"%s" S_COLOR_WHITE "\"\n", cmd);
+        return;
+    }
+
+    if (Cmd_Argc() > 1)
+    {
+        CL_AddReliableCommand(string, false);
+    }
+    else
+    {
+        CL_AddReliableCommand(cmd, false);
+    }
+}
+
+/*
+===================
+CL_RequestMotd
+
+===================
+*/
+static void CL_RequestMotd(void)
+{
+    char info[MAX_INFO_STRING];
+
+    if (!cl_motd->integer)
+    {
+        return;
+    }
+    Com_Printf("Resolving %s\n", MASTER_SERVER_NAME);
+
+    switch (NET_StringToAdr(MASTER_SERVER_NAME, &cls.updateServer, NA_UNSPEC))
+    {
+        case 0:
+            Com_Printf("Couldn't resolve master address\n");
+            return;
+
+        case 2:
+            cls.updateServer.port = BigShort(PORT_MASTER);
+        default:
+            break;
+    }
+
+    Com_Printf("%s resolved to %s\n", MASTER_SERVER_NAME, NET_AdrToStringwPort(cls.updateServer));
+
+    info[0] = 0;
+
+    Com_sprintf(cls.updateChallenge, sizeof(cls.updateChallenge), "%i", ((rand() << 16) ^ rand()) ^ Com_Milliseconds());
+
+    Info_SetValueForKey(info, "challenge", cls.updateChallenge);
+
+    NET_OutOfBandPrint(NS_CLIENT, cls.updateServer, "getmotd%s", info);
+}
+
+/*
+======================================================================
+
+CONSOLE COMMANDS
+
+======================================================================
+*/
+
+/*
+==================
+CL_ShowIP_f
+==================
+*/
+static void CL_ShowIP_f(void) { Sys_ShowIP(); }
+
+/*
+==================
+CL_ForwardToServer_f
+==================
+*/
+static void CL_ForwardToServer_f(void)
+{
+    if (clc.state != CA_ACTIVE || clc.demoplaying)
+    {
+        Com_Printf("Not connected to a server.\n");
+        return;
+    }
+
+    // don't forward the first argument
+    if (Cmd_Argc() > 1)
+    {
+        CL_AddReliableCommand(Cmd_Args(), false);
+    }
+}
+
+/*
+==================
+CL_Disconnect_f
+==================
+*/
+void CL_Disconnect_f(void)
+{
+    SCR_StopCinematic();
+    if (clc.state != CA_DISCONNECTED && clc.state != CA_CINEMATIC)
+    {
+        Com_Error(ERR_DISCONNECT, "Disconnected from server");
+    }
+}
+
+/*
+================
+CL_Reconnect_f
+
+================
+*/
+static void CL_Reconnect_f(void)
+{
+    if (!strlen(cl_reconnectArgs)) return;
+    Cbuf_AddText(va("connect %s\n", cl_reconnectArgs));
+}
+
+/*
+================
+CL_Connect_f
+
+================
+*/
+void CL_Connect_f(void)
+{
+    const char *server;
+    int alternateProtocol;
+    const char *serverString;
+    int argc = Cmd_Argc();
+    netadrtype_t family = NA_UNSPEC;
+
+    if (argc < 2 || argc > 4)
+    {
+        Com_Printf("usage: connect [-4|-6] server [-g|-1]\n");
+        return;
+    }
+
+    alternateProtocol = 0;
+    if (argc == 2)
+    {
+    }
+    else if (!strcmp(Cmd_Argv(argc - 1), "-g"))
+    {
+        alternateProtocol = 1;
+        --argc;
+    }
+    else if (!strcmp(Cmd_Argv(argc - 1), "-1"))
+    {
+        alternateProtocol = 2;
+        --argc;
+    }
+    else if (argc == 4)
+    {
+        --argc;
+    }
+
+    if (argc == 2)
+        server = Cmd_Argv(1);
+    else
+    {
+        if (!strcmp(Cmd_Argv(1), "-4"))
+            family = NA_IP;
+        else if (!strcmp(Cmd_Argv(1), "-6"))
+            family = NA_IP6;
+        else
+            Com_Printf("warning: only -4 or -6 as address type understood.\n");
+
+        server = Cmd_Argv(2);
+    }
+
+    // save arguments for reconnect
+    Q_strncpyz(cl_reconnectArgs, Cmd_Args(), sizeof(cl_reconnectArgs));
+
+    // clear any previous "server full" type messages
+    clc.serverMessage[0] = 0;
+
+    if (com_sv_running->integer && !strcmp(server, "localhost"))
+    {
+        // if running a local server, kill it
+        SV_Shutdown("Server quit");
+    }
+
+    // make sure a local server is killed
+    Cvar_Set("sv_killserver", "1");
+    SV_Frame(0);
+
+    noGameRestart = true;
+    CL_Disconnect(true);
+
+    Q_strncpyz(clc.servername, server, sizeof(clc.servername));
+
+    if (!NET_StringToAdr(clc.servername, &clc.serverAddress, family))
+    {
+        Com_Printf("Bad server address\n");
+        clc.state = CA_DISCONNECTED;
+        CL_ProtocolSpecificCommandsInit();
+        return;
+    }
+    if (clc.serverAddress.port == 0)
+    {
+        clc.serverAddress.port = BigShort(PORT_SERVER);
+    }
+    clc.serverAddress.alternateProtocol = alternateProtocol;
+
+    serverString = NET_AdrToStringwPort(clc.serverAddress);
+
+    Com_Printf("%s resolved to %s\n", clc.servername, serverString);
+
+    if (cl_guidServerUniq->integer)
+        CL_UpdateGUID(serverString, strlen(serverString));
+    else
+        CL_UpdateGUID(NULL, 0);
+
+    clc.challenge2[0] = '\0';
+    clc.sendSignature = false;
+
+    // if we aren't playing on a lan, we need to authenticate
+    // with the cd key
+    if (NET_IsLocalAddress(clc.serverAddress))
+    {
+        clc.state = CA_CHALLENGING;
+        clc.sendSignature = true;
+    }
+    else
+    {
+        clc.state = CA_CONNECTING;
+
+        // Set a client challenge number that ideally is mirrored back by the server.
+        clc.challenge = ((rand() << 16) ^ rand()) ^ Com_Milliseconds();
+    }
+
+    Key_SetCatcher(Key_GetCatcher() & KEYCATCH_CONSOLE);
+    clc.connectTime = -99999;  // CL_CheckForResend() will fire immediately
+    clc.connectPacketCount = 0;
+}
+
+#define MAX_RCON_MESSAGE 1024
+
+/*
+==================
+CL_CompleteRcon
+==================
+*/
+static void CL_CompleteRcon(char *args, int argNum)
+{
+    if (argNum == 2)
+    {
+        // Skip "rcon "
+        char *p = Com_SkipTokens(args, 1, " ");
+
+        if (p > args) Field_CompleteCommand(p, true, true);
+    }
+}
+
+/*
+=====================
+CL_Rcon_f
+
+  Send the rest of the command line over as
+  an unconnected command.
+=====================
+*/
+static void CL_Rcon_f(void)
+{
+    char message[MAX_RCON_MESSAGE];
+    netadr_t to;
+
+    if (!rcon_client_password->string[0])
+    {
+        Com_Printf(
+            "You must set 'rconpassword' before\n"
+            "issuing an rcon command.\n");
+        return;
+    }
+
+    message[0] = -1;
+    message[1] = -1;
+    message[2] = -1;
+    message[3] = -1;
+    message[4] = 0;
+
+    Q_strcat(message, MAX_RCON_MESSAGE, "rcon ");
+
+    Q_strcat(message, MAX_RCON_MESSAGE, rcon_client_password->string);
+    Q_strcat(message, MAX_RCON_MESSAGE, " ");
+
+    // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=543
+    Q_strcat(message, MAX_RCON_MESSAGE, Cmd_Cmd() + 5);
+
+    if (clc.state >= CA_CONNECTED)
+    {
+        to = clc.netchan.remoteAddress;
+    }
+    else
+    {
+        if (!strlen(rconAddress->string))
+        {
+            Com_Printf(
+                "You must either be connected,\n"
+                "or set the 'rconAddress' cvar\n"
+                "to issue rcon commands\n");
+
+            return;
+        }
+        NET_StringToAdr(rconAddress->string, &to, NA_UNSPEC);
+        if (to.port == 0)
+        {
+            to.port = BigShort(PORT_SERVER);
+        }
+    }
+
+    NET_SendPacket(NS_CLIENT, strlen(message) + 1, message, to);
+}
+
+/*
+=================
+CL_SendPureChecksums
+=================
+*/
+static void CL_SendPureChecksums(void)
+{
+    char cMsg[MAX_INFO_VALUE];
+
+    // if we are pure we need to send back a command with our referenced pk3 checksums
+    Com_sprintf(cMsg, sizeof(cMsg), "cp %d %s", cl.serverId, FS_ReferencedPakPureChecksums());
+
+    CL_AddReliableCommand(cMsg, false);
+}
+
+/*
+=================
+CL_ResetPureClientAtServer
+=================
+*/
+static void CL_ResetPureClientAtServer(void) { CL_AddReliableCommand("vdr", false); }
+
+/*
+=================
+CL_Snd_Restart
+
+Restart the sound subsystem
+=================
+*/
+static void CL_Snd_Shutdown(void)
+{
+    S_Shutdown();
+    cls.soundStarted = false;
+}
+/*
+==================
+CL_PK3List_f
+==================
+*/
+static void CL_OpenedPK3List_f(void) { Com_Printf("Opened PK3 Names: %s\n", FS_LoadedPakNames(false)); }
+
+/*
+==================
+CL_PureList_f
+==================
+*/
+static void CL_ReferencedPK3List_f(void) { Com_Printf("Referenced PK3 Names: %s\n", FS_ReferencedPakNames(false)); }
+
+/*
+==================
+CL_Configstrings_f
+==================
+*/
+static void CL_Configstrings_f(void)
+{
+    int i;
+    int ofs;
+
+    if (clc.state != CA_ACTIVE)
+    {
+        Com_Printf("Not connected to a server.\n");
+        return;
+    }
+
+    for (i = 0; i < MAX_CONFIGSTRINGS; i++)
+    {
+        ofs = cl.gameState.stringOffsets[i];
+        if (!ofs)
+        {
+            continue;
+        }
+        Com_Printf("%4i: %s\n", i, cl.gameState.stringData + ofs);
+    }
+}
+
+/*
+==============
+CL_Clientinfo_f
+==============
+*/
+static void CL_Clientinfo_f(void)
+{
+    Com_Printf("--------- Client Information ---------\n");
+    Com_Printf("state: %i\n", clc.state);
+    Com_Printf("Server: %s\n", clc.servername);
+    Com_Printf("User info settings:\n");
+    Info_Print(Cvar_InfoString(CVAR_USERINFO));
+    Com_Printf("--------------------------------------\n");
+}
+
+//====================================================================
+
+/*
+=================
+CL_DownloadsComplete
+
+Called when all downloading has been completed
+=================
+*/
+static void CL_DownloadsComplete(void)
+{
+    Com_Printf("Downloads complete\n");
+
+    // if we downloaded with cURL
+    if (clc.cURLUsed)
+    {
+        clc.cURLUsed = false;
+        CL_cURL_Shutdown();
+        if (clc.cURLDisconnected)
+        {
+            if (clc.downloadRestart)
+            {
+                if (!clc.activeCURLNotGameRelated) FS_Restart(clc.checksumFeed);
+                clc.downloadRestart = false;
+            }
+            clc.cURLDisconnected = false;
+            if (!clc.activeCURLNotGameRelated) CL_Reconnect_f();
+            return;
+        }
+    }
+
+    // if we downloaded files we need to restart the file system
+    if (clc.downloadRestart)
+    {
+        clc.downloadRestart = false;
+
+        FS_Restart(clc.checksumFeed);  // We possibly downloaded a pak, restart the file system to load it
+
+        // inform the server so we get new gamestate info
+        CL_AddReliableCommand("donedl", false);
+
+        // by sending the donedl command we request a new gamestate
+        // so we don't want to load stuff yet
+        return;
+    }
+    else
+    {
+        FS_ClearPakReferences(0);
+    }
+
+    // let the client game init and load data
+    clc.state = CA_LOADING;
+
+    // Pump the loop, this may change gamestate!
+    Com_EventLoop();
+
+    // if the gamestate was changed by calling Com_EventLoop
+    // then we loaded everything already and we don't want to do it again.
+    if (clc.state != CA_LOADING)
+    {
+        return;
+    }
+
+    // starting to load a map so we get out of full screen ui mode
+    Cvar_Set("r_uiFullScreen", "0");
+
+    // flush client memory and start loading stuff
+    // this will also (re)load the UI
+    // if this is a local client then only the client part of the hunk
+    // will be cleared, note that this is done after the hunk mark has been set
+    CL_FlushMemory();
+
+    // initialize the CGame
+    cls.cgameStarted = true;
+    CL_InitCGame();
+
+    // set pure checksums
+    CL_SendPureChecksums();
+
+    CL_WritePacket();
+    CL_WritePacket();
+    CL_WritePacket();
+}
+
+/*
+=================
+CL_BeginDownload
+
+Requests a file to download from the server.  Stores it in the current
+game directory.
+=================
+*/
+static void CL_BeginDownload(const char *localName, const char *remoteName)
+{
+    Com_DPrintf(
+        "***** CL_BeginDownload *****\n"
+        "Localname: %s\n"
+        "Remotename: %s\n"
+        "****************************\n",
+        localName, remoteName);
+
+    Q_strncpyz(clc.downloadName, localName, sizeof(clc.downloadName));
+    Com_sprintf(clc.downloadTempName, sizeof(clc.downloadTempName), "%s.tmp", localName);
+
+    // Set so UI gets access to it
+    Cvar_Set("cl_downloadName", remoteName);
+    Cvar_Set("cl_downloadSize", "0");
+    Cvar_Set("cl_downloadCount", "0");
+    Cvar_SetValue("cl_downloadTime", cls.realtime);
+
+    clc.downloadBlock = 0;  // Starting new file
+    clc.downloadCount = 0;
+
+    // Stop any errant looping sounds that may be playing
+    S_ClearLoopingSounds(true);
+
+    CL_AddReliableCommand(va("download %s", remoteName), false);
+}
+
+/*
+=================
+CL_NextDownload
+
+A download completed or failed
+=================
+*/
+void CL_NextDownload(void)
+{
+    char *s;
+    char *remoteName, *localName;
+    bool useCURL = false;
+    int prompt;
+
+    // A download has finished, check whether this matches a referenced checksum
+    if (*clc.downloadName && !clc.activeCURLNotGameRelated)
+    {
+        char *zippath = FS_BuildOSPath(Cvar_VariableString("fs_homepath"), clc.downloadName, "");
+        zippath[strlen(zippath) - 1] = '\0';
+
+        if (!FS_CompareZipChecksum(zippath)) Com_Error(ERR_DROP, "Incorrect checksum for file: %s", clc.downloadName);
+    }
+
+    *clc.downloadTempName = *clc.downloadName = 0;
+    Cvar_Set("cl_downloadName", "");
+
+    // We are looking to start a download here
+    if (*clc.downloadList)
+    {
+        // Prompt if we do not allow automatic downloads
+        prompt = com_downloadPrompt->integer;
+        if (!(prompt & DLP_TYPE_MASK) && !(cl_allowDownload->integer & DLF_ENABLE))
+        {
+            char files[MAX_INFO_STRING] = "";
+            char *name, *head;
+            const char *pure_msg;
+            const char *url_msg = "";
+            int i = 0, others = 0, swap = 0, max_list = 12;
+
+            // Set the download URL message
+            if ((clc.sv_allowDownload & DLF_ENABLE) && !(clc.sv_allowDownload & DLF_NO_REDIRECT))
+            {
+                url_msg = va("The server redirects to the following URL:\n%s", clc.sv_dlURL);
+                max_list -= 6;
+            }
+
+            // Make a pretty version of the download list
+            name = clc.downloadList;
+            if (*name == '@') name++;
+
+            do
+            {
+                // Copy remote name
+                head = name;
+                while (*head && *head != '@') head++;
+
+                swap = *head;
+                *head = 0;
+
+                if (i++ < max_list)
+                {
+                    if (i > 1) Q_strcat(files, sizeof(files), ", ");
+                    Q_strcat(files, sizeof(files), name);
+                }
+                else
+                {
+                    others++;
+                }
+
+                *head = swap;
+                if (!swap) break;
+
+                // Skip local name
+                head++;
+                while (*head && *head != '@') head++;
+
+                name = head + 1;
+            } while (*head);
+
+            if (others)
+            {
+                Q_strcat(files, sizeof(files), va("(%d other file%s)\n", others, others > 1 ? "s" : ""));
+            }
+
+            // Set the pure message
+            if (cl_connectedToPureServer)
+            {
+                if (!(clc.sv_allowDownload & DLF_ENABLE) ||
+                    ((clc.sv_allowDownload & DLF_NO_UDP) && (clc.sv_allowDownload & DLF_NO_REDIRECT)))
+                {
+                    pure_msg =
+                        "You are missing files required by the server. "
+                        "The server does not allow downloading. "
+                        "You must install these files manually:";
+                }
+                else
+                {
+                    pure_msg =
+                        "You are missing files required by the server. "
+                        "You must download these files or disconnect:";
+                }
+            }
+            else
+            {
+                pure_msg =
+                    "You are missing optional files provided by the "
+                    "server. You may not need them to play but can "
+                    "choose to download them anyway:";
+            }
+
+            Cvar_Set("com_downloadPromptText", va("%s\n\n%s\n%s", pure_msg, files, url_msg));
+            Cvar_Set("com_downloadPrompt", va("%d", DLP_SHOW));
+            return;
+        }
+
+        if (!(prompt & DLP_PROMPTED)) Cvar_Set("com_downloadPrompt", va("%d", prompt | DLP_PROMPTED));
+
+        prompt &= DLP_TYPE_MASK;
+
+        s = clc.downloadList;
+
+        // format is:
+        //  @remotename@localname@remotename@localname, etc.
+
+        if (*s == '@') s++;
+        remoteName = s;
+
+        if ((s = strchr(s, '@')) == NULL)
+        {
+            CL_DownloadsComplete();
+            return;
+        }
+
+        *s++ = 0;
+        localName = s;
+        if ((s = strchr(s, '@')) != NULL)
+            *s++ = 0;
+        else
+            s = localName + strlen(localName);  // point at the nul byte
+
+        if (((cl_allowDownload->integer & DLF_ENABLE) && !(cl_allowDownload->integer & DLF_NO_REDIRECT)) ||
+            prompt == DLP_CURL)
+        {
+            Com_Printf("Trying CURL download: %s; %s\n", localName, remoteName);
+            if (clc.sv_allowDownload & DLF_NO_REDIRECT)
+            {
+                Com_Printf(
+                    "WARNING: server does not "
+                    "allow download redirection "
+                    "(sv_allowDownload is %d)\n",
+                    clc.sv_allowDownload);
+            }
+            else if (!*clc.sv_dlURL)
+            {
+                Com_Printf(
+                    "WARNING: server allows "
+                    "download redirection, but does not "
+                    "have sv_dlURL set\n");
+            }
+            else if (!CL_cURL_Init())
+            {
+                Com_Printf(
+                    "WARNING: could not load "
+                    "cURL library\n");
+            }
+            else
+            {
+                CL_cURL_BeginDownload(localName, va("%s/%s", clc.sv_dlURL, remoteName));
+                useCURL = true;
+            }
+        }
+        else if (!(clc.sv_allowDownload & DLF_NO_REDIRECT))
+        {
+            Com_Printf(
+                "WARNING: server allows download "
+                "redirection, but it disabled by client "
+                "configuration (cl_allowDownload is %d)\n",
+                cl_allowDownload->integer);
+        }
+        if (!useCURL)
+        {
+            Com_Printf("Trying UDP download: %s; %s\n", localName, remoteName);
+
+            if ((!(cl_allowDownload->integer & DLF_ENABLE) || (cl_allowDownload->integer & DLF_NO_UDP)) &&
+                prompt != DLP_UDP)
+            {
+                if (cl_connectedToPureServer)
+                {
+                    Com_Error(ERR_DROP,
+                        "Automatic downloads are "
+                        "disabled on your client (cl_allowDownload is %d). "
+                        "You can enable automatic downloads in the Options "
+                        "menu.",
+                        cl_allowDownload->integer);
+                    return;
+                }
+
+                Com_Printf("WARNING: UDP downloads are disabled.\n");
+                CL_DownloadsComplete();
+                return;
+            }
+            else
+            {
+                CL_BeginDownload(localName, remoteName);
+            }
+        }
+        clc.downloadRestart = true;
+
+        // move over the rest
+        memmove(clc.downloadList, s, strlen(s) + 1);
+
+        return;
+    }
+
+    CL_DownloadsComplete();
+}
+
+/*
+=================
+CL_InitDownloads
+
+After receiving a valid game state, we valid the cgame and local zip files here
+and determine if we need to download them
+=================
+*/
+void CL_InitDownloads(void)
+{
+    if (FS_ComparePaks(clc.downloadList, sizeof(clc.downloadList), true))
+    {
+        Com_Printf("Need paks: %s\n", clc.downloadList);
+
+        Cvar_Set("com_downloadPrompt", "0");
+        if (*clc.downloadList)
+        {
+            // if autodownloading is not enabled on the server
+            clc.state = CA_CONNECTED;
+            *clc.downloadTempName = *clc.downloadName = 0;
+            Cvar_Set("cl_downloadName", "");
+            CL_NextDownload();
+            return;
+        }
+    }
+    CL_DownloadsComplete();
+}
+
+/*
+===============
+CL_UnloadRSAKeypair
+===============
+*/
+static void CL_UnloadRSAKeypair(void)
+{
+    rsa_public_key_clear(&cls.rsa.public_key);
+    rsa_private_key_clear(&cls.rsa.private_key);
+}
+
+/*
+===============
+CL_WriteRSAPublicKey
+===============
+*/
+static bool CL_WriteRSAPublicKey(void)
+{
+    struct nettle_buffer key_buffer;
+    fileHandle_t f;
+
+    f = FS_SV_FOpenFileWrite(RSA_PUBLIC_KEY_FILE);
+    if (!f) return false;
+
+    nettle_buffer_init(&key_buffer);
+    if (!rsa_keypair_to_sexp(&key_buffer, NULL, &cls.rsa.public_key, NULL))
+    {
+        FS_FCloseFile(f);
+        nettle_buffer_clear(&key_buffer);
+        return false;
+    }
+
+    FS_Write(key_buffer.contents, key_buffer.size, f);
+    FS_FCloseFile(f);
+
+    nettle_buffer_clear(&key_buffer);
+    return true;
+}
+
+/*
+===============
+CL_WriteRSAPrivateKey
+===============
+*/
+static bool CL_WriteRSAPrivateKey(void)
+{
+    struct nettle_buffer key_buffer;
+    fileHandle_t f;
+
+#ifndef _WIN32
+    int old_umask = umask(0377);
+#endif
+    f = FS_SV_FOpenFileWrite(RSA_PRIVATE_KEY_FILE);
+#ifndef _WIN32
+    umask(old_umask);
+#endif
+    if (!f) return false;
+
+    nettle_buffer_init(&key_buffer);
+    if (!rsa_keypair_to_sexp(&key_buffer, NULL, &cls.rsa.public_key, &cls.rsa.private_key))
+    {
+        FS_FCloseFile(f);
+        nettle_buffer_clear(&key_buffer);
+        return false;
+    }
+
+    FS_Write(key_buffer.contents, key_buffer.size, f);
+    FS_FCloseFile(f);
+
+    nettle_buffer_clear(&key_buffer);
+    return true;
+}
+
+/*
+===============
+CL_GenerateRSAKeypair
+
+public_key and private_key must already be inititalized before calling this
+function.  This is done by CL_LoadRSAKeypair.
+===============
+*/
+static void CL_GenerateRSAKeypair(void)
+{
+    mpz_set_ui(cls.rsa.public_key.e, RSA_PUBLIC_EXPONENT);
+
+    int success = rsa_generate_keypair(
+        &cls.rsa.public_key, &cls.rsa.private_key, NULL, qnettle_random, NULL, NULL, RSA_KEY_LENGTH, 0);
+    if (success)
+        if (CL_WriteRSAPrivateKey())
+            if (CL_WriteRSAPublicKey())
+            {
+                Com_Printf("RSA keypair generated\n");
+                return;
+            }
+
+    // failure
+    CL_UnloadRSAKeypair();
+    Com_Printf("Error generating RSA keypair, setting cl_rsaAuth to 0\n");
+    Cvar_Set("cl_rsaAuth", "0");
+}
+
+/*
+===============
+CL_LoadRSAKeypair
+
+Attempt to load RSA keys from RSA_PRIVATE_KEY_FILE
+If this fails, generate a new keypair
+===============
+*/
+static void CL_LoadRSAKeypair(void)
+{
+    int len;
+    fileHandle_t f;
+    uint8_t *buf;
+
+    rsa_public_key_init(&cls.rsa.public_key);
+    rsa_private_key_init(&cls.rsa.private_key);
+
+    Com_DPrintf("Loading RSA private key from %s\n", RSA_PRIVATE_KEY_FILE);
+
+    len = FS_SV_FOpenFileRead(RSA_PRIVATE_KEY_FILE, &f);
+    if (!f)
+    {
+        Com_DPrintf("RSA private key not found, generating\n");
+        CL_GenerateRSAKeypair();
+        return;
+    }
+
+    if (len < 1)
+    {
+        Com_DPrintf("RSA private key empty, generating\n");
+        FS_FCloseFile(f);
+        CL_GenerateRSAKeypair();
+        return;
+    }
+
+    buf = (uint8_t *)Z_Malloc(len);
+    FS_Read(buf, len, f);
+    FS_FCloseFile(f);
+
+    if (!rsa_keypair_from_sexp(&cls.rsa.public_key, &cls.rsa.private_key, 0, len, buf))
+    {
+        memset(buf, 0, len);
+        Z_Free(buf);
+        CL_UnloadRSAKeypair();
+        Com_Error(ERR_FATAL, "Invalid RSA private key found.");
+        return;
+    }
+
+    memset(buf, 0, len);
+    Z_Free(buf);
+
+    len = FS_SV_FOpenFileRead(RSA_PUBLIC_KEY_FILE, &f);
+    if (!f || len < 1) CL_WriteRSAPublicKey();
+    if (f) FS_FCloseFile(f);
+
+    Com_DPrintf("RSA private key loaded\n");
+}
+
+/*
+=================
+CL_CheckForResend
+
+Resend a connect message if the last one has timed out
+=================
+*/
+static void CL_CheckForResend(void)
+{
+    int port;
+    char info[MAX_INFO_STRING];
+    char data[MAX_MSGLEN];
+
+    // don't send anything if playing back a demo
+    if (clc.demoplaying)
+    {
+        return;
+    }
+
+    // resend if we haven't gotten a reply yet
+    if (clc.state != CA_CONNECTING && clc.state != CA_CHALLENGING)
+    {
+        return;
+    }
+
+    if (cls.realtime - clc.connectTime < RETRANSMIT_TIMEOUT)
+    {
+        return;
+    }
+
+    clc.connectTime = cls.realtime;  // for retransmit requests
+    clc.connectPacketCount++;
+
+    switch (clc.state)
+    {
+        case CA_CONNECTING:
+            // requesting a challenge
+
+            // The challenge request shall be followed by a client challenge so no malicious server can hijack this
+            // connection.
+            // Add the gamename so the server knows we're running the correct game or can reject the client
+            // with a meaningful message
+            if (clc.serverAddress.alternateProtocol == 2)
+            {
+                Com_sprintf(data, sizeof(data), "getchallenge");
+            }
+            else if (clc.serverAddress.alternateProtocol == 1)
+            {
+                Com_sprintf(data, sizeof(data), "getchallenge %d", clc.challenge);
+            }
+            else
+                Com_sprintf(data, sizeof(data), "getchallenge %d %s", clc.challenge, com_gamename->string);
+
+            NET_OutOfBandPrint(NS_CLIENT, clc.serverAddress, "%s", data);
+            break;
+
+        case CA_CHALLENGING:
+            // sending back the challenge
+            port = Cvar_VariableValue("net_qport");
+
+            Q_strncpyz(info, Cvar_InfoString(CVAR_USERINFO), sizeof(info));
+            Info_SetValueForKey(info, "protocol",
+                va("%i",
+                    (clc.serverAddress.alternateProtocol == 0 ? PROTOCOL_VERSION
+                                                              : clc.serverAddress.alternateProtocol == 1 ? 70 : 69)));
+            Info_SetValueForKey(info, "qport", va("%i", port));
+            Info_SetValueForKey(info, "challenge", va("%i", clc.challenge));
+
+            if (cl_rsaAuth->integer && clc.sendSignature)
+            {
+                char public_key[RSA_STRING_LENGTH];
+                char signature[RSA_STRING_LENGTH];
+                struct sha256_ctx sha256_hash;
+                mpz_t n;
+
+                Info_SetValueForKey(info, "challenge2", clc.challenge2);
+
+                sha256_init(&sha256_hash);
+                sha256_update(&sha256_hash, strlen(info), (uint8_t *)info);
+
+                mpz_init(n);
+                rsa_sha256_sign(&cls.rsa.private_key, &sha256_hash, n);
+                mpz_get_str(signature, 16, n);
+                mpz_clear(n);
+
+                mpz_get_str(public_key, 16, cls.rsa.public_key.n);
+
+                Com_sprintf(data, sizeof(data), "connect \"%s\" %s %s", info, public_key, signature);
+            }
+            else
+            {
+                Com_sprintf(data, sizeof(data), "connect \"%s\"", info);
+            }
+
+            NET_OutOfBandData(NS_CLIENT, clc.serverAddress, (byte *)data, strlen(data));
+            // the most current userinfo has been sent, so watch for any
+            // newer changes to userinfo variables
+            cvar_modifiedFlags &= ~CVAR_USERINFO;
+            break;
+
+        default:
+            Com_Error(ERR_FATAL, "CL_CheckForResend: bad clc.state");
+    }
+}
+
+/*
+=====================
+CL_MapLoading
+
+A local server is starting to load a map, so update the
+screen to let the user know about it, then dump all client
+memory on the hunk from cgame, ui, and renderer
+=====================
+*/
+void CL_MapLoading(void)
+{
+    if (com_dedicated->integer)
+    {
+        clc.state = CA_DISCONNECTED;
+        Key_SetCatcher(KEYCATCH_CONSOLE);
+        CL_ProtocolSpecificCommandsInit();
+        return;
+    }
+
+    if (!com_cl_running->integer)
+    {
+        return;
+    }
+
+    Key_SetCatcher(Key_GetCatcher() & KEYCATCH_CONSOLE);
+
+    // if we are already connected to the local host, stay connected
+    if (clc.state >= CA_CONNECTED && !Q_stricmp(clc.servername, "localhost"))
+    {
+        clc.state = CA_CONNECTED;  // so the connect screen is drawn
+        ::memset(cls.updateInfoString, 0, sizeof(cls.updateInfoString));
+        ::memset(clc.serverMessage, 0, sizeof(clc.serverMessage));
+        ::memset(&cl.gameState, 0, sizeof(cl.gameState));
+        clc.lastPacketSentTime = -9999;
+        SCR_UpdateScreen();
+    }
+    else
+    {
+        CL_Disconnect(true);
+        Q_strncpyz(clc.servername, "localhost", sizeof(clc.servername));
+        clc.state = CA_CHALLENGING;  // so the connect screen is drawn
+        Key_SetCatcher(Key_GetCatcher() & KEYCATCH_CONSOLE);
+        SCR_UpdateScreen();
+        clc.connectTime = -RETRANSMIT_TIMEOUT;
+        NET_StringToAdr(clc.servername, &clc.serverAddress, NA_UNSPEC);
+        // we don't need a challenge on the localhost
+
+        CL_CheckForResend();
+    }
+}
+
+/*
+===================
+CL_MotdPacket
+
+===================
+*/
+static void CL_MotdPacket(netadr_t from, const char *info)
+{
+    const char *v;
+
+    // if not from our server, ignore it
+    if (!NET_CompareAdr(from, cls.updateServer))
+    {
+        Com_DPrintf("MOTD packet from unexpected source\n");
+        return;
+    }
+
+    Com_DPrintf("MOTD packet: %s\n", info);
+    while (*info != '\\') info++;
+
+    // check challenge
+    v = Info_ValueForKey(info, "challenge");
+    if (strcmp(v, cls.updateChallenge))
+    {
+        Com_DPrintf(
+            "MOTD packet mismatched challenge: "
+            "'%s' != '%s'\n",
+            v, cls.updateChallenge);
+        return;
+    }
+
+    v = Info_ValueForKey(info, "motd");
+
+    Q_strncpyz(cls.updateInfoString, info, sizeof(cls.updateInfoString));
+    Cvar_Set("cl_motdString", v);
+}
+
+/*
+===================
+CL_InitServerInfo
+===================
+*/
+static void CL_InitServerInfo(serverInfo_t *server, netadr_t *address)
+{
+    server->adr = *address;
+    server->clients = 0;
+    server->hostName[0] = '\0';
+    server->mapName[0] = '\0';
+    server->label[0] = '\0';
+    server->maxClients = 0;
+    server->maxPing = 0;
+    server->minPing = 0;
+    server->ping = -1;
+    server->game[0] = '\0';
+    server->gameType = 0;
+    server->netType = 0;
+}
+
+/*
+===================
+CL_GSRSequenceInformation
+
+Parses this packet's index and the number of packets from a master server's
+response. Updates the packet count and returns the index. Advances the data
+pointer as appropriate (but only when parsing was successful)
+
+The sequencing information isn't terribly useful at present (we can skip
+duplicate packets, but we don't bother to make sure we've got all of them).
+===================
+*/
+static int CL_GSRSequenceInformation(int alternateProtocol, byte **data)
+{
+    char *p = (char *)*data, *e;
+    int ind, num;
+    // '\0'-delimited fields: this packet's index, total number of packets
+    if (*p++ != '\0') return -1;
+
+    ind = strtol(p, (char **)&e, 10);
+    if (*e++ != '\0') return -1;
+
+    num = strtol(e, (char **)&p, 10);
+    if (*p++ != '\0') return -1;
+
+    if (num <= 0 || ind <= 0 || ind > num) return -1;  // nonsensical response
+
+    if (cls.numAlternateMasterPackets[alternateProtocol] > 0 && num != cls.numAlternateMasterPackets[alternateProtocol])
+    {
+        // Assume we sent two getservers and somehow they changed in
+        // between - only use the results that arrive later
+        Com_DPrintf("Master changed its mind about%s packet count!\n",
+            (alternateProtocol == 0 ? "" : alternateProtocol == 1 ? " alternate-1" : " alternate-2"));
+        cls.receivedAlternateMasterPackets[alternateProtocol] = 0;
+        // cls.numglobalservers = 0;
+        // cls.numGlobalServerAddresses = 0;
+    }
+    cls.numAlternateMasterPackets[alternateProtocol] = num;
+
+    // successfully parsed
+    *data = (byte *)p;
+    return ind;
+}
+
+/*
+===================
+CL_GSRFeaturedLabel
+
+Parses from the data an arbitrary text string labelling the servers in the
+following getserversresponse packet.
+The result is copied to *buf, and *data is advanced as appropriate
+===================
+*/
+static void CL_GSRFeaturedLabel(byte **data, char *buf, int size)
+{
+    char *l = buf;
+
+    // copy until '\0' which indicates field break
+    // or slash which indicates beginning of server list
+    while (**data && **data != '\\' && **data != '/')
+    {
+        if (l < &buf[size - 1])
+            *l = **data;
+        else if (l == &buf[size - 1])
+            Com_DPrintf(S_COLOR_YELLOW
+                "Warning: "
+                "CL_GSRFeaturedLabel: overflow\n");
+        l++, (*data)++;
+    }
+
+    if (l < &buf[size - 1])
+        *l = '\0';
+    else
+        buf[size - 1] = '\0';
+}
+
+#define MAX_SERVERSPERPACKET 256
+
+/*
+===================
+CL_ServersResponsePacket
+===================
+*/
+static void CL_ServersResponsePacket(const netadr_t *from, msg_t *msg, bool extended)
+{
+    int i, count, total;
+    netadr_t addresses[MAX_SERVERSPERPACKET];
+    int numservers;
+    byte *buffptr;
+    byte *buffend;
+    char label[MAX_FEATLABEL_CHARS] = "";
+
+    Com_DPrintf("CL_ServersResponsePacket from %s %s\n",
+            NET_AdrToStringwPort(*from),
+            extended ? " (extended)" : "");
+
+    if (cls.numglobalservers == -1)
+    {
+        // state to detect lack of servers or lack of response
+        cls.numglobalservers = 0;
+        cls.numGlobalServerAddresses = 0;
+        for (i = 0; i < 3; ++i)
+        {
+            cls.numAlternateMasterPackets[i] = 0;
+            cls.receivedAlternateMasterPackets[i] = 0;
+        }
+    }
+
+    // parse through server response string
+    numservers = 0;
+    buffptr = msg->data;
+    buffend = buffptr + msg->cursize;
+
+    // skip header
+    buffptr += 4;
+
+    // advance to initial token
+    // I considered using strchr for this but I don't feel like relying
+    // on its behaviour with '\0'
+    while (*buffptr && *buffptr != '\\' && *buffptr != '/')
+    {
+        buffptr++;
+
+        if (buffptr >= buffend) break;
+    }
+
+    if (*buffptr == '\0')
+    {
+        int ind = CL_GSRSequenceInformation(from->alternateProtocol, &buffptr);
+        if (ind >= 0)
+        {
+            // this denotes the start of new-syntax stuff
+            // have we already received this packet?
+            if (cls.receivedAlternateMasterPackets[from->alternateProtocol] & (1 << (ind - 1)))
+            {
+                Com_DPrintf(
+                    "CL_ServersResponsePacket: "
+                    "received packet %d again, ignoring\n",
+                    ind);
+                return;
+            }
+            // TODO: detect dropped packets and make another
+            // request
+            Com_DPrintf(
+                "CL_ServersResponsePacket:%s packet "
+                "%d of %d\n",
+                (from->alternateProtocol == 0 ? "" : from->alternateProtocol == 1 ? " alternate-1" : " alternate-2"),
+                ind, cls.numAlternateMasterPackets[from->alternateProtocol]);
+            cls.receivedAlternateMasterPackets[from->alternateProtocol] |= (1 << (ind - 1));
+
+            CL_GSRFeaturedLabel(&buffptr, label, sizeof(label));
+        }
+        // now skip to the server list
+        for (; buffptr < buffend && *buffptr != '\\' && *buffptr != '/'; buffptr++)
+            ;
+    }
+
+    while (buffptr + 1 < buffend)
+    {
+        // IPv4 address
+        if (*buffptr == '\\')
+        {
+            buffptr++;
+
+            if (buffend - buffptr < sizeof(addresses[numservers].ip) + sizeof(addresses[numservers].port) + 1) break;
+
+            for (i = 0; i < sizeof(addresses[numservers].ip); i++) addresses[numservers].ip[i] = *buffptr++;
+
+            addresses[numservers].type = NA_IP;
+        }
+        // IPv6 address, if it's an extended response
+        else if (extended && *buffptr == '/')
+        {
+            buffptr++;
+
+            if (buffend - buffptr < sizeof(addresses[numservers].ip6) + sizeof(addresses[numservers].port) + 1) break;
+
+            for (i = 0; i < sizeof(addresses[numservers].ip6); i++) addresses[numservers].ip6[i] = *buffptr++;
+
+            addresses[numservers].type = NA_IP6;
+            addresses[numservers].scope_id = from->scope_id;
+        }
+        else
+            // syntax error!
+            break;
+
+        // parse out port
+        addresses[numservers].port = (*buffptr++) << 8;
+        addresses[numservers].port += *buffptr++;
+        addresses[numservers].port = BigShort(addresses[numservers].port);
+
+        // syntax check
+        if (*buffptr != '\\' && *buffptr != '/') break;
+
+        addresses[numservers].alternateProtocol = from->alternateProtocol;
+
+        numservers++;
+        if (numservers >= MAX_SERVERSPERPACKET) break;
+    }
+
+    count = cls.numglobalservers;
+
+    for (i = 0; i < numservers && count < MAX_GLOBAL_SERVERS; i++)
+    {
+        // build net address
+        serverInfo_t *server = &cls.globalServers[count];
+
+        CL_InitServerInfo(server, &addresses[i]);
+        Q_strncpyz(server->label, label, sizeof(server->label));
+        // advance to next slot
+        count++;
+    }
+
+    // if getting the global list
+    if (count >= MAX_GLOBAL_SERVERS && cls.numGlobalServerAddresses < MAX_GLOBAL_SERVERS)
+    {
+        // if we couldn't store the servers in the main list anymore
+        for (; i < numservers && cls.numGlobalServerAddresses < MAX_GLOBAL_SERVERS; i++)
+        {
+            // just store the addresses in an additional list
+            cls.globalServerAddresses[cls.numGlobalServerAddresses++] = addresses[i];
+        }
+    }
+
+    cls.numglobalservers = count;
+    total = count + cls.numGlobalServerAddresses;
+
+    Com_Printf("%d servers parsed (total %d)\n", numservers, total);
+}
+/*
+==================
+CL_CheckTimeout
+
+==================
+*/
+static void CL_CheckTimeout(void)
+{
+    //
+    // check timeout
+    //
+    if ((!CL_CheckPaused() || !sv_paused->integer) && clc.state >= CA_CONNECTED && clc.state != CA_CINEMATIC &&
+        cls.realtime - clc.lastPacketTime > cl_timeout->value * 1000)
+    {
+        if (++cl.timeoutcount > 5)
+        {  // timeoutcount saves debugger
+            Com_Printf("\nServer connection timed out.\n");
+            CL_Disconnect(true);
+            return;
+        }
+    }
+    else
+    {
+        cl.timeoutcount = 0;
+    }
+}
+
+/*
+==================
+CL_CheckPaused
+Check whether client has been paused.
+==================
+*/
+bool CL_CheckPaused(void)
+{  // if cl_paused->modified is set, the cvar has only been changed in
+    // this frame. Keep paused in this frame to ensure the server doesn't
+    // lag behind.
+    if (cl_paused->integer || cl_paused->modified) return true;
+
+    return false;
+}
+
+//============================================================================
+
+/*
+==================
+CL_CheckUserinfo
+
+==================
+*/
+static void CL_CheckUserinfo(void)
+{
+    // don't add reliable commands when not yet connected
+    if (clc.state < CA_CONNECTED) return;
+
+    // don't overflow the reliable command buffer when paused
+    if (CL_CheckPaused()) return;
+
+    // send a reliable userinfo update if needed
+    if (cvar_modifiedFlags & CVAR_USERINFO)
+    {
+        cvar_modifiedFlags &= ~CVAR_USERINFO;
+        CL_AddReliableCommand(va("userinfo \"%s\"", Cvar_InfoString(CVAR_USERINFO)), false);
+    }
+}
+
+/*
+==================
+CL_Frame
+
+==================
+*/
+void CL_Frame(int msec)
+{
+    if (!com_cl_running->integer) return;
+
+    // We may have a download prompt ready
+    if ((com_downloadPrompt->integer & DLP_TYPE_MASK) && !(com_downloadPrompt->integer & DLP_PROMPTED))
+    {
+        Com_Printf("Download prompt returned %d\n", com_downloadPrompt->integer);
+        CL_NextDownload();
+    }
+    else if (com_downloadPrompt->integer & DLP_SHOW)
+    {
+        // If the UI VM does not support the download prompt, we need to catch
+        // the prompt here and replicate regular behavior.
+        // One frame will always run between requesting and showing the prompt.
+
+        if (com_downloadPrompt->integer & DLP_STALE)
+        {
+            Com_Printf("WARNING: UI VM does not support download prompt\n");
+            Cvar_Set("com_downloadPrompt", va("%d", DLP_IGNORE));
+            CL_NextDownload();
+        }
+        else
+        {
+            Cvar_Set("com_downloadPrompt", va("%d", com_downloadPrompt->integer | DLP_STALE));
+        }
+    }
+
+    if (clc.downloadCURLM)
+    {
+        CL_cURL_PerformDownload();
+        // we can't process frames normally when in disconnected download mode
+        // since the ui vm expects clc.state to be CA_CONNECTED
+        if (clc.cURLDisconnected)
+        {
+            cls.realFrametime = msec;
+            cls.frametime = msec;
+            cls.realtime += cls.frametime;
+
+            SCR_UpdateScreen();
+            S_Update();
+            Con_RunConsole();
+
+            cls.framecount++;
+            return;
+        }
+    }
+
+    if (clc.state == CA_DISCONNECTED && !(Key_GetCatcher() & KEYCATCH_UI) && !com_sv_running->integer && cls.ui)
+    {
+        // if disconnected, bring up the menu
+        S_StopAllSounds();
+        VM_Call(cls.ui, UI_SET_ACTIVE_MENU - (cls.uiInterface == 2 ? 2 : 0), UIMENU_MAIN);
+    }
+
+    // if recording an avi, lock to a fixed fps
+    if (CL_VideoRecording() && cl_aviFrameRate->integer && msec)
+    {
+        // save the current screen
+        if (clc.state == CA_ACTIVE || cl_forceavidemo->integer)
+        {
+            float fps = MIN(cl_aviFrameRate->value * com_timescale->value, 1000.0f);
+            float frameDuration = MAX(1000.0f / fps, 1.0f) + clc.aviVideoFrameRemainder;
+
+            CL_TakeVideoFrame();
+
+            msec = (int)frameDuration;
+            clc.aviVideoFrameRemainder = frameDuration - msec;
+        }
+    }
+
+    if (cl_autoRecordDemo->integer)
+    {
+        if (clc.state == CA_ACTIVE && !clc.demorecording && !clc.demoplaying)
+        {
+            // If not recording a demo, and we should be, start one
+            qtime_t now;
+            Com_RealTime(&now);
+
+            const char *nowString = va("%04d%02d%02d%02d%02d%02d", 1900 + now.tm_year, 1 + now.tm_mon, now.tm_mday,
+                now.tm_hour, now.tm_min, now.tm_sec);
+
+            char serverName[MAX_OSPATH];
+            Q_strncpyz(serverName, clc.servername, MAX_OSPATH);
+
+            // Replace the ":" in the address as it is not a valid
+            // file name character
+            char *p = strstr(serverName, ":");
+            if (p) *p = '.';
+
+            char mapName[MAX_QPATH];
+            Q_strncpyz(mapName, COM_SkipPath(cl.mapname), sizeof(cl.mapname));
+            COM_StripExtension(mapName, mapName, sizeof(mapName));
+            Cbuf_ExecuteText(EXEC_NOW, va("record \"%s-%s-%s\"\n", nowString, serverName, mapName));
+        }
+        else if (clc.state != CA_ACTIVE && clc.demorecording)
+        {
+            // Recording, but not CA_ACTIVE, so stop recording
+            CL_StopRecord_f();
+        }
+    }
+
+    // save the msec before checking pause
+    cls.realFrametime = msec;
+
+    // decide the simulation time
+    cls.frametime = msec;
+
+    cls.realtime += cls.frametime;
+
+    if (cl_timegraph->integer)
+    {
+        SCR_DebugGraph(cls.realFrametime * 0.25);
+    }
+
+    // see if we need to update any userinfo
+    CL_CheckUserinfo();
+
+    // if we haven't gotten a packet in a long time, drop the connection
+    CL_CheckTimeout();
+
+    // send intentions now
+    CL_SendCmd();
+
+    // resend a connection request if necessary
+    CL_CheckForResend();
+
+    // decide on the serverTime to render
+    CL_SetCGameTime();
+
+    // update the screen
+    SCR_UpdateScreen();
+
+    // update audio
+    S_Update();
+
+#ifdef USE_VOIP
+    CL_CaptureVoip();
+#endif
+
+#ifdef USE_MUMBLE
+    CL_UpdateMumble();
+#endif
+
+    // advance local effects for next frame
+    SCR_RunCinematic();
+
+    Con_RunConsole();
+
+    cls.framecount++;
+}
+
+//============================================================================
+
+/*
+================
+CL_RefPrintf
+
+DLL glue
+================
+*/
+static __attribute__((format(printf, 2, 3))) void QDECL CL_RefPrintf(int print_level, const char *fmt, ...)
+{
+    va_list argptr;
+    char msg[MAXPRINTMSG];
+
+    va_start(argptr, fmt);
+    Q_vsnprintf(msg, sizeof(msg), fmt, argptr);
+    va_end(argptr);
+
+    switch (print_level)
+    {
+        case PRINT_ALL:
+            Com_Printf("%s", msg);
+            break;
+
+        case PRINT_WARNING:
+            Com_Printf(S_COLOR_YELLOW "%s", msg);
+            break;
+
+        case PRINT_DEVELOPER:
+            Com_DPrintf(S_COLOR_RED "%s", msg);
+            break;
+    }
+}
+
+/*
+============
+CL_ShutdownRef
+============
+*/
+static void CL_ShutdownRef(void)
+{
+    if (re.Shutdown) re.Shutdown(true);
+
+    ::memset(&re, 0, sizeof(re));
+
+#ifdef USE_RENDERER_DLOPEN
+    if (rendererLib)
+    {
+        Sys_UnloadLibrary(rendererLib);
+        rendererLib = NULL;
+    }
+#endif
+}
+
+/*
+=====================
+CL_ShutdownAll
+=====================
+*/
+void CL_ShutdownAll(bool shutdownRef)
+{
+    if (CL_VideoRecording()) CL_CloseAVI();
+
+    if (clc.demorecording) CL_StopRecord_f();
+
+    CL_cURL_Shutdown();
+
+    // clear sounds
+    S_DisableSounds();
+    // shutdown CGame
+    CL_ShutdownCGame();
+    // shutdown UI
+    CL_ShutdownUI();
+
+    // shutdown the renderer
+    if (shutdownRef)
+        CL_ShutdownRef();
+    else if (re.Shutdown)
+        re.Shutdown(false);  // don't destroy window or context
+
+    cls.uiStarted = false;
+    cls.cgameStarted = false;
+    cls.rendererStarted = false;
+    cls.soundRegistered = false;
+}
+
+/*
+=================
+CL_ClearMemory
+
+Called by Com_GameRestart
+=================
+*/
+static void CL_ClearMemory(bool shutdownRef)
+{
+    // shutdown all the client stuff
+    CL_ShutdownAll(shutdownRef);
+
+    // if not running a server clear the whole hunk
+    if (!com_sv_running->integer)
+    {
+        // clear the whole hunk
+        Hunk_Clear();
+        // clear collision map data
+        CM_ClearMap();
+    }
+    else
+    {
+        // clear all the client data on the hunk
+        Hunk_ClearToMark();
+    }
+}
+
+/*
+=================
+CL_FlushMemory
+
+Called by CL_MapLoading, CL_Connect_f, CL_PlayDemo_f, and CL_ParseGamestate the only
+ways a client gets into a game
+Also called by Com_Error
+=================
+*/
+void CL_FlushMemory(void)
+{
+    CL_ClearMemory(false);
+    CL_StartHunkUsers(false);
+}
+
+/*
+=================
+CL_Vid_Restart_f
+
+Restart the video subsystem
+
+we also have to reload the UI and CGame because the renderer
+doesn't know what graphics to reload
+=================
+*/
+static void CL_Vid_Restart_f(void)
+{
+    // Settings may have changed so stop recording now
+    if (CL_VideoRecording())
+    {
+        CL_CloseAVI();
+    }
+
+    if (clc.demorecording) CL_StopRecord_f();
+
+    // don't let them loop during the restart
+    S_StopAllSounds();
+
+    if (!FS_ConditionalRestart(clc.checksumFeed, true))
+    {
+        // if not running a server clear the whole hunk
+        if (com_sv_running->integer)
+        {
+            // clear all the client data on the hunk
+            Hunk_ClearToMark();
+        }
+        else
+        {
+            // clear the whole hunk
+            Hunk_Clear();
+        }
+
+        // shutdown the UI
+        CL_ShutdownUI();
+        // shutdown the CGame
+        CL_ShutdownCGame();
+        // shutdown the renderer and clear the renderer interface
+        CL_ShutdownRef();
+        // client is no longer pure untill new checksums are sent
+        CL_ResetPureClientAtServer();
+        // clear pak references
+        FS_ClearPakReferences(FS_UI_REF | FS_CGAME_REF);
+        // reinitialize the filesystem if the game directory or checksum has changed
+
+        cls.rendererStarted = false;
+        cls.uiStarted = false;
+        cls.cgameStarted = false;
+        cls.soundRegistered = false;
+
+        // unpause so the cgame definately gets a snapshot and renders a frame
+        Cvar_Set("cl_paused", "0");
+
+        // initialize the renderer interface
+        CL_InitRef();
+
+        // startup all the client stuff
+        CL_StartHunkUsers(false);
+
+        // start the cgame if connected
+        if (clc.state > CA_CONNECTED && clc.state != CA_CINEMATIC)
+        {
+            cls.cgameStarted = true;
+            CL_InitCGame();
+            // send pure checksums
+            CL_SendPureChecksums();
+        }
+    }
+}
+
+/*
+=================
+CL_Snd_Restart_f
+
+Restart the sound subsystem
+The cgame and game must also be forced to restart because
+handles will be invalid
+=================
+*/
+static void CL_Snd_Restart_f(void)
+{
+    CL_Snd_Shutdown();
+    // sound will be reinitialized by vid_restart
+    CL_Vid_Restart_f();
+}
+
+
+/*
+============
+CL_InitRenderer
+============
+*/
+static void CL_InitRenderer(void)
+{
+    // this sets up the renderer and calls R_Init
+    re.BeginRegistration(&cls.glconfig);
+
+    // load character sets
+    cls.charSetShader = re.RegisterShader("gfx/2d/bigchars");
+    cls.whiteShader = re.RegisterShader("white");
+    cls.consoleShader = re.RegisterShader("console");
+    g_console_field_width = cls.glconfig.vidWidth / SMALLCHAR_WIDTH - 2;
+    g_consoleField.widthInChars = g_console_field_width;
+}
+
+/*
+============================
+CL_StartHunkUsers
+
+After the server has cleared the hunk, these will need to be restarted
+This is the only place that any of these functions are called from
+============================
+*/
+void CL_StartHunkUsers(bool rendererOnly)
+{
+    if (!com_cl_running)
+    {
+        return;
+    }
+
+    if (!com_cl_running->integer)
+    {
+        return;
+    }
+
+    if (!cls.rendererStarted)
+    {
+        cls.rendererStarted = true;
+        CL_InitRenderer();
+    }
+
+    if (rendererOnly)
+    {
+        return;
+    }
+
+    if (!cls.soundStarted)
+    {
+        cls.soundStarted = true;
+        S_Init();
+    }
+
+    if (!cls.soundRegistered)
+    {
+        cls.soundRegistered = true;
+        S_BeginRegistration();
+    }
+
+    if (com_dedicated->integer)
+    {
+        return;
+    }
+
+    if (!cls.uiStarted)
+    {
+        cls.uiStarted = true;
+        CL_InitUI();
+    }
+}
+
+/*
+============
+CL_RefMalloc
+============
+*/
+static void *CL_RefMalloc(int size) { return Z_TagMalloc(size, TAG_RENDERER); }
+
+/*
+============
+CL_ScaledMilliseconds
+============
+*/
+int CL_ScaledMilliseconds(void) { return Sys_Milliseconds() * com_timescale->value; }
+
+//===========================================================================================
+
+static void CL_SetModel_f(void)
+{
+    char name[256];
+
+    const char *arg = Cmd_Argv(1);
+    if (arg[0])
+    {
+        Cvar_Set("model", arg);
+        Cvar_Set("headmodel", arg);
+    }
+    else
+    {
+        Cvar_VariableStringBuffer("model", name, sizeof(name));
+        Com_Printf("model is set to %s\n", name);
+    }
+}
+
+//===========================================================================================
+
+/*
+===============
+CL_Video_f
+
+video
+video [filename]
+===============
+*/
+static void CL_Video_f(void)
+{
+    char filename[MAX_OSPATH];
+
+    if (!clc.demoplaying)
+    {
+        Com_Printf("The video command can only be used when playing back demos\n");
+        return;
+    }
+
+    if (Cmd_Argc() == 2)
+    {
+        // explicit filename
+        Com_sprintf(filename, MAX_OSPATH, "videos/%s.avi", Cmd_Argv(1));
+    }
+    else
+    {
+        int i, last;
+
+        // scan for a free filename
+        for (i = 0; i <= 9999; i++)
+        {
+            int a, b, c, d;
+
+            last = i;
+
+            a = last / 1000;
+            last -= a * 1000;
+            b = last / 100;
+            last -= b * 100;
+            c = last / 10;
+            last -= c * 10;
+            d = last;
+
+            Com_sprintf(filename, MAX_OSPATH, "videos/video%d%d%d%d.avi", a, b, c, d);
+
+            if (!FS_FileExists(filename)) break;  // file doesn't exist
+        }
+
+        if (i > 9999)
+        {
+            Com_Printf(S_COLOR_RED "ERROR: no free file names to create video\n");
+            return;
+        }
+    }
+
+    CL_OpenAVIForWriting(filename);
+}
+
+/*
+===============
+CL_StopVideo_f
+===============
+*/
+static void CL_StopVideo_f(void) { CL_CloseAVI(); }
+/*
+===============
+CL_GenerateQKey
+
+test to see if a valid QKEY_FILE exists.  If one does not, try to generate
+it by filling it with 2048 bytes of random data.
+===============
+*/
+static void CL_GenerateQKey(void)
+{
+    int len = 0;
+    unsigned char buff[QKEY_SIZE];
+    fileHandle_t f;
+
+    len = FS_SV_FOpenFileRead(QKEY_FILE, &f);
+    FS_FCloseFile(f);
+    if (len == QKEY_SIZE)
+    {
+        Com_Printf("QKEY found.\n");
+        return;
+    }
+    else
+    {
+        if (len > 0)
+        {
+            Com_Printf("QKEY file size != %d, regenerating\n", QKEY_SIZE);
+        }
+
+        Com_Printf("QKEY building random string\n");
+        Com_RandomBytes(buff, sizeof(buff));
+
+        f = FS_SV_FOpenFileWrite(QKEY_FILE);
+        if (!f)
+        {
+            Com_Printf("QKEY could not open %s for write\n", QKEY_FILE);
+            return;
+        }
+        FS_Write(buff, sizeof(buff), f);
+        FS_FCloseFile(f);
+        Com_Printf("QKEY generated\n");
+    }
+}
+
+static void CL_SetServerInfo(serverInfo_t *server, const char *info, int ping)
+{
+    if (server)
+    {
+        if (info)
+        {
+            server->clients = atoi(Info_ValueForKey(info, "clients"));
+            Q_strncpyz(server->hostName, Info_ValueForKey(info, "hostname"), MAX_HOSTNAME_LENGTH);
+            Q_strncpyz(server->mapName, Info_ValueForKey(info, "mapname"), MAX_NAME_LENGTH);
+            server->maxClients = atoi(Info_ValueForKey(info, "sv_maxclients"));
+            server->gameType = atoi(Info_ValueForKey(info, "gametype"));
+            server->netType = atoi(Info_ValueForKey(info, "nettype"));
+            server->minPing = atoi(Info_ValueForKey(info, "minping"));
+            server->maxPing = atoi(Info_ValueForKey(info, "maxping"));
+            const char *game = Info_ValueForKey(info, "game");
+            Q_strncpyz(server->game, (game[0]) ? game : BASEGAME, MAX_NAME_LENGTH);
+        }
+        server->ping = ping;
+    }
+}
+
+static void CL_SetServerInfoByAddress(netadr_t from, const char *info, int ping)
+{
+    int i;
+
+    for (i = 0; i < MAX_OTHER_SERVERS; i++)
+    {
+        if (NET_CompareAdr(from, cls.localServers[i].adr))
+        {
+            CL_SetServerInfo(&cls.localServers[i], info, ping);
+        }
+    }
+
+    for (i = 0; i < MAX_GLOBAL_SERVERS; i++)
+    {
+        if (NET_CompareAdr(from, cls.globalServers[i].adr))
+        {
+            CL_SetServerInfo(&cls.globalServers[i], info, ping);
+        }
+    }
+
+    for (i = 0; i < MAX_OTHER_SERVERS; i++)
+    {
+        if (NET_CompareAdr(from, cls.favoriteServers[i].adr))
+        {
+            CL_SetServerInfo(&cls.favoriteServers[i], info, ping);
+        }
+    }
+}
+
+/*
+===================
+CL_ServerInfoPacket
+===================
+*/
+static void CL_ServerInfoPacket(netadr_t from, msg_t *msg)
+{
+    int i, type;
+    char info[MAX_INFO_STRING];
+    char *infoString;
+    int prot;
+    char *gamename;
+    bool gameMismatch;
+
+    infoString = MSG_ReadString(msg);
+
+    if (from.alternateProtocol == 0)
+    {
+        // if this isn't the correct gamename, ignore it
+        gamename = Info_ValueForKey(infoString, "gamename");
+
+        gameMismatch = !*gamename || strcmp(gamename, com_gamename->string) != 0;
+
+        if (gameMismatch)
+        {
+            Com_DPrintf("Game mismatch in info packet: %s\n", infoString);
+            return;
+        }
+    }
+
+    // if this isn't the correct protocol version, ignore it
+    prot = atoi(Info_ValueForKey(infoString, "protocol"));
+    if (prot != (from.alternateProtocol == 0 ? PROTOCOL_VERSION : from.alternateProtocol == 1 ? 70 : 69))
+    {
+        Com_DPrintf("Different protocol info packet: %s\n", infoString);
+        return;
+    }
+
+    // iterate servers waiting for ping response
+    for (i = 0; i < MAX_PINGREQUESTS; i++)
+    {
+        if (cl_pinglist[i].adr.port && !cl_pinglist[i].time && NET_CompareAdr(from, cl_pinglist[i].adr))
+        {
+            // calc ping time
+            cl_pinglist[i].time = Sys_Milliseconds() - cl_pinglist[i].start;
+            Com_DPrintf("ping time %dms from %s\n", cl_pinglist[i].time, NET_AdrToString(from));
+
+            // save of info
+            Q_strncpyz(cl_pinglist[i].info, infoString, sizeof(cl_pinglist[i].info));
+
+            // tack on the net type
+            // NOTE: make sure these types are in sync with the netnames strings in the UI
+            switch (from.type)
+            {
+                case NA_BROADCAST:
+                case NA_IP:
+                    type = 1;
+                    break;
+                case NA_IP6:
+                    type = 2;
+                    break;
+                default:
+                    type = 0;
+                    break;
+            }
+            Info_SetValueForKey(cl_pinglist[i].info, "nettype", va("%d", type));
+            CL_SetServerInfoByAddress(from, infoString, cl_pinglist[i].time);
+
+            return;
+        }
+    }
+
+    // if not just sent a local broadcast or pinging local servers
+    if (cls.pingUpdateSource != AS_LOCAL)
+    {
+        return;
+    }
+
+    for (i = 0; i < MAX_OTHER_SERVERS; i++)
+    {
+        // empty slot
+        if (cls.localServers[i].adr.port == 0)
+        {
+            break;
+        }
+
+        // avoid duplicate
+        if (NET_CompareAdr(from, cls.localServers[i].adr))
+        {
+            return;
+        }
+    }
+
+    if (i == MAX_OTHER_SERVERS)
+    {
+        Com_DPrintf("MAX_OTHER_SERVERS hit, dropping infoResponse\n");
+        return;
+    }
+
+    // add this to the list
+    cls.numlocalservers = i + 1;
+    CL_InitServerInfo(&cls.localServers[i], &from);
+
+    Q_strncpyz(info, MSG_ReadString(msg), MAX_INFO_STRING);
+    if (strlen(info))
+    {
+        if (info[strlen(info) - 1] != '\n')
+        {
+            Q_strcat(info, sizeof(info), "\n");
+        }
+        Com_Printf("%s: %s", NET_AdrToStringwPort(from), info);
+    }
+}
+
+/*
+===================
+CL_ServerStatusResponse
+===================
+*/
+static void CL_ServerStatusResponse(netadr_t from, msg_t *msg)
+{
+    char info[MAX_INFO_STRING];
+    int i, l, score, ping;
+    int len;
+    serverStatus_t *serverStatus;
+
+    serverStatus = NULL;
+    for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++)
+    {
+        if (NET_CompareAdr(from, cl_serverStatusList[i].address))
+        {
+            serverStatus = &cl_serverStatusList[i];
+            break;
+        }
+    }
+    // if we didn't request this server status
+    if (!serverStatus)
+    {
+        return;
+    }
+
+    const char *s = MSG_ReadStringLine(msg);
+
+    len = 0;
+    Com_sprintf(&serverStatus->string[len], sizeof(serverStatus->string) - len, "%s", s);
+
+    if (serverStatus->print)
+    {
+        Com_Printf("Server settings:\n");
+        // print cvars
+        while (*s)
+        {
+            for (i = 0; i < 2 && *s; i++)
+            {
+                if (*s == '\\') s++;
+                l = 0;
+                while (*s)
+                {
+                    info[l++] = *s;
+                    if (l >= MAX_INFO_STRING - 1) break;
+                    s++;
+                    if (*s == '\\')
+                    {
+                        break;
+                    }
+                }
+                info[l] = '\0';
+                if (i)
+                {
+                    Com_Printf("%s\n", info);
+                }
+                else
+                {
+                    Com_Printf("%-24s", info);
+                }
+            }
+        }
+    }
+
+    len = strlen(serverStatus->string);
+    Com_sprintf(&serverStatus->string[len], sizeof(serverStatus->string) - len, "\\");
+
+    if (serverStatus->print)
+    {
+        Com_Printf("\nPlayers:\n");
+        Com_Printf("num: score: ping: name:\n");
+    }
+    for (i = 0, s = MSG_ReadStringLine(msg); *s; s = MSG_ReadStringLine(msg), i++)
+    {
+        len = strlen(serverStatus->string);
+        Com_sprintf(&serverStatus->string[len], sizeof(serverStatus->string) - len, "\\%s", s);
+
+        if (serverStatus->print)
+        {
+            score = ping = 0;
+            sscanf(s, "%d %d", &score, &ping);
+            s = strchr(s, ' ');
+            if (s) s = strchr(s + 1, ' ');
+            if (s)
+                s++;
+            else
+                s = "unknown";
+            Com_Printf("%-2d   %-3d    %-3d   %s\n", i, score, ping, s);
+        }
+    }
+    len = strlen(serverStatus->string);
+    Com_sprintf(&serverStatus->string[len], sizeof(serverStatus->string) - len, "\\");
+
+    serverStatus->time = Com_Milliseconds();
+    serverStatus->address = from;
+    serverStatus->pending = false;
+    if (serverStatus->print)
+    {
+        serverStatus->retrieved = true;
+    }
+}
+
+/*
+=================
+CL_ConnectionlessPacket
+
+Responses to broadcasts, etc
+=================
+*/
+static void CL_ConnectionlessPacket(netadr_t from, msg_t *msg)
+{
+    int challenge = 0;
+
+    MSG_BeginReadingOOB(msg);
+    MSG_ReadLong(msg);  // skip the -1
+
+    const char *s = MSG_ReadStringLine(msg);
+
+    Cmd_TokenizeString(s);
+
+    const char *c = Cmd_Argv(0);
+
+    Com_DPrintf("CL packet %s: %s\n", NET_AdrToStringwPort(from), c);
+
+    // challenge from the server we are connecting to
+    if (!Q_stricmp(c, "challengeResponse"))
+    {
+        int ver;
+
+        if (clc.state != CA_CONNECTING)
+        {
+            Com_DPrintf("Unwanted challenge response received. Ignored.\n");
+            return;
+        }
+
+        const char *strver = Cmd_Argv(3);
+        if (*strver)
+        {
+            ver = atoi(strver);
+
+            if (ver != PROTOCOL_VERSION)
+            {
+                Com_Printf(S_COLOR_YELLOW
+                    "Warning: Server reports protocol version %d, we have %d. "
+                    "Trying anyways.\n",
+                    ver, PROTOCOL_VERSION);
+            }
+        }
+        if (clc.serverAddress.alternateProtocol == 0)
+        {
+            c = Cmd_Argv(2);
+            if (*c) challenge = atoi(c);
+
+            if (!*c || challenge != clc.challenge)
+            {
+                Com_Printf("Bad challenge for challengeResponse. Ignored.\n");
+                return;
+            }
+        }
+
+        // start sending challenge response instead of challenge request packets
+        clc.challenge = atoi(Cmd_Argv(1));
+        clc.state = CA_CHALLENGING;
+        clc.connectPacketCount = 0;
+        clc.connectTime = -99999;
+
+        if (cl_rsaAuth->integer)
+        {
+            s = Cmd_Argv(4);
+            if (*s)
+            {
+                Q_strncpyz(clc.challenge2, s, sizeof(clc.challenge2));
+                clc.sendSignature = true;
+            }
+        }
+
+        // take this address as the new server address.  This allows
+        // a server proxy to hand off connections to multiple servers
+        clc.serverAddress = from;
+        Com_DPrintf("challengeResponse: %d\n", clc.challenge);
+        return;
+    }
+
+    // server connection
+    if (!Q_stricmp(c, "connectResponse"))
+    {
+        if (clc.state >= CA_CONNECTED)
+        {
+            Com_Printf("Dup connect received. Ignored.\n");
+            return;
+        }
+        if (clc.state != CA_CHALLENGING)
+        {
+            Com_Printf("connectResponse packet while not connecting. Ignored.\n");
+            return;
+        }
+        if (!NET_CompareAdr(from, clc.serverAddress))
+        {
+            Com_Printf("connectResponse from wrong address. Ignored.\n");
+            return;
+        }
+
+        if (clc.serverAddress.alternateProtocol == 0)
+        {
+            c = Cmd_Argv(1);
+
+            if (*c)
+                challenge = atoi(c);
+            else
+            {
+                Com_Printf("Bad connectResponse received. Ignored.\n");
+                return;
+            }
+
+            if (challenge != clc.challenge)
+            {
+                Com_Printf("ConnectResponse with bad challenge received. Ignored.\n");
+                return;
+            }
+        }
+
+        Netchan_Setup(clc.serverAddress.alternateProtocol, NS_CLIENT, &clc.netchan, from,
+            Cvar_VariableValue("net_qport"), clc.challenge);
+
+        clc.state = CA_CONNECTED;
+        clc.lastPacketSentTime = -9999;  // send first packet immediately
+        return;
+    }
+
+    // server responding to an info broadcast
+    if (!Q_stricmp(c, "infoResponse"))
+    {
+        CL_ServerInfoPacket(from, msg);
+        return;
+    }
+
+    // server responding to a get playerlist
+    if (!Q_stricmp(c, "statusResponse"))
+    {
+        CL_ServerStatusResponse(from, msg);
+        return;
+    }
+
+    // echo request from server
+    if (!Q_stricmp(c, "echo"))
+    {
+        NET_OutOfBandPrint(NS_CLIENT, from, "%s", Cmd_Argv(1));
+        return;
+    }
+
+    // global MOTD from trem master
+    if (!Q_stricmp(c, "motd"))
+    {
+        CL_MotdPacket(from, s);
+        return;
+    }
+
+    // echo request from server
+    if (!Q_stricmp(c, "print"))
+    {
+        s = MSG_ReadString(msg);
+
+        Q_strncpyz(clc.serverMessage, s, sizeof(clc.serverMessage));
+
+        while (clc.serverMessage[strlen(clc.serverMessage) - 1] == '\n')
+            clc.serverMessage[strlen(clc.serverMessage) - 1] = '\0';
+
+        Com_Printf("%s", s);
+
+        return;
+    }
+
+    // list of servers sent back by a master server (classic)
+    if (!Q_strncmp(c, "getserversResponse", 18))
+    {
+        CL_ServersResponsePacket(&from, msg, false);
+
+        return;
+    }
+
+    // list of servers sent back by a master server (extended)
+    if (!Q_strncmp(c, "getserversExtResponse", 21))
+    {
+        CL_ServersResponsePacket(&from, msg, true);
+        return;
+    }
+
+    Com_DPrintf("Unknown connectionless packet command.\n");
+}
+
+/*
+=================
+CL_PacketEvent
+
+A packet has arrived from the main event loop
+=================
+*/
+void CL_PacketEvent(netadr_t from, msg_t *msg)
+{
+    int headerBytes;
+
+    clc.lastPacketTime = cls.realtime;
+
+    if (msg->cursize >= 4 && *(int *)msg->data == -1)
+    {
+        CL_ConnectionlessPacket(from, msg);
+        return;
+    }
+
+    if (clc.state < CA_CONNECTED)
+    {
+        return;  // can't be a valid sequenced packet
+    }
+
+    if (msg->cursize < 4)
+    {
+        Com_Printf("%s: Runt packet\n", NET_AdrToStringwPort(from));
+        return;
+    }
+
+    //
+    // packet from server
+    //
+    if (!NET_CompareAdr(from, clc.netchan.remoteAddress))
+    {
+        Com_DPrintf("%s:sequenced packet without connection\n", NET_AdrToStringwPort(from));
+        // FIXME: send a client disconnect?
+        return;
+    }
+
+    if (!CL_Netchan_Process(&clc.netchan, msg))
+    {
+        return;  // out of order, duplicated, etc
+    }
+
+    // the header is different lengths for reliable and unreliable messages
+    headerBytes = msg->readcount;
+
+    // track the last message received so it can be returned in
+    // client messages, allowing the server to detect a dropped
+    // gamestate
+    clc.serverMessageSequence = LittleLong(*(int *)msg->data);
+
+    clc.lastPacketTime = cls.realtime;
+    CL_ParseServerMessage(msg);
+
+    //
+    // we don't know if it is ok to save a demo message until
+    // after we have parsed the frame
+    //
+    if (clc.demorecording && !clc.demowaiting)
+    {
+        CL_WriteDemoMessage(msg, headerBytes);
+    }
+}
+
+/*
+===================
+CL_GetServerStatus
+===================
+*/
+static serverStatus_t *CL_GetServerStatus(netadr_t from)
+{
+    int i, oldest, oldestTime;
+
+    for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++)
+    {
+        if (NET_CompareAdr(from, cl_serverStatusList[i].address))
+        {
+            return &cl_serverStatusList[i];
+        }
+    }
+    for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++)
+    {
+        if (cl_serverStatusList[i].retrieved)
+        {
+            return &cl_serverStatusList[i];
+        }
+    }
+    oldest = -1;
+    oldestTime = 0;
+    for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++)
+    {
+        if (oldest == -1 || cl_serverStatusList[i].startTime < oldestTime)
+        {
+            oldest = i;
+            oldestTime = cl_serverStatusList[i].startTime;
+        }
+    }
+    return &cl_serverStatusList[oldest];
+}
+
+/*
+===================
+CL_ServerStatus
+===================
+*/
+bool CL_ServerStatus(char *serverAddress, char *serverStatusString, int maxLen)
+{
+    int i;
+    netadr_t to;
+    serverStatus_t *serverStatus;
+
+    // if no server address then reset all server status requests
+    if (!serverAddress)
+    {
+        for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++)
+        {
+            cl_serverStatusList[i].address.port = 0;
+            cl_serverStatusList[i].retrieved = true;
+        }
+        return false;
+    }
+    // get the address
+    if (!NET_StringToAdr(serverAddress, &to, NA_UNSPEC))
+    {
+        return false;
+    }
+    serverStatus = CL_GetServerStatus(to);
+    // if no server status string then reset the server status request for this address
+    if (!serverStatusString)
+    {
+        serverStatus->retrieved = true;
+        return false;
+    }
+
+    // if this server status request has the same address
+    if (NET_CompareAdr(to, serverStatus->address))
+    {
+        // if we received a response for this server status request
+        if (!serverStatus->pending)
+        {
+            Q_strncpyz(serverStatusString, serverStatus->string, maxLen);
+            serverStatus->retrieved = true;
+            serverStatus->startTime = 0;
+            return true;
+        }
+        // resend the request regularly
+        else if (serverStatus->startTime < Com_Milliseconds() - cl_serverStatusResendTime->integer)
+        {
+            serverStatus->print = false;
+            serverStatus->pending = true;
+            serverStatus->retrieved = false;
+            serverStatus->time = 0;
+            serverStatus->startTime = Com_Milliseconds();
+            NET_OutOfBandPrint(NS_CLIENT, to, "getstatus");
+            return false;
+        }
+    }
+    // if retrieved
+    else if (serverStatus->retrieved)
+    {
+        serverStatus->address = to;
+        serverStatus->print = false;
+        serverStatus->pending = true;
+        serverStatus->retrieved = false;
+        serverStatus->startTime = Com_Milliseconds();
+        serverStatus->time = 0;
+        NET_OutOfBandPrint(NS_CLIENT, to, "getstatus");
+        return false;
+    }
+    return false;
+}
+
+/*
+==================
+CL_LocalServers_f
+==================
+*/
+static void CL_LocalServers_f(void)
+{
+    const char *message;
+    int i, j;
+    netadr_t to;
+
+    Com_Printf("Scanning for servers on the local network...\n");
+
+    // reset the list, waiting for response
+    cls.numlocalservers = 0;
+    cls.pingUpdateSource = AS_LOCAL;
+
+    for (i = 0; i < MAX_OTHER_SERVERS; i++)
+    {
+        bool b = cls.localServers[i].visible;
+        ::memset(&cls.localServers[i], 0, sizeof(cls.localServers[i]));
+        cls.localServers[i].visible = b;
+    }
+    ::memset(&to, 0, sizeof(to));
+
+    // The 'xxx' in the message is a challenge that will be echoed back
+    // by the server.  We don't care about that here, but master servers
+    // can use that to prevent spoofed server responses from invalid ip
+    message = "\377\377\377\377getinfo xxx";
+
+    // send each message twice in case one is dropped
+    for (i = 0; i < 2; i++)
+    {
+        // send a broadcast packet on each server port
+        // we support multiple server ports so a single machine
+        // can nicely run multiple servers
+        for (j = 0; j < NUM_SERVER_PORTS; j++)
+        {
+            to.port = BigShort((short)(PORT_SERVER + j));
+
+            to.type = NA_BROADCAST;
+            NET_SendPacket(NS_CLIENT, strlen(message), message, to);
+            to.type = NA_MULTICAST6;
+            NET_SendPacket(NS_CLIENT, strlen(message), message, to);
+        }
+    }
+}
+
+/*
+==================
+CL_GlobalServers_f
+==================
+*/
+static void CL_GlobalServers_f(void)
+{
+    int netAlternateProtocols, a;
+    int i;
+    char command[1024];
+    const char *masteraddress;
+
+    int masterNum;
+    int count = Cmd_Argc();
+    if ( count < 2 || (masterNum = atoi(Cmd_Argv(1))) < 0 || masterNum > MAX_MASTER_SERVERS )
+    {
+        Com_Printf("usage: globalservers <master# 0-%d> [keywords]\n", MAX_MASTER_SERVERS);
+        return;
+    }
+
+    netAlternateProtocols = Cvar_VariableIntegerValue("net_alternateProtocols");
+
+    for (a = 0; a < 3; ++a)
+    {
+        // indent
+        if (a == 0 && (netAlternateProtocols & NET_DISABLEPRIMPROTO)) continue;
+        if (a == 1 && !(netAlternateProtocols & NET_ENABLEALT1PROTO)) continue;
+        if (a == 2 && !(netAlternateProtocols & NET_ENABLEALT2PROTO)) continue;
+
+        // request from all master servers
+        if ( masterNum == 0 )
+        {
+            int numAddress = 0;
+
+            for ( int i = 1; i <= MAX_MASTER_SERVERS; i++ )
+            {
+                sprintf(command, "sv_master%d", i);
+                masteraddress = Cvar_VariableString(command);
+
+                if(!*masteraddress)
+                    continue;
+
+                numAddress++;
+
+                Com_sprintf(command, sizeof(command), "globalservers %d %s %s\n", i, Cmd_Argv(2), Cmd_ArgsFrom(3));
+                Cbuf_AddText(command);
+            }
+
+            if ( !numAddress )
+                Com_Printf("CL_GlobalServers_f: Error: No master server addresses.\n");
+
+            return;
+        }
+
+        sprintf(command, "sv_%smaster%d", (a == 0 ? "" : a == 1 ? "alt1" : "alt2"), masterNum);
+        masteraddress = Cvar_VariableString(command);
+
+        if (!*masteraddress)
+        {
+            Com_Printf("CL_GlobalServers_f: Error: No%s master server address given.\n",
+                (a == 0 ? "" : a == 1 ? " alternate-1" : " alternate-2"));
+            continue;
+        }
+
+        // reset the list, waiting for response
+        // -1 is used to distinguish a "no response"
+        netadr_t to;
+        int i = NET_StringToAdr(masteraddress, &to, NA_UNSPEC);
+
+        if ( i == 0 )
+        {
+            Com_Printf("CL_GlobalServers_f: Error: could not resolve address of%s master %s\n",
+                (a == 0 ? "" : a == 1 ? " alternate-1" : " alternate-2"), masteraddress);
+            continue;
+        }
+        else if ( i == 2 )
+        {
+            to.port = BigShort(a == 0 ? PORT_MASTER : a == 1 ? ALT1PORT_MASTER : ALT2PORT_MASTER);
+        }
+        to.alternateProtocol = a;
+
+        Com_Printf("Requesting servers from%s master %s...\n",
+                a == 0 ? "" : a == 1 ? " alternate-1" : " alternate-2",
+                masteraddress);
+
+        cls.numglobalservers = -1;
+        cls.pingUpdateSource = AS_GLOBAL;
+
+        Com_sprintf(command, sizeof(command), "getserversExt %s %i%s",
+                com_gamename->string,
+                a == 0 ? PROTOCOL_VERSION : a == 1 ? 70 : 69,
+                Cvar_VariableIntegerValue("net_enabled") & NET_ENABLEV4 ? "" : " ipv6");
+
+        for (i = 3; i < count; i++)
+        {
+            Q_strcat(command, sizeof(command), " ");
+            Q_strcat(command, sizeof(command), Cmd_Argv(i));
+        }
+
+        NET_OutOfBandPrint(NS_SERVER, to, "%s", command);
+        // outdent
+    }
+    CL_RequestMotd();
+}
+
+/*
+==================
+CL_GetPing
+==================
+*/
+void CL_GetPing(int n, char *buf, int buflen, int *pingtime)
+{
+    const char *str;
+    int time;
+    int maxPing;
+
+    if (n < 0 || n >= MAX_PINGREQUESTS || !cl_pinglist[n].adr.port)
+    {
+        // empty or invalid slot
+        buf[0] = '\0';
+        *pingtime = 0;
+        return;
+    }
+
+    str = NET_AdrToStringwPort(cl_pinglist[n].adr);
+    Q_strncpyz(buf, str, buflen);
+
+    time = cl_pinglist[n].time;
+    if (!time)
+    {
+        // check for timeout
+        time = Sys_Milliseconds() - cl_pinglist[n].start;
+        maxPing = Cvar_VariableIntegerValue("cl_maxPing");
+        if (maxPing < 100)
+        {
+            maxPing = 100;
+        }
+        if (time < maxPing)
+        {
+            // not timed out yet
+            time = 0;
+        }
+    }
+
+    CL_SetServerInfoByAddress(cl_pinglist[n].adr, cl_pinglist[n].info, cl_pinglist[n].time);
+
+    *pingtime = time;
+}
+
+/*
+==================
+CL_GetPingInfo
+==================
+*/
+void CL_GetPingInfo(int n, char *buf, int buflen)
+{
+    if (n < 0 || n >= MAX_PINGREQUESTS || !cl_pinglist[n].adr.port)
+    {
+        // empty or invalid slot
+        if (buflen) buf[0] = '\0';
+        return;
+    }
+
+    Q_strncpyz(buf, cl_pinglist[n].info, buflen);
+}
+
+/*
+==================
+CL_ClearPing
+==================
+*/
+void CL_ClearPing(int n)
+{
+    if (n < 0 || n >= MAX_PINGREQUESTS) return;
+
+    cl_pinglist[n].adr.port = 0;
+}
+
+/*
+==================
+CL_GetPingQueueCount
+==================
+*/
+int CL_GetPingQueueCount(void)
+{
+    int i;
+    int count;
+    ping_t *pingptr;
+
+    count = 0;
+    pingptr = cl_pinglist;
+
+    for (i = 0; i < MAX_PINGREQUESTS; i++, pingptr++)
+    {
+        if (pingptr->adr.port)
+        {
+            count++;
+        }
+    }
+
+    return (count);
+}
+
+/*
+==================
+CL_GetFreePing
+==================
+*/
+static ping_t *CL_GetFreePing(void)
+{
+    ping_t *pingptr;
+    ping_t *best;
+    int oldest;
+    int i;
+    int time;
+
+    pingptr = cl_pinglist;
+    for (i = 0; i < MAX_PINGREQUESTS; i++, pingptr++)
+    {
+        // find free ping slot
+        if (pingptr->adr.port)
+        {
+            if (!pingptr->time)
+            {
+                if (Sys_Milliseconds() - pingptr->start < 500)
+                {
+                    // still waiting for response
+                    continue;
+                }
+            }
+            else if (pingptr->time < 500)
+            {
+                // results have not been queried
+                continue;
+            }
+        }
+
+        // clear it
+        pingptr->adr.port = 0;
+        return (pingptr);
+    }
+
+    // use oldest entry
+    pingptr = cl_pinglist;
+    best = cl_pinglist;
+    oldest = INT_MIN;
+    for (i = 0; i < MAX_PINGREQUESTS; i++, pingptr++)
+    {
+        // scan for oldest
+        time = Sys_Milliseconds() - pingptr->start;
+        if (time > oldest)
+        {
+            oldest = time;
+            best = pingptr;
+        }
+    }
+
+    return (best);
+}
+
+/*
+==================
+CL_Ping_f
+==================
+*/
+static void CL_Ping_f(void)
+{
+    netadr_t to;
+    ping_t *pingptr;
+    const char *server;
+    int argc;
+    netadrtype_t family = NA_UNSPEC;
+
+    argc = Cmd_Argc();
+
+    if (argc != 2 && argc != 3)
+    {
+        Com_Printf("usage: ping [-4|-6] server\n");
+        return;
+    }
+
+    if (argc == 2)
+        server = Cmd_Argv(1);
+    else
+    {
+        if (!strcmp(Cmd_Argv(1), "-4"))
+            family = NA_IP;
+        else if (!strcmp(Cmd_Argv(1), "-6"))
+            family = NA_IP6;
+        else
+            Com_Printf("warning: only -4 or -6 as address type understood.\n");
+
+        server = Cmd_Argv(2);
+    }
+
+    ::memset(&to, 0, sizeof(netadr_t));
+
+    if (!NET_StringToAdr(server, &to, family))
+    {
+        return;
+    }
+
+    pingptr = CL_GetFreePing();
+
+    memcpy(&pingptr->adr, &to, sizeof(netadr_t));
+    pingptr->start = Sys_Milliseconds();
+    pingptr->time = 0;
+
+    CL_SetServerInfoByAddress(pingptr->adr, NULL, 0);
+
+    NET_OutOfBandPrint(NS_CLIENT, to, "getinfo xxx");
+}
+
+/*
+==================
+CL_UpdateVisiblePings_f
+==================
+*/
+bool CL_UpdateVisiblePings_f(int source)
+{
+    int slots, i;
+    char buff[MAX_STRING_CHARS];
+    int pingTime;
+    int max;
+    bool status = false;
+
+    if (source < 0 || source > AS_FAVORITES)
+    {
+        return false;
+    }
+
+    cls.pingUpdateSource = source;
+
+    slots = CL_GetPingQueueCount();
+    if (slots < MAX_PINGREQUESTS)
+    {
+        serverInfo_t *server = NULL;
+
+        switch (source)
+        {
+            case AS_LOCAL:
+                server = &cls.localServers[0];
+                max = cls.numlocalservers;
+                break;
+            case AS_GLOBAL:
+                server = &cls.globalServers[0];
+                max = cls.numglobalservers;
+                break;
+            case AS_FAVORITES:
+                server = &cls.favoriteServers[0];
+                max = cls.numfavoriteservers;
+                break;
+            default:
+                return false;
+        }
+        for (i = 0; i < max; i++)
+        {
+            if (server[i].visible)
+            {
+                if (server[i].ping == -1)
+                {
+                    int j;
+
+                    if (slots >= MAX_PINGREQUESTS)
+                    {
+                        break;
+                    }
+                    for (j = 0; j < MAX_PINGREQUESTS; j++)
+                    {
+                        if (!cl_pinglist[j].adr.port)
+                        {
+                            continue;
+                        }
+                        if (NET_CompareAdr(cl_pinglist[j].adr, server[i].adr))
+                        {
+                            // already on the list
+                            break;
+                        }
+                    }
+                    if (j >= MAX_PINGREQUESTS)
+                    {
+                        status = true;
+                        for (j = 0; j < MAX_PINGREQUESTS; j++)
+                        {
+                            if (!cl_pinglist[j].adr.port)
+                            {
+                                break;
+                            }
+                        }
+                        memcpy(&cl_pinglist[j].adr, &server[i].adr, sizeof(netadr_t));
+                        cl_pinglist[j].start = Sys_Milliseconds();
+                        cl_pinglist[j].time = 0;
+                        NET_OutOfBandPrint(NS_CLIENT, cl_pinglist[j].adr, "getinfo xxx");
+                        slots++;
+                    }
+                }
+                // if the server has a ping higher than cl_maxPing or
+                // the ping packet got lost
+                else if (server[i].ping == 0)
+                {
+                    // if we are updating global servers
+                    if (source == AS_GLOBAL)
+                    {
+                        //
+                        if (cls.numGlobalServerAddresses > 0)
+                        {
+                            // overwrite this server with one from the additional global servers
+                            cls.numGlobalServerAddresses--;
+                            CL_InitServerInfo(&server[i], &cls.globalServerAddresses[cls.numGlobalServerAddresses]);
+                            // NOTE: the server[i].visible flag stays untouched
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (slots)
+    {
+        status = true;
+    }
+    for (i = 0; i < MAX_PINGREQUESTS; i++)
+    {
+        if (!cl_pinglist[i].adr.port)
+        {
+            continue;
+        }
+        CL_GetPing(i, buff, MAX_STRING_CHARS, &pingTime);
+        if (pingTime != 0)
+        {
+            CL_ClearPing(i);
+            status = true;
+        }
+    }
+
+    return status;
+}
+
+/*
+==================
+CL_ServerStatus_f
+==================
+*/
+static void CL_ServerStatus_f(void)
+{
+    netadr_t to, *toptr = NULL;
+    const char *server;
+    serverStatus_t *serverStatus;
+    int argc;
+    netadrtype_t family = NA_UNSPEC;
+
+    argc = Cmd_Argc();
+
+    if (argc != 2 && argc != 3)
+    {
+        if (clc.state != CA_ACTIVE || clc.demoplaying)
+        {
+            Com_Printf("Not connected to a server.\n");
+            Com_Printf("usage: serverstatus [-4|-6] server\n");
+            return;
+        }
+
+        toptr = &clc.serverAddress;
+    }
+
+    if (!toptr)
+    {
+        ::memset(&to, 0, sizeof(netadr_t));
+
+        if (argc == 2)
+            server = Cmd_Argv(1);
+        else
+        {
+            if (!strcmp(Cmd_Argv(1), "-4"))
+                family = NA_IP;
+            else if (!strcmp(Cmd_Argv(1), "-6"))
+                family = NA_IP6;
+            else
+                Com_Printf("warning: only -4 or -6 as address type understood.\n");
+
+            server = Cmd_Argv(2);
+        }
+
+        toptr = &to;
+        if (!NET_StringToAdr(server, toptr, family)) return;
+    }
+
+    NET_OutOfBandPrint(NS_CLIENT, *toptr, "getstatus");
+
+    serverStatus = CL_GetServerStatus(*toptr);
+    serverStatus->address = *toptr;
+    serverStatus->print = true;
+    serverStatus->pending = true;
+}
+
+/*
+============
+CL_InitRef
+============
+*/
+static void CL_InitRef(void)
+{
+    refimport_t ri;
+    refexport_t *ret;
+#ifdef USE_RENDERER_DLOPEN
+    GetRefAPI_t GetRefAPI;
+    char dllName[MAX_OSPATH];
+#endif
+
+    Com_Printf("----- Initializing Renderer ----\n");
+
+#ifdef USE_RENDERER_DLOPEN
+    cl_renderer = Cvar_Get("cl_renderer", "opengl2", CVAR_ARCHIVE | CVAR_LATCH);
+
+    Com_sprintf(dllName, sizeof(dllName), "renderer_%s" DLL_EXT, cl_renderer->string);
+
+    if (!(rendererLib = Sys_LoadDll(dllName, false)) && strcmp(cl_renderer->string, cl_renderer->resetString))
+    {
+        Com_Printf("failed:\n\"%s\"\n", Sys_LibraryError());
+        Cvar_ForceReset("cl_renderer");
+
+        Com_sprintf(dllName, sizeof(dllName), "renderer_opengl1" DLL_EXT);
+        rendererLib = Sys_LoadDll(dllName, false);
+    }
+
+    if (!rendererLib)
+    {
+        Com_Printf("failed:\n\"%s\"\n", Sys_LibraryError());
+        Com_Error(ERR_FATAL, "Failed to load renderer");
+    }
+
+    GetRefAPI = (GetRefAPI_t)Sys_LoadFunction(rendererLib, "GetRefAPI");
+    if (!GetRefAPI)
+    {
+        Com_Error(ERR_FATAL, "Can't load symbol GetRefAPI: '%s'", Sys_LibraryError());
+    }
+#endif
+
+    ri.Cmd_AddCommand = Cmd_AddCommand;
+    ri.Cmd_RemoveCommand = Cmd_RemoveCommand;
+    ri.Cmd_Argc = Cmd_Argc;
+    ri.Cmd_Argv = Cmd_Argv;
+    ri.Cmd_ExecuteText = Cbuf_ExecuteText;
+    ri.Printf = CL_RefPrintf;
+    ri.Error = Com_Error;
+    ri.Milliseconds = CL_ScaledMilliseconds;
+    ri.Malloc = CL_RefMalloc;
+    ri.Free = Z_Free;
+#ifdef HUNK_DEBUG
+    ri.Hunk_AllocDebug = Hunk_AllocDebug;
+#else
+    ri.Hunk_Alloc = Hunk_Alloc;
+#endif
+    ri.Hunk_AllocateTempMemory = Hunk_AllocateTempMemory;
+    ri.Hunk_FreeTempMemory = Hunk_FreeTempMemory;
+
+    ri.CM_ClusterPVS = CM_ClusterPVS;
+    ri.CM_DrawDebugSurface = CM_DrawDebugSurface;
+
+    ri.FS_ReadFile = FS_ReadFile;
+    ri.FS_FreeFile = FS_FreeFile;
+    ri.FS_WriteFile = FS_WriteFile;
+    ri.FS_FreeFileList = FS_FreeFileList;
+    ri.FS_ListFiles = FS_ListFiles;
+    ri.FS_FileIsInPAK = FS_FileIsInPAK;
+    ri.FS_FileExists = FS_FileExists;
+    ri.Cvar_Get = Cvar_Get;
+    ri.Cvar_Set = Cvar_Set;
+    ri.Cvar_SetValue = Cvar_SetValue;
+    ri.Cvar_CheckRange = Cvar_CheckRange;
+    ri.Cvar_SetDescription = Cvar_SetDescription;
+    ri.Cvar_VariableIntegerValue = Cvar_VariableIntegerValue;
+
+    // cinematic stuff
+
+    ri.CIN_UploadCinematic = CIN_UploadCinematic;
+    ri.CIN_PlayCinematic = CIN_PlayCinematic;
+    ri.CIN_RunCinematic = CIN_RunCinematic;
+
+    ri.CL_WriteAVIVideoFrame = CL_WriteAVIVideoFrame;
+
+    ri.IN_Init = IN_Init;
+    ri.IN_Shutdown = IN_Shutdown;
+    ri.IN_Restart = IN_Restart;
+
+    ri.Sys_GLimpSafeInit = Sys_GLimpSafeInit;
+    ri.Sys_GLimpInit = Sys_GLimpInit;
+    ri.Sys_LowPhysicalMemory = Sys_LowPhysicalMemory;
+
+    ret = GetRefAPI(REF_API_VERSION, &ri);
+
+#if defined __USEA3D && defined __A3D_GEOM
+    hA3Dg_ExportRenderGeom(ret);
+#endif
+
+    Com_Printf("-------------------------------\n");
+
+    if (!ret)
+    {
+        Com_Error(ERR_FATAL, "Couldn't initialize refresh");
+    }
+
+    re = *ret;
+
+    // unpause so the cgame definately gets a snapshot and renders a frame
+    Cvar_Set("cl_paused", "0");
+}
+
+/*
+====================
+CL_ProtocolSpecificCommandsInit
+
+For adding/remove commands that depend on a/some
+specific protocols, whenever the protcol may change
+====================
+*/
+void CL_ProtocolSpecificCommandsInit(void)
+{
+  Con_MessageModesInit();
+}
+
+/*
+====================
+CL_Init
+====================
+*/
+void CL_Init(void)
+{
+    Com_Printf("----- Client Initialization -----\n");
+
+    Con_Init();
+
+    if (!com_fullyInitialized)
+    {
+        CL_ClearState();
+        clc.state = CA_DISCONNECTED;  // no longer CA_UNINITIALIZED
+        cl_oldGameSet = false;
+    }
+
+    CL_InitInput();
+
+    //
+    // register our variables
+    //
+    cl_noprint = Cvar_Get("cl_noprint", "0", 0);
+    cl_motd = Cvar_Get("cl_motd", "1", 0);
+
+    cl_timeout = Cvar_Get("cl_timeout", "200", 0);
+
+    cl_timeNudge = Cvar_Get("cl_timeNudge", "0", CVAR_TEMP);
+    cl_shownet = Cvar_Get("cl_shownet", "0", CVAR_TEMP);
+    cl_showSend = Cvar_Get("cl_showSend", "0", CVAR_TEMP);
+    cl_showTimeDelta = Cvar_Get("cl_showTimeDelta", "0", CVAR_TEMP);
+    cl_freezeDemo = Cvar_Get("cl_freezeDemo", "0", CVAR_TEMP);
+    rcon_client_password = Cvar_Get("rconPassword", "", CVAR_TEMP);
+    cl_activeAction = Cvar_Get("activeAction", "", CVAR_TEMP);
+
+    cl_timedemo = Cvar_Get("timedemo", "0", 0);
+    cl_timedemoLog = Cvar_Get("cl_timedemoLog", "", CVAR_ARCHIVE);
+    cl_autoRecordDemo = Cvar_Get("cl_autoRecordDemo", "0", CVAR_ARCHIVE);
+    cl_aviFrameRate = Cvar_Get("cl_aviFrameRate", "25", CVAR_ARCHIVE);
+    cl_aviMotionJpeg = Cvar_Get("cl_aviMotionJpeg", "1", CVAR_ARCHIVE);
+    cl_forceavidemo = Cvar_Get("cl_forceavidemo", "0", 0);
+
+    rconAddress = Cvar_Get("rconAddress", "", 0);
+
+    cl_yawspeed = Cvar_Get("cl_yawspeed", "140", CVAR_ARCHIVE);
+    cl_pitchspeed = Cvar_Get("cl_pitchspeed", "140", CVAR_ARCHIVE);
+    cl_anglespeedkey = Cvar_Get("cl_anglespeedkey", "1.5", 0);
+
+    cl_maxpackets = Cvar_Get("cl_maxpackets", "30", CVAR_ARCHIVE);
+    cl_packetdup = Cvar_Get("cl_packetdup", "1", CVAR_ARCHIVE);
+
+    cl_run = Cvar_Get("cl_run", "1", CVAR_ARCHIVE);
+    cl_sensitivity = Cvar_Get("sensitivity", "5", CVAR_ARCHIVE);
+    cl_mouseAccel = Cvar_Get("cl_mouseAccel", "0", CVAR_ARCHIVE);
+    cl_freelook = Cvar_Get("cl_freelook", "1", CVAR_ARCHIVE);
+
+    // 0: legacy mouse acceleration
+    // 1: new implementation
+    cl_mouseAccelStyle = Cvar_Get("cl_mouseAccelStyle", "0", CVAR_ARCHIVE);
+    // offset for the power function (for style 1, ignored otherwise)
+    // this should be set to the max rate value
+    cl_mouseAccelOffset = Cvar_Get("cl_mouseAccelOffset", "5", CVAR_ARCHIVE);
+    Cvar_CheckRange(cl_mouseAccelOffset, 0.001f, 50000.0f, false);
+
+    cl_showMouseRate = Cvar_Get("cl_showmouserate", "0", 0);
+
+    cl_allowDownload = Cvar_Get("cl_allowDownload", "1", CVAR_ARCHIVE);
+
+    if (cl_allowDownload->integer != -1) cl_allowDownload->integer = DLF_ENABLE;
+
+    com_downloadPrompt = Cvar_Get("com_downloadPrompt", "0", CVAR_ROM);
+    Cvar_Get("com_downloadPromptText", "", CVAR_TEMP);
+
+    cl_conXOffset = Cvar_Get("cl_conXOffset", "0", 0);
+#ifdef __APPLE__
+    // In game video is REALLY slow in Mac OS X right now due to driver slowness
+    cl_inGameVideo = Cvar_Get("r_inGameVideo", "0", CVAR_ARCHIVE);
+#else
+    cl_inGameVideo = Cvar_Get("r_inGameVideo", "1", CVAR_ARCHIVE);
+#endif
+
+    cl_serverStatusResendTime = Cvar_Get("cl_serverStatusResendTime", "750", 0);
+
+    m_pitch = Cvar_Get("m_pitch", "0.022", CVAR_ARCHIVE);
+    m_yaw = Cvar_Get("m_yaw", "0.022", CVAR_ARCHIVE);
+    m_forward = Cvar_Get("m_forward", "0.25", CVAR_ARCHIVE);
+    m_side = Cvar_Get("m_side", "0.25", CVAR_ARCHIVE);
+#ifdef __APPLE__
+    // Input is jittery on OS X w/o this
+    m_filter = Cvar_Get("m_filter", "1", CVAR_ARCHIVE);
+#else
+    m_filter = Cvar_Get("m_filter", "0", CVAR_ARCHIVE);
+#endif
+
+    j_pitch = Cvar_Get("j_pitch", "0.022", CVAR_ARCHIVE);
+    j_yaw = Cvar_Get("j_yaw", "-0.022", CVAR_ARCHIVE);
+    j_forward = Cvar_Get("j_forward", "-0.25", CVAR_ARCHIVE);
+    j_side = Cvar_Get("j_side", "0.25", CVAR_ARCHIVE);
+    j_up = Cvar_Get("j_up", "0", CVAR_ARCHIVE);
+
+    j_pitch_axis = Cvar_Get("j_pitch_axis", "3", CVAR_ARCHIVE);
+    j_yaw_axis = Cvar_Get("j_yaw_axis", "2", CVAR_ARCHIVE);
+    j_forward_axis = Cvar_Get("j_forward_axis", "1", CVAR_ARCHIVE);
+    j_side_axis = Cvar_Get("j_side_axis", "0", CVAR_ARCHIVE);
+    j_up_axis = Cvar_Get("j_up_axis", "4", CVAR_ARCHIVE);
+
+    Cvar_CheckRange(j_pitch_axis, 0, MAX_JOYSTICK_AXIS - 1, true);
+    Cvar_CheckRange(j_yaw_axis, 0, MAX_JOYSTICK_AXIS - 1, true);
+    Cvar_CheckRange(j_forward_axis, 0, MAX_JOYSTICK_AXIS - 1, true);
+    Cvar_CheckRange(j_side_axis, 0, MAX_JOYSTICK_AXIS - 1, true);
+    Cvar_CheckRange(j_up_axis, 0, MAX_JOYSTICK_AXIS - 1, true);
+
+    cl_motdString = Cvar_Get("cl_motdString", "", CVAR_ROM);
+
+    Cvar_Get("cl_maxPing", "800", CVAR_ARCHIVE);
+
+    cl_lanForcePackets = Cvar_Get("cl_lanForcePackets", "1", CVAR_ARCHIVE);
+
+    cl_guidServerUniq = Cvar_Get("cl_guidServerUniq", "1", CVAR_ARCHIVE);
+
+    cl_rsaAuth = Cvar_Get("cl_rsaAuth", "0", CVAR_INIT | CVAR_PROTECTED);
+
+    // ~ and `, as keys and characters
+    cl_consoleKeys = Cvar_Get("cl_consoleKeys", "~ ` 0x7e 0x60", CVAR_ARCHIVE);
+
+    cl_clantag = Cvar_Get ("cl_clantag", "", CVAR_ARCHIVE);
+
+    // userinfo
+    Cvar_Get("name", "UnnamedPlayer", CVAR_USERINFO | CVAR_ARCHIVE);
+    cl_rate = Cvar_Get("rate", "25000", CVAR_USERINFO | CVAR_ARCHIVE);
+    Cvar_Get("snaps", "40", CVAR_USERINFO | CVAR_ARCHIVE);
+    Cvar_Get("color1", "4", CVAR_USERINFO | CVAR_ARCHIVE);
+    Cvar_Get("color2", "5", CVAR_USERINFO | CVAR_ARCHIVE);
+    Cvar_Get("handicap", "100", CVAR_USERINFO | CVAR_ARCHIVE);
+    Cvar_Get("sex", "male", CVAR_USERINFO | CVAR_ARCHIVE);
+
+    Cvar_Get("password", "", CVAR_USERINFO);
+
+#ifdef USE_MUMBLE
+    cl_useMumble = Cvar_Get("cl_useMumble", "0", CVAR_ARCHIVE | CVAR_LATCH);
+    cl_mumbleScale = Cvar_Get("cl_mumbleScale", "0.0254", CVAR_ARCHIVE);
+#endif
+
+#ifdef USE_VOIP
+    cl_voipSend = Cvar_Get("cl_voipSend", "0", 0);
+    cl_voipSendTarget = Cvar_Get("cl_voipSendTarget", "spatial", 0);
+    cl_voipGainDuringCapture = Cvar_Get("cl_voipGainDuringCapture", "0.2", CVAR_ARCHIVE);
+    cl_voipCaptureMult = Cvar_Get("cl_voipCaptureMult", "2.0", CVAR_ARCHIVE);
+    cl_voipUseVAD = Cvar_Get("cl_voipUseVAD", "0", CVAR_ARCHIVE);
+    cl_voipVADThreshold = Cvar_Get("cl_voipVADThreshold", "0.25", CVAR_ARCHIVE);
+    cl_voipShowMeter = Cvar_Get("cl_voipShowMeter", "1", CVAR_ARCHIVE);
+
+    cl_voip = Cvar_Get("cl_voip", "1", CVAR_ARCHIVE);
+    Cvar_CheckRange(cl_voip, 0, 1, true);
+    cl_voipProtocol = Cvar_Get("cl_voipProtocol", cl_voip->integer ? "opus" : "", CVAR_USERINFO | CVAR_ROM);
+#endif
+
+    // cgame might not be initialized before menu is used
+    Cvar_Get("cg_viewsize", "100", CVAR_ARCHIVE);
+    // Make sure cg_stereoSeparation is zero as that variable is deprecated and should not be used anymore.
+    Cvar_Get("cg_stereoSeparation", "0", CVAR_ROM);
+
+    //
+    // register our commands
+    //
+    Cmd_AddCommand("cmd", CL_ForwardToServer_f);
+    Cmd_AddCommand("configstrings", CL_Configstrings_f);
+    Cmd_AddCommand("clientinfo", CL_Clientinfo_f);
+    Cmd_AddCommand("snd_restart", CL_Snd_Restart_f);
+    Cmd_AddCommand("vid_restart", CL_Vid_Restart_f);
+    Cmd_AddCommand("disconnect", CL_Disconnect_f);
+    Cmd_AddCommand("record", CL_Record_f);
+    Cmd_AddCommand("demo", CL_PlayDemo_f);
+    Cmd_SetCommandCompletionFunc("demo", CL_CompleteDemoName);
+    Cmd_AddCommand("cinematic", CL_PlayCinematic_f);
+    Cmd_AddCommand("stoprecord", CL_StopRecord_f);
+    Cmd_AddCommand("connect", CL_Connect_f);
+    Cmd_AddCommand("reconnect", CL_Reconnect_f);
+    Cmd_AddCommand("localservers", CL_LocalServers_f);
+    Cmd_AddCommand("globalservers", CL_GlobalServers_f);
+    Cmd_AddCommand("rcon", CL_Rcon_f);
+    Cmd_SetCommandCompletionFunc("rcon", CL_CompleteRcon);
+    Cmd_AddCommand("ping", CL_Ping_f);
+    Cmd_AddCommand("serverstatus", CL_ServerStatus_f);
+    Cmd_AddCommand("showip", CL_ShowIP_f);
+    Cmd_AddCommand("fs_openedList", CL_OpenedPK3List_f);
+    Cmd_AddCommand("fs_referencedList", CL_ReferencedPK3List_f);
+    Cmd_AddCommand("model", CL_SetModel_f);
+    Cmd_AddCommand("video", CL_Video_f);
+    Cmd_AddCommand("stopvideo", CL_StopVideo_f);
+    Cmd_AddCommand("downloadUpdate", CL_DownloadUpdate_f);
+    Cmd_AddCommand("installUpdate", CL_InstallUpdate_f);
+    Cmd_AddCommand("checkForUpdate", CL_CheckForUpdate_f);
+    Cmd_AddCommand("browseHomepath", CL_BrowseHomepath_f);
+    Cmd_AddCommand("browseDemos", CL_BrowseDemos_f);
+    Cmd_AddCommand("browseScreenShots", CL_BrowseScreenShots_f);
+
+    CL_InitRef();
+
+    SCR_Init();
+
+    //	Cbuf_Execute ();
+
+    Cvar_Set("cl_running", "1");
+
+    if (cl_rsaAuth->integer) CL_LoadRSAKeypair();
+
+    CL_GenerateQKey();
+    Cvar_Get("cl_guid", "", CVAR_USERINFO | CVAR_ROM);
+    if (clc.state == CA_DISCONNECTED) CL_UpdateGUID(NULL, 0);
+
+    Com_Printf("----- Client Initialization Complete -----\n");
+}
+
+/*
+===============
+CL_Shutdown
+
+===============
+*/
+void CL_Shutdown(const char *finalmsg, bool disconnect, bool quit)
+{
+    static bool recursive = false;
+    int realtime;
+
+    // check whether the client is running at all.
+    if (!(com_cl_running && com_cl_running->integer)) return;
+
+    Com_Printf("----- Client Shutdown (%s) -----\n", finalmsg);
+
+    if (recursive)
+    {
+        Com_Printf("WARNING: Recursive shutdown\n");
+        return;
+    }
+    recursive = true;
+
+    noGameRestart = quit;
+
+    if (disconnect) CL_Disconnect(true);
+
+    CL_ClearMemory(true);
+    CL_Snd_Shutdown();
+
+    Cmd_RemoveCommand("cmd");
+    Cmd_RemoveCommand("configstrings");
+    Cmd_RemoveCommand("clientinfo");
+    Cmd_RemoveCommand("snd_restart");
+    Cmd_RemoveCommand("vid_restart");
+    Cmd_RemoveCommand("disconnect");
+    Cmd_RemoveCommand("record");
+    Cmd_RemoveCommand("demo");
+    Cmd_RemoveCommand("cinematic");
+    Cmd_RemoveCommand("stoprecord");
+    Cmd_RemoveCommand("connect");
+    Cmd_RemoveCommand("reconnect");
+    Cmd_RemoveCommand("localservers");
+    Cmd_RemoveCommand("globalservers");
+    Cmd_RemoveCommand("rcon");
+    Cmd_RemoveCommand("ping");
+    Cmd_RemoveCommand("serverstatus");
+    Cmd_RemoveCommand("showip");
+    Cmd_RemoveCommand("fs_openedList");
+    Cmd_RemoveCommand("fs_referencedList");
+    Cmd_RemoveCommand("model");
+    Cmd_RemoveCommand("video");
+    Cmd_RemoveCommand("stopvideo");
+
+    CL_ShutdownInput();
+    Con_Shutdown();
+
+    Cvar_Set("cl_running", "0");
+
+    recursive = false;
+
+    if (cl_rsaAuth->integer) CL_UnloadRSAKeypair();
+
+    realtime = cls.realtime;
+    ::memset(&cls, 0, sizeof(cls));
+    cls.realtime = realtime;
+    Key_SetCatcher(0);
+
+    Com_Printf("-----------------------\n");
+}
diff --git a/src/client/cl_net_chan.cpp b/src/client/cl_net_chan.cpp
new file mode 100644
index 0000000..80ac25d
--- /dev/null
+++ b/src/client/cl_net_chan.cpp
@@ -0,0 +1,190 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include "client.h"
+
+#include "qcommon/q_shared.h"
+#include "qcommon/qcommon.h"
+
+/*
+==============
+CL_Netchan_Encode
+
+        // first 12 bytes of the data are always:
+        long serverId;
+        long messageAcknowledge;
+        long reliableAcknowledge;
+
+==============
+*/
+static void CL_Netchan_Encode(msg_t *msg)
+{
+    int serverId, messageAcknowledge, reliableAcknowledge;
+    int i, idx, srdc, sbit;
+    bool soob;
+    byte key, *string;
+
+    if (msg->cursize <= CL_ENCODE_START)
+    {
+        return;
+    }
+
+    srdc = msg->readcount;
+    sbit = msg->bit;
+    soob = msg->oob;
+
+    msg->bit = 0;
+    msg->readcount = 0;
+    msg->oob = false;
+
+    serverId = MSG_ReadLong(msg);
+    messageAcknowledge = MSG_ReadLong(msg);
+    reliableAcknowledge = MSG_ReadLong(msg);
+
+    msg->oob = soob;
+    msg->bit = sbit;
+    msg->readcount = srdc;
+
+    string = (byte *)clc.serverCommands[reliableAcknowledge & (MAX_RELIABLE_COMMANDS - 1)];
+    idx = 0;
+    //
+    key = clc.challenge ^ serverId ^ messageAcknowledge;
+    for (i = CL_ENCODE_START; i < msg->cursize; i++)
+    {
+        // modify the key with the last received now acknowledged server command
+        if (!string[idx]) idx = 0;
+        if (string[idx] > 127 || (string[idx] == '%' && clc.netchan.alternateProtocol == 2))
+        {
+            key ^= '.' << (i & 1);
+        }
+        else
+        {
+            key ^= string[idx] << (i & 1);
+        }
+        idx++;
+        // encode the data with this key
+        *(msg->data + i) = (*(msg->data + i)) ^ key;
+    }
+}
+
+/*
+==============
+CL_Netchan_Decode
+
+        // first four bytes of the data are always:
+        long reliableAcknowledge;
+
+==============
+*/
+static void CL_Netchan_Decode(msg_t *msg)
+{
+    long reliableAcknowledge, i, idx;
+    byte key, *string;
+    int srdc, sbit;
+    bool soob;
+
+    srdc = msg->readcount;
+    sbit = msg->bit;
+    soob = msg->oob;
+
+    msg->oob = false;
+
+    reliableAcknowledge = MSG_ReadLong(msg);
+
+    msg->oob = soob;
+    msg->bit = sbit;
+    msg->readcount = srdc;
+
+    string = (byte *)clc.reliableCommands[reliableAcknowledge & (MAX_RELIABLE_COMMANDS - 1)];
+    idx = 0;
+    // xor the client challenge with the netchan sequence number (need something that changes every message)
+    key = clc.challenge ^ LittleLong(*(unsigned *)msg->data);
+    for (i = msg->readcount + CL_DECODE_START; i < msg->cursize; i++)
+    {
+        // modify the key with the last sent and with this message acknowledged client command
+        if (!string[idx]) idx = 0;
+        if (string[idx] > 127 || (string[idx] == '%' && clc.netchan.alternateProtocol == 2))
+        {
+            key ^= '.' << (i & 1);
+        }
+        else
+        {
+            key ^= string[idx] << (i & 1);
+        }
+        idx++;
+        // decode the data with this key
+        *(msg->data + i) = *(msg->data + i) ^ key;
+    }
+}
+
+/*
+=================
+CL_Netchan_TransmitNextFragment
+=================
+*/
+static bool CL_Netchan_TransmitNextFragment(netchan_t *chan)
+{
+    if (chan->unsentFragments)
+    {
+        Netchan_TransmitNextFragment(chan);
+        return true;
+    }
+
+    return false;
+}
+
+/*
+===============
+CL_Netchan_Transmit
+================
+*/
+void CL_Netchan_Transmit(netchan_t *chan, msg_t *msg)
+{
+    MSG_WriteByte(msg, clc_EOF);
+
+    if (chan->alternateProtocol != 0) CL_Netchan_Encode(msg);
+    Netchan_Transmit(chan, msg->cursize, msg->data);
+
+    // Transmit all fragments without delay
+    while (CL_Netchan_TransmitNextFragment(chan))
+    {
+        Com_DPrintf("WARNING: #462 unsent fragments (not supposed to happen!)\n");
+    }
+}
+
+/*
+=================
+CL_Netchan_Process
+=================
+*/
+bool CL_Netchan_Process(netchan_t *chan, msg_t *msg)
+{
+    int ret;
+
+    ret = Netchan_Process(chan, msg);
+    if (!ret) return false;
+    if (chan->alternateProtocol != 0) CL_Netchan_Decode(msg);
+
+    return true;
+}
diff --git a/src/client/cl_parse.cpp b/src/client/cl_parse.cpp
new file mode 100644
index 0000000..111211a
--- /dev/null
+++ b/src/client/cl_parse.cpp
@@ -0,0 +1,961 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+// cl_parse.c  -- parse a message received from the server
+
+#include "client.h"
+
+const char *svc_strings[256] = {
+	"svc_bad",
+	"svc_nop",
+	"svc_gamestate",
+	"svc_configstring",
+	"svc_baseline",	
+	"svc_serverCommand",
+	"svc_download",
+	"svc_snapshot",
+	"svc_EOF",
+	"svc_voipSpeex",
+	"svc_voipOpus",
+};
+
+void SHOWNET( msg_t *msg, const char *s) {
+	if ( cl_shownet->integer >= 2) {
+		Com_Printf ("%3i:%s\n", msg->readcount-1, s);
+	}
+}
+
+
+/*
+=========================================================================
+
+MESSAGE PARSING
+
+=========================================================================
+*/
+
+/*
+==================
+CL_DeltaEntity
+
+Parses deltas from the given base and adds the resulting entity
+to the current frame
+==================
+*/
+static void CL_DeltaEntity(msg_t *msg, clSnapshot_t *frame, int newnum, entityState_t *old, bool unchanged)
+{
+	entityState_t	*state;
+
+    // save the parsed entity state into the big circular buffer so it can be
+    // used as the source for a later delta
+	state = &cl.parseEntities[cl.parseEntitiesNum & (MAX_PARSE_ENTITIES-1)];
+
+	if ( unchanged )
+    {
+		*state = *old;
+	}
+    else
+    {
+		MSG_ReadDeltaEntity( clc.netchan.alternateProtocol, msg, old, state, newnum );
+	}
+
+	if ( state->number == (MAX_GENTITIES-1) )
+    {
+		return;	// entity was delta removed
+	}
+
+	cl.parseEntitiesNum++;
+	frame->numEntities++;
+}
+
+/*
+==================
+CL_ParsePacketEntities
+
+==================
+*/
+static void CL_ParsePacketEntities( msg_t *msg, clSnapshot_t *oldframe, clSnapshot_t *newframe)
+{
+	int	newnum;
+	entityState_t *oldstate;
+	int	oldindex, oldnum;
+
+	newframe->parseEntitiesNum = cl.parseEntitiesNum;
+	newframe->numEntities = 0;
+
+	// delta from the entities present in oldframe
+	oldindex = 0;
+	oldstate = NULL;
+	if (!oldframe) {
+		oldnum = 99999;
+	} else {
+		if ( oldindex >= oldframe->numEntities ) {
+			oldnum = 99999;
+		} else {
+			oldstate = &cl.parseEntities[
+				(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+			oldnum = oldstate->number;
+		}
+	}
+
+	while ( 1 ) {
+		// read the entity index number
+		newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
+
+		if ( newnum == (MAX_GENTITIES-1) ) {
+			break;
+		}
+
+		if ( msg->readcount > msg->cursize ) {
+			Com_Error (ERR_DROP,"CL_ParsePacketEntities: end of message");
+		}
+
+		while ( oldnum < newnum ) {
+			// one or more entities from the old packet are unchanged
+			if ( cl_shownet->integer == 3 ) {
+				Com_Printf ("%3i:  unchanged: %i\n", msg->readcount, oldnum);
+			}
+			CL_DeltaEntity( msg, newframe, oldnum, oldstate, true );
+			
+			oldindex++;
+
+			if ( oldindex >= oldframe->numEntities ) {
+				oldnum = 99999;
+			} else {
+				oldstate = &cl.parseEntities[
+					(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+				oldnum = oldstate->number;
+			}
+		}
+		if (oldnum == newnum) {
+			// delta from previous state
+			if ( cl_shownet->integer == 3 ) {
+				Com_Printf ("%3i:  delta: %i\n", msg->readcount, newnum);
+			}
+			CL_DeltaEntity( msg, newframe, newnum, oldstate, false );
+
+			oldindex++;
+
+			if ( oldindex >= oldframe->numEntities ) {
+				oldnum = 99999;
+			} else {
+				oldstate = &cl.parseEntities[
+					(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+				oldnum = oldstate->number;
+			}
+			continue;
+		}
+
+		if ( oldnum > newnum ) {
+			// delta from baseline
+			if ( cl_shownet->integer == 3 ) {
+				Com_Printf ("%3i:  baseline: %i\n", msg->readcount, newnum);
+			}
+			CL_DeltaEntity( msg, newframe, newnum, &cl.entityBaselines[newnum], false );
+			continue;
+		}
+
+	}
+
+	// any remaining entities in the old frame are copied over
+	while ( oldnum != 99999 ) {
+		// one or more entities from the old packet are unchanged
+		if ( cl_shownet->integer == 3 ) {
+			Com_Printf ("%3i:  unchanged: %i\n", msg->readcount, oldnum);
+		}
+		CL_DeltaEntity( msg, newframe, oldnum, oldstate, true );
+		
+		oldindex++;
+
+		if ( oldindex >= oldframe->numEntities ) {
+			oldnum = 99999;
+		} else {
+			oldstate = &cl.parseEntities[
+				(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+			oldnum = oldstate->number;
+		}
+	}
+}
+
+
+/*
+================
+CL_ParseSnapshot
+
+If the snapshot is parsed properly, it will be copied to
+cl.snap and saved in cl.snapshots[].  If the snapshot is invalid
+for any reason, no changes to the state will be made at all.
+================
+*/
+void CL_ParseSnapshot( msg_t *msg ) {
+	int			len;
+	clSnapshot_t	*old;
+	clSnapshot_t	newSnap;
+	int			deltaNum;
+	int			oldMessageNum;
+	int			i, packetNum;
+
+	// get the reliable sequence acknowledge number
+	// NOTE: now sent with all server to client messages
+	//clc.reliableAcknowledge = MSG_ReadLong( msg );
+
+	// read in the new snapshot to a temporary buffer
+	// we will only copy to cl.snap if it is valid
+	::memset(&newSnap, 0, sizeof(newSnap));
+
+	// we will have read any new server commands in this
+	// message before we got to svc_snapshot
+	newSnap.serverCommandNum = clc.serverCommandSequence;
+
+	newSnap.serverTime = MSG_ReadLong( msg );
+
+	// if we were just unpaused, we can only *now* really let the
+	// change come into effect or the client hangs.
+	cl_paused->modified = false;
+
+	newSnap.messageNum = clc.serverMessageSequence;
+
+	deltaNum = MSG_ReadByte( msg );
+	if ( !deltaNum ) {
+		newSnap.deltaNum = -1;
+	} else {
+		newSnap.deltaNum = newSnap.messageNum - deltaNum;
+	}
+	newSnap.snapFlags = MSG_ReadByte( msg );
+
+	// If the frame is delta compressed from data that we
+	// no longer have available, we must suck up the rest of
+	// the frame, but not use it, then ask for a non-compressed
+	// message 
+	if ( newSnap.deltaNum <= 0 ) {
+		newSnap.valid = true;		// uncompressed frame
+		old = NULL;
+		clc.demowaiting = false;	// we can start recording now
+	} else {
+		old = &cl.snapshots[newSnap.deltaNum & PACKET_MASK];
+		if ( !old->valid ) {
+			// should never happen
+			Com_DPrintf ("Delta from invalid frame (not supposed to happen!).\n");
+		} else if ( old->messageNum != newSnap.deltaNum ) {
+			// The frame that the server did the delta from
+			// is too old, so we can't reconstruct it properly.
+			Com_DPrintf ("Delta frame too old.\n");
+		} else if ( cl.parseEntitiesNum - old->parseEntitiesNum > MAX_PARSE_ENTITIES - MAX_SNAPSHOT_ENTITIES ) {
+			Com_DPrintf ("Delta parseEntitiesNum too old.\n");
+		} else {
+			newSnap.valid = true;	// valid delta parse
+		}
+	}
+
+	// read areamask
+	len = MSG_ReadByte( msg );
+	
+	if(len > sizeof(newSnap.areamask))
+	{
+		Com_Error (ERR_DROP,"CL_ParseSnapshot: Invalid size %d for areamask", len);
+		return;
+	}
+	
+	MSG_ReadData( msg, &newSnap.areamask, len);
+
+	// read playerinfo
+	SHOWNET( msg, "playerstate" );
+	if ( clc.netchan.alternateProtocol == 2 ) {
+		if ( old ) {
+			MSG_ReadDeltaAlternatePlayerstate( msg, &old->alternatePs, &newSnap.alternatePs );
+		} else {
+			MSG_ReadDeltaAlternatePlayerstate( msg, NULL, &newSnap.alternatePs );
+		}
+	} else {
+		if ( old ) {
+			MSG_ReadDeltaPlayerstate( msg, &old->ps, &newSnap.ps );
+		} else {
+			MSG_ReadDeltaPlayerstate( msg, NULL, &newSnap.ps );
+		}
+	}
+
+	// read packet entities
+	SHOWNET( msg, "packet entities" );
+	CL_ParsePacketEntities( msg, old, &newSnap );
+
+	// if not valid, dump the entire thing now that it has
+	// been properly read
+	if ( !newSnap.valid ) {
+		return;
+	}
+
+	// clear the valid flags of any snapshots between the last
+	// received and this one, so if there was a dropped packet
+	// it won't look like something valid to delta from next
+	// time we wrap around in the buffer
+	oldMessageNum = cl.snap.messageNum + 1;
+
+	if ( newSnap.messageNum - oldMessageNum >= PACKET_BACKUP ) {
+		oldMessageNum = newSnap.messageNum - ( PACKET_BACKUP - 1 );
+	}
+	for ( ; oldMessageNum < newSnap.messageNum ; oldMessageNum++ ) {
+		cl.snapshots[oldMessageNum & PACKET_MASK].valid = false;
+	}
+
+	// copy to the current good spot
+	cl.snap = newSnap;
+	cl.snap.ping = 999;
+	// calculate ping time
+	for ( i = 0 ; i < PACKET_BACKUP ; i++ ) {
+		packetNum = ( clc.netchan.outgoingSequence - 1 - i ) & PACKET_MASK;
+		if ( ( clc.netchan.alternateProtocol == 2 ? cl.snap.alternatePs.commandTime : cl.snap.ps.commandTime ) >= cl.outPackets[ packetNum ].p_serverTime ) {
+			cl.snap.ping = cls.realtime - cl.outPackets[ packetNum ].p_realtime;
+			break;
+		}
+	}
+	// save the frame off in the backup array for later delta comparisons
+	cl.snapshots[cl.snap.messageNum & PACKET_MASK] = cl.snap;
+
+	if (cl_shownet->integer == 3) {
+		Com_Printf( "   snapshot:%i  delta:%i  ping:%i\n", cl.snap.messageNum,
+		cl.snap.deltaNum, cl.snap.ping );
+	}
+
+	cl.newSnapshots = true;
+}
+
+
+//=====================================================================
+
+bool cl_connectedToPureServer;
+bool cl_connectedToCheatServer;
+
+/*
+==================
+CL_SystemInfoChanged
+
+The systeminfo configstring has been changed, so parse
+new information out of it.  This will happen at every
+gamestate, and possibly during gameplay.
+==================
+*/
+void CL_SystemInfoChanged( void ) {
+	char			*systemInfo;
+	const char		*s, *t;
+	char			key[BIG_INFO_KEY];
+	char			value[BIG_INFO_VALUE];
+	bool		    gameSet;
+
+	systemInfo = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SYSTEMINFO ];
+	// NOTE TTimo:
+	// when the serverId changes, any further messages we send to the server will use this new serverId
+	// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=475
+	// in some cases, outdated cp commands might get sent with this news serverId
+	cl.serverId = atoi( Info_ValueForKey( systemInfo, "sv_serverid" ) );
+
+#ifdef USE_VOIP
+	s = Info_ValueForKey( systemInfo, "sv_voipProtocol" );
+	clc.voipEnabled = !Q_stricmp(s, "opus");
+#endif
+
+	// only set the paks, fs_game, and sv_pure when playing a demo
+	if ( !clc.demoplaying ) {
+		s = Info_ValueForKey( systemInfo, "sv_cheats" );
+		cl_connectedToCheatServer = (bool)atoi( s );
+		if ( !cl_connectedToCheatServer ) {
+			Cvar_SetCheatState();
+		}
+	}
+
+	// check pure server string
+	s = Info_ValueForKey( systemInfo, "sv_paks" );
+	t = Info_ValueForKey( systemInfo, "sv_pakNames" );
+	FS_PureServerSetLoadedPaks( s, t );
+
+	s = Info_ValueForKey( systemInfo, "sv_referencedPaks" );
+	t = Info_ValueForKey( systemInfo, "sv_referencedPakNames" );
+	FS_PureServerSetReferencedPaks( s, t );
+
+	gameSet = false;
+	// scan through all the variables in the systeminfo and locally set cvars to match
+	s = systemInfo;
+	while ( s ) {
+		int cvar_flags;
+		
+		Info_NextPair( &s, key, value );
+		if ( !key[0] ) {
+			break;
+		}
+		
+		// ehw!
+		if (!Q_stricmp(key, "fs_game"))
+		{
+			if(FS_CheckDirTraversal(value))
+			{
+				Com_Printf(S_COLOR_YELLOW "WARNING: Server sent invalid fs_game value %s\n", value);
+				continue;
+			}
+				
+			gameSet = true;
+		} else if ( clc.demoplaying && Q_stricmp(key, "sv_pure" ) ) {
+			continue;
+		}
+
+		if((cvar_flags = Cvar_Flags(key)) == CVAR_NONEXISTENT)
+			Cvar_Get(key, value, CVAR_SERVER_CREATED | CVAR_ROM);
+		else
+		{
+			// If this cvar may not be modified by a server discard the value.
+			if(!(cvar_flags & (CVAR_SYSTEMINFO | CVAR_SERVER_CREATED | CVAR_USER_CREATED)))
+			{
+				if(Q_stricmp(key, "g_synchronousClients") && Q_stricmp(key, "pmove_fixed") &&
+				   Q_stricmp(key, "pmove_msec"))
+				{
+					Com_Printf(S_COLOR_YELLOW "WARNING: server is not allowed to set %s=%s\n", key, value);
+					continue;
+				}
+			}
+
+			Cvar_SetSafe(key, value);
+		}
+	}
+	// if game folder should not be set and it is set at the client side
+	if ( !gameSet && *Cvar_VariableString("fs_game") ) {
+		Cvar_Set( "fs_game", "" );
+	}
+	cl_connectedToPureServer = (bool)Cvar_VariableValue( "sv_pure" );
+}
+
+/*
+==================
+CL_ParseServerInfo
+==================
+*/
+static void CL_ParseServerInfo(void)
+{
+	const char *serverInfo;
+
+	serverInfo = cl.gameState.stringData
+		+ cl.gameState.stringOffsets[ CS_SERVERINFO ];
+
+	clc.sv_allowDownload = atoi(Info_ValueForKey(serverInfo,
+		"sv_allowDownload"));
+	Q_strncpyz(clc.sv_dlURL,
+		Info_ValueForKey(serverInfo, "sv_dlURL"),
+		sizeof(clc.sv_dlURL));
+}
+
+/*
+==================
+CL_ParseGamestate
+==================
+*/
+void CL_ParseGamestate( msg_t *msg ) {
+	int				i;
+	entityState_t	*es;
+	int				newnum;
+	entityState_t	nullstate;
+	int				cmd;
+	char			*s;
+	char oldGame[MAX_QPATH];
+
+	clc.connectPacketCount = 0;
+
+	// wipe local client state
+	CL_ClearState();
+
+	// a gamestate always marks a server command sequence
+	clc.serverCommandSequence = MSG_ReadLong( msg );
+
+	// parse all the configstrings and baselines
+	cl.gameState.dataCount = 1;	// leave a 0 at the beginning for uninitialized configstrings
+	while ( 1 ) {
+		cmd = MSG_ReadByte( msg );
+
+		if ( cmd == svc_EOF ) {
+			break;
+		}
+		
+		if ( cmd == svc_configstring ) {
+			int		len;
+
+			i = MSG_ReadShort( msg );
+			if ( i < 0 || i >= MAX_CONFIGSTRINGS ) {
+				Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
+			}
+			s = MSG_ReadBigString( msg );
+			len = strlen( s );
+
+			if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
+				Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
+			}
+
+			// append it to the gameState string buffer
+			cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
+			::memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
+			cl.gameState.dataCount += len + 1;
+		} else if ( cmd == svc_baseline ) {
+			newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
+			if ( newnum < 0 || newnum >= MAX_GENTITIES ) {
+				Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
+			}
+			::memset(&nullstate, 0, sizeof(nullstate));
+			es = &cl.entityBaselines[ newnum ];
+			MSG_ReadDeltaEntity( clc.netchan.alternateProtocol, msg, &nullstate, es, newnum );
+		} else {
+			Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
+		}
+	}
+
+	clc.clientNum = MSG_ReadLong(msg);
+	// read the checksum feed
+	clc.checksumFeed = MSG_ReadLong( msg );
+
+	// save old gamedir
+	Cvar_VariableStringBuffer("fs_game", oldGame, sizeof(oldGame));
+
+	// parse useful values out of CS_SERVERINFO
+	CL_ParseServerInfo();
+
+	// parse serverId and other cvars
+	CL_SystemInfoChanged();
+
+	// stop recording now so the demo won't have an unnecessary level load at the end.
+	if(cl_autoRecordDemo->integer && clc.demorecording)
+		CL_StopRecord_f();
+	
+	// reinitialize the filesystem if the game directory has changed
+	if(!cl_oldGameSet && (Cvar_Flags("fs_game") & CVAR_MODIFIED))
+	{
+		cl_oldGameSet = true;
+		Q_strncpyz(cl_oldGame, oldGame, sizeof(cl_oldGame));
+	}
+
+	FS_ConditionalRestart(clc.checksumFeed, false);
+
+	// This used to call CL_StartHunkUsers, but now we enter the download state before loading the
+	// cgame
+	CL_InitDownloads();
+
+	// make sure the game starts
+	Cvar_Set( "cl_paused", "0" );
+}
+
+
+//=====================================================================
+
+/*
+=====================
+CL_ParseDownload
+
+A download message has been received from the server
+=====================
+*/
+void CL_ParseDownload ( msg_t *msg ) {
+	int		size;
+	unsigned char data[MAX_MSGLEN];
+	uint16_t block;
+
+	if (!*clc.downloadTempName) {
+		Com_Printf("Server sending download, but no download was requested\n");
+		CL_AddReliableCommand("stopdl", false);
+		return;
+	}
+
+	// read the data
+	block = MSG_ReadShort ( msg );
+
+	if(!block && !clc.downloadBlock)
+	{
+		// block zero is special, contains file size
+		clc.downloadSize = MSG_ReadLong ( msg );
+
+		Cvar_SetValue( "cl_downloadSize", clc.downloadSize );
+
+		if (clc.downloadSize < 0)
+		{
+			Com_Error( ERR_DROP, "%s", MSG_ReadString( msg ) );
+			return;
+		}
+	}
+
+	size = MSG_ReadShort ( msg );
+	if (size < 0 || size > sizeof(data))
+	{
+		Com_Error(ERR_DROP, "CL_ParseDownload: Invalid size %d for download chunk", size);
+		return;
+	}
+	
+	MSG_ReadData(msg, data, size);
+
+	if((clc.downloadBlock & 0xFFFF) != block)
+	{
+		Com_DPrintf( "CL_ParseDownload: Expected block %d, got %d\n", (clc.downloadBlock & 0xFFFF), block);
+		return;
+	}
+
+	// open the file if not opened yet
+	if (!clc.download)
+	{
+		clc.download = FS_SV_FOpenFileWrite( clc.downloadTempName );
+
+		if (!clc.download) {
+			Com_Printf( "Could not create %s\n", clc.downloadTempName );
+			CL_AddReliableCommand("stopdl", false);
+			CL_NextDownload();
+			return;
+		}
+	}
+
+	if (size)
+		FS_Write( data, size, clc.download );
+
+	CL_AddReliableCommand(va("nextdl %d", clc.downloadBlock), false);
+	clc.downloadBlock++;
+
+	clc.downloadCount += size;
+
+	// So UI gets access to it
+	Cvar_SetValue( "cl_downloadCount", clc.downloadCount );
+
+	if (!size) { // A zero length block means EOF
+		if (clc.download) {
+			FS_FCloseFile( clc.download );
+			clc.download = 0;
+
+			// rename the file
+			FS_SV_Rename( clc.downloadTempName, clc.downloadName, false );
+		}
+
+		// send intentions now
+		// We need this because without it, we would hold the last nextdl and then start
+		// loading right away.  If we take a while to load, the server is happily trying
+		// to send us that last block over and over.
+		// Write it twice to help make sure we acknowledge the download
+		CL_WritePacket();
+		CL_WritePacket();
+
+		// get another file if needed
+		CL_NextDownload ();
+	}
+}
+
+#ifdef USE_VOIP
+static bool CL_ShouldIgnoreVoipSender(int sender)
+{
+	if (!cl_voip->integer)
+		return true;  // VoIP is disabled.
+	else if ((sender == clc.clientNum) && (!clc.demoplaying))
+		return true;  // ignore own voice (unless playing back a demo).
+	else if (clc.voipMuteAll)
+		return true;  // all channels are muted with extreme prejudice.
+	else if (clc.voipIgnore[sender])
+		return true;  // just ignoring this guy.
+	else if (clc.voipGain[sender] == 0.0f)
+		return true;  // too quiet to play.
+
+	return false;
+}
+
+/*
+=====================
+CL_PlayVoip
+
+Play raw data
+=====================
+*/
+
+static void CL_PlayVoip(int sender, int samplecnt, const byte *data, int flags)
+{
+	if(flags & VOIP_DIRECT)
+	{
+		S_RawSamples(sender + 1, samplecnt, 48000, 2, 1, data, clc.voipGain[sender], -1);
+	}
+
+	if(flags & VOIP_SPATIAL)
+	{
+		S_RawSamples(sender + MAX_CLIENTS + 1, samplecnt, 48000, 2, 1, data, 1.0f, sender);
+	}
+}
+
+/*
+=====================
+CL_ParseVoip
+
+A VoIP message has been received from the server
+=====================
+*/
+static void CL_ParseVoip( msg_t *msg, bool ignoreData )
+{
+	static short decoded[VOIP_MAX_PACKET_SAMPLES*4]; // !!! FIXME: don't hard code
+
+	const int sender = MSG_ReadShort(msg);
+	const int generation = MSG_ReadByte(msg);
+	const int sequence = MSG_ReadLong(msg);
+	const int frames = MSG_ReadByte(msg);
+	const int packetsize = MSG_ReadShort(msg);
+	int flags = VOIP_DIRECT;
+	if (clc.netchan.alternateProtocol == 0)
+		flags = MSG_ReadBits(msg, VOIP_FLAGCNT);
+	char encoded[4000];
+	int	numSamples;
+	int seqdiff;
+	int written = 0;
+	int i;
+
+	Com_DPrintf("VoIP: %d-byte packet from client %d\n", packetsize, sender);
+
+	if (sender < 0)
+		return;   // short/invalid packet, bail.
+	else if (generation < 0)
+		return;   // short/invalid packet, bail.
+	else if (sequence < 0)
+		return;   // short/invalid packet, bail.
+	else if (frames < 0)
+		return;   // short/invalid packet, bail.
+	else if (packetsize < 0)
+		return;   // short/invalid packet, bail.
+
+	if (packetsize > sizeof (encoded)) {  // overlarge packet?
+		int bytesleft = packetsize;
+		while (bytesleft) {
+			int br = bytesleft;
+			if (br > sizeof (encoded))
+				br = sizeof (encoded);
+			MSG_ReadData(msg, encoded, br);
+			bytesleft -= br;
+		}
+		return;   // overlarge packet, bail.
+	}
+
+	MSG_ReadData(msg, encoded, packetsize);
+
+	if (ignoreData) {
+		return; // just ignore legacy speex voip data
+	} else if (!clc.voipCodecInitialized) {
+		return;   // can't handle VoIP without libopus!
+	} else if (sender >= MAX_CLIENTS) {
+		return;   // bogus sender.
+	} else if (CL_ShouldIgnoreVoipSender(sender)) {
+		return;   // Channel is muted, bail.
+	}
+
+	// !!! FIXME: make sure data is narrowband? Does decoder handle this?
+
+	Com_DPrintf("VoIP: packet accepted!\n");
+
+	seqdiff = sequence - clc.voipIncomingSequence[sender];
+
+	// This is a new "generation" ... a new recording started, reset the bits.
+	if (generation != clc.voipIncomingGeneration[sender]) {
+		Com_DPrintf("VoIP: new generation %d!\n", generation);
+		opus_decoder_ctl(clc.opusDecoder[sender], OPUS_RESET_STATE);
+		clc.voipIncomingGeneration[sender] = generation;
+		seqdiff = 0;
+	} else if (seqdiff < 0) {   // we're ahead of the sequence?!
+		// This shouldn't happen unless the packet is corrupted or something.
+		Com_DPrintf("VoIP: misordered sequence! %d < %d!\n",
+		            sequence, clc.voipIncomingSequence[sender]);
+		// reset the decoder just in case.
+		opus_decoder_ctl(clc.opusDecoder[sender], OPUS_RESET_STATE);
+		seqdiff = 0;
+	} else if (seqdiff * VOIP_MAX_PACKET_SAMPLES*2 >= sizeof (decoded)) { // dropped more than we can handle?
+		// just start over.
+		Com_DPrintf("VoIP: Dropped way too many (%d) frames from client #%d\n",
+		            seqdiff, sender);
+		opus_decoder_ctl(clc.opusDecoder[sender], OPUS_RESET_STATE);
+		seqdiff = 0;
+	}
+
+	if (seqdiff != 0) {
+		Com_DPrintf("VoIP: Dropped %d frames from client #%d\n",
+		            seqdiff, sender);
+		// tell opus that we're missing frames...
+		for (i = 0; i < seqdiff; i++) {
+			assert((written + VOIP_MAX_PACKET_SAMPLES) * 2 < sizeof (decoded));
+			numSamples = opus_decode(clc.opusDecoder[sender], NULL, 0, decoded + written, VOIP_MAX_PACKET_SAMPLES, 0);
+			if ( numSamples <= 0 ) {
+				Com_DPrintf("VoIP: Error decoding frame %d from client #%d\n", i, sender);
+				continue;
+			}
+			written += numSamples;
+		}
+	}
+
+	numSamples = opus_decode(clc.opusDecoder[sender],
+            (const unsigned char*)encoded,
+            packetsize,
+            decoded + written,
+            ARRAY_LEN(decoded) - written,
+            0);
+
+	if ( numSamples <= 0 ) {
+		Com_DPrintf("VoIP: Error decoding voip data from client #%d\n", sender);
+		numSamples = 0;
+	}
+
+	#if 0
+	static FILE *encio = NULL;
+	if (encio == NULL) encio = fopen("voip-incoming-encoded.bin", "wb");
+	if (encio != NULL) { fwrite(encoded, len, 1, encio); fflush(encio); }
+	static FILE *decio = NULL;
+	if (decio == NULL) decio = fopen("voip-incoming-decoded.bin", "wb");
+	if (decio != NULL) { fwrite(decoded+written, clc.speexFrameSize*2, 1, decio); fflush(decio); }
+	#endif
+
+	written += numSamples;
+
+	Com_DPrintf("VoIP: playback %d bytes, %d samples, %d frames\n",
+	            written * 2, written, frames);
+
+	if(written > 0)
+		CL_PlayVoip(sender, written, (const byte *) decoded, flags);
+
+	clc.voipIncomingSequence[sender] = sequence + frames;
+}
+#endif
+
+
+/*
+=====================
+CL_ParseCommandString
+
+Command strings are just saved off until cgame asks for them
+when it transitions a snapshot
+=====================
+*/
+void CL_ParseCommandString( msg_t *msg ) {
+	char	*s;
+	int		seq;
+	int		index;
+
+	seq = MSG_ReadLong( msg );
+	s = MSG_ReadString( msg );
+
+	// see if we have already executed stored it off
+	if ( clc.serverCommandSequence >= seq ) {
+		return;
+	}
+	clc.serverCommandSequence = seq;
+
+	index = seq & (MAX_RELIABLE_COMMANDS-1);
+	Q_strncpyz( clc.serverCommands[ index ], s, sizeof( clc.serverCommands[ index ] ) );
+}
+
+
+/*
+=====================
+CL_ParseServerMessage
+=====================
+*/
+void CL_ParseServerMessage( msg_t *msg ) {
+	int			cmd;
+
+	if ( cl_shownet->integer == 1 ) {
+		Com_Printf ("%i ",msg->cursize);
+	} else if ( cl_shownet->integer >= 2 ) {
+		Com_Printf ("------------------\n");
+	}
+
+	MSG_Bitstream(msg);
+
+	// get the reliable sequence acknowledge number
+	clc.reliableAcknowledge = MSG_ReadLong( msg );
+	// 
+	if ( clc.reliableAcknowledge < clc.reliableSequence - MAX_RELIABLE_COMMANDS ) {
+		clc.reliableAcknowledge = clc.reliableSequence;
+	}
+
+	//
+	// parse the message
+	//
+	while ( 1 ) {
+		if ( msg->readcount > msg->cursize ) {
+			Com_Error (ERR_DROP,"CL_ParseServerMessage: read past end of server message");
+			break;
+		}
+
+		cmd = MSG_ReadByte( msg );
+
+		if ( clc.netchan.alternateProtocol != 0 )
+		{
+			// See if this is an extension command after the EOF, which means we
+			//  got data that a legacy client should ignore.
+			if ( cmd == svc_EOF && MSG_LookaheadByte( msg ) == svc_voipSpeex ) {
+				SHOWNET( msg, "EXTENSION" );
+				MSG_ReadByte( msg );  // throw the svc_extension byte away.
+				cmd = MSG_ReadByte( msg );  // something legacy clients can't do!
+				// sometimes you get a svc_extension at end of stream...dangling
+				//  bits in the huffman decoder giving a bogus value?
+				if ( cmd == -1 ) {
+					cmd = svc_EOF;
+				}
+			}
+
+			if ( cmd == svc_voipSpeex ) {
+				cmd = svc_voipSpeex + 1;
+			} else if ( cmd == svc_voipSpeex + 1 ) {
+				cmd = svc_voipSpeex;
+			}
+		}
+
+		if (cmd == svc_EOF) {
+			SHOWNET( msg, "END OF MESSAGE" );
+			break;
+		}
+
+		if ( cl_shownet->integer >= 2 ) {
+			if ( (cmd < 0) || (!svc_strings[cmd]) ) {
+				Com_Printf( "%3i:BAD CMD %i\n", msg->readcount-1, cmd );
+			} else {
+				SHOWNET( msg, svc_strings[cmd] );
+			}
+		}
+	
+	// other commands
+		switch ( cmd ) {
+		default:
+			Com_Error (ERR_DROP,"CL_ParseServerMessage: Illegible server message");
+			break;			
+		case svc_nop:
+			break;
+		case svc_serverCommand:
+			CL_ParseCommandString( msg );
+			break;
+		case svc_gamestate:
+			CL_ParseGamestate( msg );
+			break;
+		case svc_snapshot:
+			CL_ParseSnapshot( msg );
+			break;
+		case svc_download:
+			CL_ParseDownload( msg );
+			break;
+		case svc_voipSpeex:
+#ifdef USE_VOIP
+			CL_ParseVoip( msg, true );
+#endif
+			break;
+		case svc_voipOpus:
+#ifdef USE_VOIP
+			CL_ParseVoip( msg, !clc.voipEnabled );
+#endif
+			break;
+		}
+	}
+}
diff --git a/src/client/cl_rest.cpp b/src/client/cl_rest.cpp
new file mode 100644
index 0000000..c1ff2fc
--- /dev/null
+++ b/src/client/cl_rest.cpp
@@ -0,0 +1,117 @@
+//
+// Restclient wrapper abusively modified to be a one-off donwloader.
+// -wtfbbqhax
+//
+// TODO Verify sha256 of file if exists
+
+#include "cl_rest.h"
+
+#include <unistd.h>
+
+#include <cerrno>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#include "qcommon/files.h"
+#include "restclient/restclient.h"
+
+bool is_good(std::string filename, int permissions = (R_OK|W_OK))
+{
+    int ret = access(filename.c_str(), permissions);
+    if (ret)
+        std::cerr << filename << ": " << strerror(errno) << std::endl;
+
+    return !ret;
+}
+
+bool MakeDir(std::string destdir, std::string basegame)
+{
+    std::string destpath(destdir);
+
+    if ( basegame != "" )
+    {
+        destpath += '/';
+        destpath += basegame;
+    }
+
+    if ( *destpath.rbegin() != '/' )
+        destpath += '/'; // XXX FS_CreatePath requires a trailing slash. 
+        // Maybe the assumption is that a file listing might be included?
+
+    FS_CreatePath(destpath.c_str());
+    return true;
+}
+
+#include "sys/dialog.h"
+static bool PromptDownloadPk3s(std::string basegame, const std::vector<std::string>& missing)
+{
+    std::string msg;
+        
+    msg = "The following files must be downloaded to complete the installation.\n\n";
+    for ( auto f : missing )
+        msg += "\t" + basegame + "/" + f + "\n";
+
+    msg += "\n";
+    msg += "Yes to continue, No to quit the game.";
+
+    if( Sys_Dialog( DT_YES_NO, msg.c_str(), "You're almost ready!" ) == DR_YES )
+        return true;
+
+    return false;
+}
+
+bool GetTremulousPk3s(const char* destdir, const char* basegame)
+{
+    std::string baseuri = "https://github.com/wtfbbqhax/tremulous-data/raw/master/";
+    std::vector<std::string> files = { 
+        "data-gpp1.pk3",
+        "data-1.1.0.pk3",
+        "map-arachnid2-1.1.0.pk3",
+        "map-atcs-1.1.0.pk3",
+        "map-karith-1.1.0.pk3",
+        "map-nexus6-1.1.0.pk3",
+        "map-niveus-1.1.0.pk3",
+        "map-transit-1.1.0.pk3",
+        "map-tremor-1.1.0.pk3",
+        "map-uncreation-1.1.0.pk3"
+    };
+
+    RestClient::init();
+
+    MakeDir(destdir, basegame);
+
+    if (!PromptDownloadPk3s(basegame, files))
+        return false;
+
+    for (auto f : files )
+    {
+        std::string destpath(destdir);
+        destpath += "/";
+        destpath += basegame;
+        destpath += "/";
+        destpath += f;
+
+        if ( is_good(destpath) )
+        {
+            return false;
+        }
+
+        std::cout << "Downloading " << baseuri << f << std::endl;
+        std::ofstream dl(destpath);
+        //dl.open(destpath);
+        if ( dl.fail() )
+        {
+            std::cerr << "Error " << strerror(errno) << "\n";
+            continue;
+        }
+
+        RestClient::Response resp = RestClient::get(baseuri + f);
+
+        dl << resp.body;
+        dl.close();
+    }
+
+    return true;
+}
diff --git a/src/client/cl_rest.h b/src/client/cl_rest.h
new file mode 100644
index 0000000..afde7d2
--- /dev/null
+++ b/src/client/cl_rest.h
@@ -0,0 +1,18 @@
+#ifndef _CL_REST_H_
+#define _CL_REST_H_
+
+bool    GetPermissions(const char*execpath);
+
+// Download a fresh copy of the "required" base game files to the top-most fs_basegame.
+//
+// Returns true(1) on success
+// Return false(0) on error
+//
+bool    GetTremulousPk3s(const char* destdir, const char* basegame);
+
+#include <string>
+
+//bool is_good(std::string filename, int permissions = (R_OK|W_OK));
+bool MakeDir(std::string destdir, std::string basegame);
+
+#endif
diff --git a/src/client/cl_scrn.cpp b/src/client/cl_scrn.cpp
new file mode 100644
index 0000000..7d0c7e2
--- /dev/null
+++ b/src/client/cl_scrn.cpp
@@ -0,0 +1,588 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+// cl_scrn.c -- master for refresh, status bar, console, chat, notify, etc
+
+#include "client.h"
+
+bool scr_initialized;  // ready to draw
+
+cvar_t *cl_timegraph;
+cvar_t *cl_debuggraph;
+cvar_t *cl_graphheight;
+cvar_t *cl_graphscale;
+cvar_t *cl_graphshift;
+
+/*
+================
+SCR_DrawNamedPic
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawNamedPic(float x, float y, float width, float height, const char *picname)
+{
+    qhandle_t hShader;
+
+    assert(width != 0);
+
+    hShader = re.RegisterShader(picname);
+    SCR_AdjustFrom640(&x, &y, &width, &height);
+    re.DrawStretchPic(x, y, width, height, 0, 0, 1, 1, hShader);
+}
+
+/*
+================
+SCR_AdjustFrom640
+
+Adjusted for resolution and screen aspect ratio
+================
+*/
+void SCR_AdjustFrom640(float *x, float *y, float *w, float *h)
+{
+    float xscale;
+    float yscale;
+
+#if 0
+		// adjust for wide screens
+		if ( cls.glconfig.vidWidth * 480 > cls.glconfig.vidHeight * 640 ) {
+			*x += 0.5 * ( cls.glconfig.vidWidth - ( cls.glconfig.vidHeight * 640 / 480 ) );
+		}
+#endif
+
+    // scale for screen sizes
+    xscale = cls.glconfig.vidWidth / 640.0;
+    yscale = cls.glconfig.vidHeight / 480.0;
+    if (x)
+    {
+        *x *= xscale;
+    }
+    if (y)
+    {
+        *y *= yscale;
+    }
+    if (w)
+    {
+        *w *= xscale;
+    }
+    if (h)
+    {
+        *h *= yscale;
+    }
+}
+
+/*
+================
+SCR_FillRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_FillRect(float x, float y, float width, float height, const float *color)
+{
+    re.SetColor(color);
+
+    SCR_AdjustFrom640(&x, &y, &width, &height);
+    re.DrawStretchPic(x, y, width, height, 0, 0, 0, 0, cls.whiteShader);
+
+    re.SetColor(NULL);
+}
+
+/*
+================
+SCR_DrawPic
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawPic(float x, float y, float width, float height, qhandle_t hShader)
+{
+    SCR_AdjustFrom640(&x, &y, &width, &height);
+    re.DrawStretchPic(x, y, width, height, 0, 0, 1, 1, hShader);
+}
+
+/*
+** SCR_DrawChar
+** chars are drawn at 640*480 virtual screen size
+*/
+static void SCR_DrawChar(int x, int y, float size, int ch)
+{
+    int row, col;
+    float frow, fcol;
+    float ax, ay, aw, ah;
+
+    ch &= 255;
+
+    if (ch == ' ')
+    {
+        return;
+    }
+
+    if (y < -size)
+    {
+        return;
+    }
+
+    ax = x;
+    ay = y;
+    aw = size;
+    ah = size;
+    SCR_AdjustFrom640(&ax, &ay, &aw, &ah);
+
+    row = ch >> 4;
+    col = ch & 15;
+
+    frow = row * 0.0625;
+    fcol = col * 0.0625;
+    size = 0.0625;
+
+    re.DrawStretchPic(ax, ay, aw, ah, fcol, frow, fcol + size, frow + size, cls.charSetShader);
+}
+
+/*
+** SCR_DrawSmallChar
+** small chars are drawn at native screen resolution
+*/
+void SCR_DrawSmallChar(int x, int y, int ch)
+{
+    int row, col;
+    float frow, fcol;
+    float size;
+
+    ch &= 255;
+
+    if (ch == ' ')
+    {
+        return;
+    }
+
+    if (y < -SMALLCHAR_HEIGHT)
+    {
+        return;
+    }
+
+    row = ch >> 4;
+    col = ch & 15;
+
+    frow = row * 0.0625;
+    fcol = col * 0.0625;
+    size = 0.0625;
+
+    re.DrawStretchPic(x, y, SMALLCHAR_WIDTH, SMALLCHAR_HEIGHT, fcol, frow, fcol + size, frow + size, cls.charSetShader);
+}
+
+/*
+==================
+SCR_DrawBigString[Color]
+
+Draws a multi-colored string with a drop shadow, optionally forcing
+to a fixed color.
+
+Coordinates are at 640 by 480 virtual resolution
+==================
+*/
+static void SCR_DrawStringExt(
+    int x, int y, float size, const char *string, float *setColor, bool forceColor, bool noColorEscape)
+{
+    vec4_t color;
+    const char *s;
+    int xx;
+
+    // draw the drop shadow
+    color[0] = color[1] = color[2] = 0;
+    color[3] = setColor[3];
+    re.SetColor(color);
+    s = string;
+    xx = x;
+    while (*s)
+    {
+        if (!noColorEscape && Q_IsColorString(s))
+        {
+            s += 2;
+            continue;
+        }
+        SCR_DrawChar(xx + 2, y + 2, size, *s);
+        xx += size;
+        s++;
+    }
+
+    // draw the colored text
+    s = string;
+    xx = x;
+    re.SetColor(setColor);
+    while (*s)
+    {
+        if (Q_IsColorString(s))
+        {
+            if (!forceColor)
+            {
+                ::memcpy(color, g_color_table[ColorIndex(*(s + 1))], sizeof(color));
+                color[3] = setColor[3];
+                re.SetColor(color);
+            }
+            if (!noColorEscape)
+            {
+                s += 2;
+                continue;
+            }
+        }
+        SCR_DrawChar(xx, y, size, *s);
+        xx += size;
+        s++;
+    }
+    re.SetColor(NULL);
+}
+
+void SCR_DrawBigString(int x, int y, const char *s, float alpha, bool noColorEscape)
+{
+    float color[4];
+
+    color[0] = color[1] = color[2] = 1.0;
+    color[3] = alpha;
+    SCR_DrawStringExt(x, y, BIGCHAR_WIDTH, s, color, false, noColorEscape);
+}
+
+void SCR_DrawBigStringColor(int x, int y, const char *s, vec4_t color, bool noColorEscape)
+{
+    SCR_DrawStringExt(x, y, BIGCHAR_WIDTH, s, color, true, noColorEscape);
+}
+
+/*
+==================
+SCR_DrawSmallString[Color]
+
+Draws a multi-colored string with a drop shadow, optionally forcing
+to a fixed color.
+==================
+*/
+void SCR_DrawSmallStringExt(int x, int y, const char *string, float *setColor, bool forceColor, bool noColorEscape)
+{
+    vec4_t color;
+    const char *s;
+    int xx;
+
+    // draw the colored text
+    s = string;
+    xx = x;
+    re.SetColor(setColor);
+    while (*s)
+    {
+        if (Q_IsColorString(s))
+        {
+            if (!forceColor)
+            {
+                ::memcpy(color, g_color_table[ColorIndex(*(s + 1))], sizeof(color));
+                color[3] = setColor[3];
+                re.SetColor(color);
+            }
+            if (!noColorEscape)
+            {
+                s += 2;
+                continue;
+            }
+        }
+        SCR_DrawSmallChar(xx, y, *s);
+        xx += SMALLCHAR_WIDTH;
+        s++;
+    }
+    re.SetColor(NULL);
+}
+
+/*
+** SCR_Strlen -- skips color escape codes
+*/
+static int SCR_Strlen(const char *str)
+{
+    const char *s = str;
+    int count = 0;
+
+    while (*s)
+    {
+        if (Q_IsColorString(s))
+        {
+            s += 2;
+        }
+        else
+        {
+            count++;
+            s++;
+        }
+    }
+
+    return count;
+}
+
+/*
+** SCR_GetBigStringWidth
+*/
+int SCR_GetBigStringWidth(const char *str) { return SCR_Strlen(str) * BIGCHAR_WIDTH; }
+//===============================================================================
+
+#ifdef USE_VOIP
+/*
+=================
+SCR_DrawVoipMeter
+
+FIXME: inherited from ioq3, move to cgame/ui
+=================
+*/
+void SCR_DrawVoipMeter(void)
+{
+    char buffer[16];
+    char string[256];
+    int limit, i;
+
+    if (!cl_voipShowMeter->integer)
+        return;  // player doesn't want to show meter at all.
+    else if (!cl_voipSend->integer)
+        return;  // not recording at the moment.
+    else if (clc.state != CA_ACTIVE)
+        return;  // not connected to a server.
+    else if (!clc.voipEnabled)
+        return;  // server doesn't support VoIP.
+    else if (clc.demoplaying)
+        return;  // playing back a demo.
+    else if (!cl_voip->integer)
+        return;  // client has VoIP support disabled.
+
+    limit = (int)(clc.voipPower * 10.0f);
+    if (limit > 10) limit = 10;
+
+    for (i = 0; i < limit; i++) buffer[i] = '*';
+    while (i < 10) buffer[i++] = ' ';
+    buffer[i] = '\0';
+
+    sprintf(string, "VoIP: [%s]", buffer);
+    SCR_DrawStringExt(320 - strlen(string) * 4, 10, 8, string, g_color_table[7], true, false);
+}
+#endif
+
+/*
+===============================================================================
+
+DEBUG GRAPH
+
+===============================================================================
+*/
+
+static int current;
+static float values[1024];
+
+/*
+==============
+SCR_DebugGraph
+==============
+*/
+void SCR_DebugGraph(float value)
+{
+    values[current] = value;
+    current = (current + 1) % ARRAY_LEN(values);
+}
+
+/*
+==============
+SCR_DrawDebugGraph
+==============
+*/
+void SCR_DrawDebugGraph(void)
+{
+    int a, x, y, w, i, h;
+    float v;
+
+    //
+    // draw the graph
+    //
+    w = cls.glconfig.vidWidth;
+    x = 0;
+    y = cls.glconfig.vidHeight;
+    re.SetColor(g_color_table[0]);
+    re.DrawStretchPic(x, y - cl_graphheight->integer, w, cl_graphheight->integer, 0, 0, 0, 0, cls.whiteShader);
+    re.SetColor(NULL);
+
+    for (a = 0; a < w; a++)
+    {
+        i = (ARRAY_LEN(values) + current - 1 - (a % ARRAY_LEN(values))) % ARRAY_LEN(values);
+        v = values[i];
+        v = v * cl_graphscale->integer + cl_graphshift->integer;
+
+        if (v < 0) v += cl_graphheight->integer * (1 + (int)(-v / cl_graphheight->integer));
+        h = (int)v % cl_graphheight->integer;
+        re.DrawStretchPic(x + w - 1 - a, y - h, 1, h, 0, 0, 0, 0, cls.whiteShader);
+    }
+}
+
+//=============================================================================
+
+/*
+==================
+SCR_Init
+==================
+*/
+void SCR_Init(void)
+{
+    cl_timegraph = Cvar_Get("timegraph", "0", CVAR_CHEAT);
+    cl_debuggraph = Cvar_Get("debuggraph", "0", CVAR_CHEAT);
+    cl_graphheight = Cvar_Get("graphheight", "32", CVAR_CHEAT);
+    cl_graphscale = Cvar_Get("graphscale", "1", CVAR_CHEAT);
+    cl_graphshift = Cvar_Get("graphshift", "0", CVAR_CHEAT);
+
+    scr_initialized = true;
+}
+
+//=======================================================
+
+/*
+==================
+SCR_DrawScreenField
+
+This will be called twice if rendering in stereo mode
+==================
+*/
+void SCR_DrawScreenField(stereoFrame_t stereoFrame)
+{
+    bool uiFullscreen;
+
+    re.BeginFrame(stereoFrame);
+
+    uiFullscreen = (cls.ui && VM_Call(cls.ui, UI_IS_FULLSCREEN - (cls.uiInterface == 2 ? 2 : 0)));
+
+    // wide aspect ratio screens need to have the sides cleared
+    // unless they are displaying game renderings
+    if (uiFullscreen || clc.state < CA_LOADING)
+    {
+        if (cls.glconfig.vidWidth * 480 > cls.glconfig.vidHeight * 640)
+        {
+            re.SetColor(g_color_table[0]);
+            re.DrawStretchPic(0, 0, cls.glconfig.vidWidth, cls.glconfig.vidHeight, 0, 0, 0, 0, cls.whiteShader);
+            re.SetColor(NULL);
+        }
+    }
+
+    // if the menu is going to cover the entire screen, we
+    // don't need to render anything under it
+    if (cls.ui && !uiFullscreen)
+    {
+        switch (clc.state)
+        {
+            default:
+                Com_Error(ERR_FATAL, "SCR_DrawScreenField: bad clc.state");
+                break;
+            case CA_CINEMATIC:
+                SCR_DrawCinematic();
+                break;
+            case CA_DISCONNECTED:
+                // force menu up
+                S_StopAllSounds();
+                VM_Call(cls.ui, UI_SET_ACTIVE_MENU - (cls.uiInterface == 2 ? 2 : 0), UIMENU_MAIN);
+                break;
+            case CA_CONNECTING:
+            case CA_CHALLENGING:
+            case CA_CONNECTED:
+                // connecting clients will only show the connection dialog
+                // refresh to update the time
+                VM_Call(cls.ui, UI_REFRESH - (cls.uiInterface == 2 ? 2 : 0), cls.realtime);
+                VM_Call(cls.ui, UI_DRAW_CONNECT_SCREEN - (cls.uiInterface == 2 ? 2 : 0), false);
+                break;
+            case CA_LOADING:
+            case CA_PRIMED:
+                // draw the game information screen and loading progress
+                CL_CGameRendering(stereoFrame);
+                break;
+            case CA_ACTIVE:
+                // always supply STEREO_CENTER as vieworg offset is now done by the engine.
+                CL_CGameRendering(stereoFrame);
+#ifdef USE_VOIP
+                SCR_DrawVoipMeter();
+#endif
+                break;
+        }
+    }
+
+    // the menu draws next
+    if (Key_GetCatcher() & KEYCATCH_UI && cls.ui)
+    {
+        VM_Call(cls.ui, UI_REFRESH - (cls.uiInterface == 2 ? 2 : 0), cls.realtime);
+    }
+
+    // console draws next
+    Con_DrawConsole();
+
+    // debug graph can be drawn on top of anything
+    if (cl_debuggraph->integer || cl_timegraph->integer || cl_debugMove->integer)
+    {
+        SCR_DrawDebugGraph();
+    }
+}
+
+/*
+==================
+SCR_UpdateScreen
+
+This is called every frame, and can also be called explicitly to flush
+text to the screen.
+==================
+*/
+void SCR_UpdateScreen(void)
+{
+    static int recursive;
+
+    if (!scr_initialized)
+    {
+        return;  // not initialized yet
+    }
+
+    if (++recursive > 2)
+    {
+        Com_Error(ERR_FATAL, "SCR_UpdateScreen: recursively called");
+    }
+    recursive = 1;
+
+    // If there is no VM, there are also no rendering commands issued. Stop the renderer in
+    // that case.
+    if (cls.ui || com_dedicated->integer)
+    {
+        // XXX
+        int in_anaglyphMode = Cvar_VariableIntegerValue("r_anaglyphMode");
+        // if running in stereo, we need to draw the frame twice
+        if (cls.glconfig.stereoEnabled || in_anaglyphMode)
+        {
+            SCR_DrawScreenField(STEREO_LEFT);
+            SCR_DrawScreenField(STEREO_RIGHT);
+        }
+        else
+        {
+            SCR_DrawScreenField(STEREO_CENTER);
+        }
+
+        if (com_speeds->integer)
+        {
+            re.EndFrame(&time_frontend, &time_backend);
+        }
+        else
+        {
+            re.EndFrame(NULL, NULL);
+        }
+    }
+
+    recursive = 0;
+}
diff --git a/src/client/cl_ui.cpp b/src/client/cl_ui.cpp
new file mode 100644
index 0000000..4052fe6
--- /dev/null
+++ b/src/client/cl_ui.cpp
@@ -0,0 +1,1269 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include "client.h"
+
+#include "cl_updates.h"
+
+/*
+====================
+GetClientState
+====================
+*/
+static void GetClientState(uiClientState_t *state)
+{
+    state->connectPacketCount = clc.connectPacketCount;
+    state->connState = clc.state;
+    Q_strncpyz(state->servername, clc.servername, sizeof(state->servername));
+    Q_strncpyz(state->updateInfoString, cls.updateInfoString, sizeof(state->updateInfoString));
+    Q_strncpyz(state->messageString, clc.serverMessage, sizeof(state->messageString));
+    state->clientNum = (clc.netchan.alternateProtocol == 2 ? cl.snap.alternatePs.clientNum : cl.snap.ps.clientNum);
+}
+
+/*
+====================
+LAN_LoadCachedServers
+====================
+*/
+void LAN_LoadCachedServers(void)
+{
+    int size;
+    fileHandle_t fileIn;
+    cls.numglobalservers = cls.numfavoriteservers = 0;
+    cls.numGlobalServerAddresses = 0;
+    if (FS_SV_FOpenFileRead("servercache.dat", &fileIn))
+    {
+        FS_Read(&cls.numglobalservers, sizeof(int), fileIn);
+        FS_Read(&cls.numfavoriteservers, sizeof(int), fileIn);
+        FS_Read(&size, sizeof(int), fileIn);
+        if (size == sizeof(cls.globalServers) + sizeof(cls.favoriteServers))
+        {
+            FS_Read(&cls.globalServers, sizeof(cls.globalServers), fileIn);
+            FS_Read(&cls.favoriteServers, sizeof(cls.favoriteServers), fileIn);
+        }
+        else
+        {
+            cls.numglobalservers = cls.numfavoriteservers = 0;
+            cls.numGlobalServerAddresses = 0;
+        }
+        FS_FCloseFile(fileIn);
+    }
+}
+
+/*
+====================
+LAN_SaveServersToCache
+====================
+*/
+void LAN_SaveServersToCache(void)
+{
+    fileHandle_t fileOut = FS_SV_FOpenFileWrite("servercache.dat");
+    FS_Write(&cls.numglobalservers, sizeof(int), fileOut);
+    FS_Write(&cls.numfavoriteservers, sizeof(int), fileOut);
+
+    int size = sizeof(cls.globalServers) + sizeof(cls.favoriteServers);
+    FS_Write(&size, sizeof(int), fileOut);
+    FS_Write(&cls.globalServers, sizeof(cls.globalServers), fileOut);
+    FS_Write(&cls.favoriteServers, sizeof(cls.favoriteServers), fileOut);
+    FS_FCloseFile(fileOut);
+}
+
+/*
+====================
+GetNews
+====================
+*/
+static bool GetNews(bool begin)
+{
+    bool finished = false;
+    fileHandle_t fileIn;
+    int readSize;
+
+    if (begin)
+    {  // if not already using curl, start the download
+        if (!clc.downloadCURLM)
+        {
+            if (!CL_cURL_Init())
+            {
+                Cvar_Set("cl_newsString", "^1Error: Could not load cURL library");
+                return true;
+            }
+            clc.activeCURLNotGameRelated = true;
+            CL_cURL_BeginDownload("news.dat", "http://grangerhub.com/wp-content/uploads/clientnews.txt");
+            return false;
+        }
+    }
+
+    if (!clc.downloadCURLM && FS_SV_FOpenFileRead("news.dat", &fileIn))
+    {
+        readSize = FS_Read(clc.newsString, sizeof(clc.newsString), fileIn);
+        FS_FCloseFile(fileIn);
+        clc.newsString[readSize] = '\0';
+        if (readSize > 0)
+        {
+            finished = true;
+            clc.cURLUsed = false;
+            CL_cURL_Shutdown();
+            clc.activeCURLNotGameRelated = false;
+        }
+    }
+    if (!finished) strcpy(clc.newsString, "Retrieving...");
+    Cvar_Set("cl_newsString", clc.newsString);
+    return finished;
+    Cvar_Set("cl_newsString", "^1You must compile your client with CURL support to use this feature");
+    return true;
+}
+
+/*
+====================
+LAN_ResetPings
+====================
+*/
+static void LAN_ResetPings(int source)
+{
+    int count, i;
+    serverInfo_t *servers = NULL;
+    count = 0;
+
+    switch (source)
+    {
+        case AS_LOCAL:
+            servers = &cls.localServers[0];
+            count = MAX_OTHER_SERVERS;
+            break;
+        case AS_MPLAYER:
+        case AS_GLOBAL:
+            servers = &cls.globalServers[0];
+            count = MAX_GLOBAL_SERVERS;
+            break;
+        case AS_FAVORITES:
+            servers = &cls.favoriteServers[0];
+            count = MAX_OTHER_SERVERS;
+            break;
+    }
+    if (servers)
+    {
+        for (i = 0; i < count; i++)
+        {
+            servers[i].ping = -1;
+        }
+    }
+}
+
+/*
+====================
+LAN_AddServer
+====================
+*/
+static int LAN_AddServer(int source, const char *name, const char *address)
+{
+    int max, *count, i;
+    netadr_t adr;
+    serverInfo_t *servers = NULL;
+    max = MAX_OTHER_SERVERS;
+    count = NULL;
+
+    switch (source)
+    {
+        case AS_LOCAL:
+            count = &cls.numlocalservers;
+            servers = &cls.localServers[0];
+            break;
+        case AS_MPLAYER:
+        case AS_GLOBAL:
+            max = MAX_GLOBAL_SERVERS;
+            count = &cls.numglobalservers;
+            servers = &cls.globalServers[0];
+            break;
+        case AS_FAVORITES:
+            count = &cls.numfavoriteservers;
+            servers = &cls.favoriteServers[0];
+            break;
+    }
+    if (servers && *count < max)
+    {
+        NET_StringToAdr(address, &adr, NA_UNSPEC);
+        for (i = 0; i < *count; i++)
+        {
+            if (NET_CompareAdr(servers[i].adr, adr))
+            {
+                break;
+            }
+        }
+        if (i >= *count)
+        {
+            servers[*count].adr = adr;
+            Q_strncpyz(servers[*count].hostName, name, sizeof(servers[*count].hostName));
+            servers[*count].visible = true;
+            (*count)++;
+            return 1;
+        }
+        return 0;
+    }
+    return -1;
+}
+
+/*
+====================
+LAN_RemoveServer
+====================
+*/
+static void LAN_RemoveServer(int source, const char *addr)
+{
+    int *count, i;
+    serverInfo_t *servers = NULL;
+    count = NULL;
+    switch (source)
+    {
+        case AS_LOCAL:
+            count = &cls.numlocalservers;
+            servers = &cls.localServers[0];
+            break;
+        case AS_MPLAYER:
+        case AS_GLOBAL:
+            count = &cls.numglobalservers;
+            servers = &cls.globalServers[0];
+            break;
+        case AS_FAVORITES:
+            count = &cls.numfavoriteservers;
+            servers = &cls.favoriteServers[0];
+            break;
+    }
+    if (servers)
+    {
+        netadr_t comp;
+        NET_StringToAdr(addr, &comp, NA_UNSPEC);
+        for (i = 0; i < *count; i++)
+        {
+            if (NET_CompareAdr(comp, servers[i].adr))
+            {
+                int j = i;
+                while (j < *count - 1)
+                {
+                    ::memcpy(&servers[j], &servers[j + 1], sizeof(servers[j]));
+                    j++;
+                }
+                (*count)--;
+                break;
+            }
+        }
+    }
+}
+
+/*
+====================
+LAN_GetServerCount
+====================
+*/
+static int LAN_GetServerCount(int source)
+{
+    switch (source)
+    {
+        case AS_LOCAL:
+            return cls.numlocalservers;
+            break;
+        case AS_MPLAYER:
+        case AS_GLOBAL:
+            return cls.numglobalservers;
+            break;
+        case AS_FAVORITES:
+            return cls.numfavoriteservers;
+            break;
+    }
+    return 0;
+}
+
+/*
+====================
+LAN_GetLocalServerAddressString
+====================
+*/
+static void LAN_GetServerAddressString(int source, int n, char *buf, int buflen)
+{
+    switch (source)
+    {
+        case AS_LOCAL:
+            if (n >= 0 && n < MAX_OTHER_SERVERS)
+            {
+                Q_strncpyz(buf, NET_AdrToStringwPort(cls.localServers[n].adr), buflen);
+                if (cls.localServers[n].adr.alternateProtocol != 0)
+                    Q_strncpyz(buf + (int)strlen(buf), (cls.localServers[n].adr.alternateProtocol == 1 ? " -g" : " -1"),
+                        buflen - (int)strlen(buf));
+                return;
+            }
+            break;
+        case AS_MPLAYER:
+        case AS_GLOBAL:
+            if (n >= 0 && n < MAX_GLOBAL_SERVERS)
+            {
+                Q_strncpyz(buf, NET_AdrToStringwPort(cls.globalServers[n].adr), buflen);
+                if (cls.globalServers[n].adr.alternateProtocol != 0)
+                    Q_strncpyz(buf + (int)strlen(buf),
+                        (cls.globalServers[n].adr.alternateProtocol == 1 ? " -g" : " -1"), buflen - (int)strlen(buf));
+                return;
+            }
+            break;
+        case AS_FAVORITES:
+            if (n >= 0 && n < MAX_OTHER_SERVERS)
+            {
+                Q_strncpyz(buf, NET_AdrToStringwPort(cls.favoriteServers[n].adr), buflen);
+                if (cls.favoriteServers[n].adr.alternateProtocol != 0)
+                    Q_strncpyz(buf + (int)strlen(buf),
+                        (cls.favoriteServers[n].adr.alternateProtocol == 1 ? " -g" : " -1"), buflen - (int)strlen(buf));
+                return;
+            }
+            break;
+    }
+    buf[0] = '\0';
+}
+
+/*
+====================
+LAN_GetServerInfo
+====================
+*/
+static void LAN_GetServerInfo(int source, int n, char *buf, int buflen)
+{
+    char info[MAX_STRING_CHARS];
+    serverInfo_t *server = NULL;
+    info[0] = '\0';
+    switch (source)
+    {
+        case AS_LOCAL:
+            if (n >= 0 && n < MAX_OTHER_SERVERS)
+            {
+                server = &cls.localServers[n];
+            }
+            break;
+        case AS_MPLAYER:
+        case AS_GLOBAL:
+            if (n >= 0 && n < MAX_GLOBAL_SERVERS)
+            {
+                server = &cls.globalServers[n];
+            }
+            break;
+        case AS_FAVORITES:
+            if (n >= 0 && n < MAX_OTHER_SERVERS)
+            {
+                server = &cls.favoriteServers[n];
+            }
+            break;
+    }
+    if (server && buf)
+    {
+        buf[0] = '\0';
+        if (server->adr.alternateProtocol != 0)
+        {
+            char hn[MAX_HOSTNAME_LENGTH];
+            Q_strncpyz(hn, server->hostName, sizeof(hn));
+            Q_strcat(
+                hn, sizeof(hn), (server->adr.alternateProtocol == 1 ? S_COLOR_WHITE " [GPP]" : S_COLOR_WHITE " [1.1]"));
+            Info_SetValueForKey(info, "hostname", hn);
+        }
+        else
+        {
+            Info_SetValueForKey(info, "hostname", server->hostName);
+        }
+        Info_SetValueForKey(info, "mapname", server->mapName);
+        Info_SetValueForKey(info, "label", server->label);
+        Info_SetValueForKey(info, "clients", va("%i", server->clients));
+        Info_SetValueForKey(info, "sv_maxclients", va("%i", server->maxClients));
+        Info_SetValueForKey(info, "ping", va("%i", server->ping));
+        Info_SetValueForKey(info, "minping", va("%i", server->minPing));
+        Info_SetValueForKey(info, "maxping", va("%i", server->maxPing));
+        Info_SetValueForKey(info, "game", server->game);
+        Info_SetValueForKey(info, "gametype", va("%i", server->gameType));
+        Info_SetValueForKey(info, "nettype", va("%i", server->netType));
+        Info_SetValueForKey(info, "addr", NET_AdrToStringwPort(server->adr));
+        Q_strncpyz(buf, info, buflen);
+    }
+    else
+    {
+        if (buf)
+        {
+            buf[0] = '\0';
+        }
+    }
+}
+
+/*
+====================
+LAN_GetServerPing
+====================
+*/
+static int LAN_GetServerPing(int source, int n)
+{
+    serverInfo_t *server = NULL;
+    switch (source)
+    {
+        case AS_LOCAL:
+            if (n >= 0 && n < MAX_OTHER_SERVERS)
+            {
+                server = &cls.localServers[n];
+            }
+            break;
+        case AS_MPLAYER:
+        case AS_GLOBAL:
+            if (n >= 0 && n < MAX_GLOBAL_SERVERS)
+            {
+                server = &cls.globalServers[n];
+            }
+            break;
+        case AS_FAVORITES:
+            if (n >= 0 && n < MAX_OTHER_SERVERS)
+            {
+                server = &cls.favoriteServers[n];
+            }
+            break;
+    }
+    if (server)
+    {
+        return server->ping;
+    }
+    return -1;
+}
+
+/*
+====================
+LAN_GetServerPtr
+====================
+*/
+static serverInfo_t *LAN_GetServerPtr(int source, int n)
+{
+    switch (source)
+    {
+        case AS_LOCAL:
+            if (n >= 0 && n < MAX_OTHER_SERVERS)
+            {
+                return &cls.localServers[n];
+            }
+            break;
+        case AS_MPLAYER:
+        case AS_GLOBAL:
+            if (n >= 0 && n < MAX_GLOBAL_SERVERS)
+            {
+                return &cls.globalServers[n];
+            }
+            break;
+        case AS_FAVORITES:
+            if (n >= 0 && n < MAX_OTHER_SERVERS)
+            {
+                return &cls.favoriteServers[n];
+            }
+            break;
+    }
+    return NULL;
+}
+
+#define FEATURED_MAXPING 200
+/*
+====================
+LAN_CompareServers
+====================
+*/
+static int LAN_CompareServers(int source, int sortKey, int sortDir, int s1, int s2)
+{
+    int res;
+    serverInfo_t *server1, *server2;
+
+    server1 = LAN_GetServerPtr(source, s1);
+    server2 = LAN_GetServerPtr(source, s2);
+    if (!server1 || !server2)
+    {
+        return 0;
+    }
+
+    // featured servers on top
+    if ((server1->label[0] && server1->ping <= FEATURED_MAXPING) ||
+        (server2->label[0] && server2->ping <= FEATURED_MAXPING))
+    {
+        res = Q_stricmpn(server1->label, server2->label, MAX_FEATLABEL_CHARS);
+        if (res) return -res;
+    }
+
+    res = 0;
+    switch (sortKey)
+    {
+        case SORT_HOST:
+        {
+            char hostName1[MAX_HOSTNAME_LENGTH];
+            char hostName2[MAX_HOSTNAME_LENGTH];
+            char *p;
+            int i;
+
+            for (p = server1->hostName, i = 0; *p != '\0'; p++)
+            {
+                if (Q_isalpha(*p)) hostName1[i++] = *p;
+            }
+            hostName1[i] = '\0';
+
+            for (p = server2->hostName, i = 0; *p != '\0'; p++)
+            {
+                if (Q_isalpha(*p)) hostName2[i++] = *p;
+            }
+            hostName2[i] = '\0';
+
+            res = Q_stricmp(hostName1, hostName2);
+        }
+        break;
+
+        case SORT_GAME:
+            res = Q_stricmp(server1->game, server2->game);
+            break;
+        case SORT_MAP:
+            res = Q_stricmp(server1->mapName, server2->mapName);
+            break;
+        case SORT_CLIENTS:
+            if (server1->clients < server2->clients)
+            {
+                res = -1;
+            }
+            else if (server1->clients > server2->clients)
+            {
+                res = 1;
+            }
+            else
+            {
+                res = 0;
+            }
+            break;
+        case SORT_PING:
+            if (server1->ping < server2->ping)
+            {
+                res = -1;
+            }
+            else if (server1->ping > server2->ping)
+            {
+                res = 1;
+            }
+            else
+            {
+                res = 0;
+            }
+            break;
+    }
+
+    if (sortDir)
+    {
+        if (res < 0) return 1;
+        if (res > 0) return -1;
+        return 0;
+    }
+    return res;
+}
+
+/*
+====================
+LAN_GetPingQueueCount
+====================
+*/
+static int LAN_GetPingQueueCount(void) { return (CL_GetPingQueueCount()); }
+/*
+====================
+LAN_ClearPing
+====================
+*/
+static void LAN_ClearPing(int n) { CL_ClearPing(n); }
+/*
+====================
+LAN_GetPing
+====================
+*/
+static void LAN_GetPing(int n, char *buf, int buflen, int *pingtime) { CL_GetPing(n, buf, buflen, pingtime); }
+/*
+====================
+LAN_GetPingInfo
+====================
+*/
+static void LAN_GetPingInfo(int n, char *buf, int buflen) { CL_GetPingInfo(n, buf, buflen); }
+/*
+====================
+LAN_MarkServerVisible
+====================
+*/
+static void LAN_MarkServerVisible(int source, int n, bool visible)
+{
+    if (n == -1)
+    {
+        int count = MAX_OTHER_SERVERS;
+        serverInfo_t *server = NULL;
+        switch (source)
+        {
+            case AS_LOCAL:
+                server = &cls.localServers[0];
+                break;
+            case AS_MPLAYER:
+            case AS_GLOBAL:
+                server = &cls.globalServers[0];
+                count = MAX_GLOBAL_SERVERS;
+                break;
+            case AS_FAVORITES:
+                server = &cls.favoriteServers[0];
+                break;
+        }
+        if (server)
+        {
+            for (n = 0; n < count; n++)
+            {
+                server[n].visible = visible;
+            }
+        }
+    }
+    else
+    {
+        switch (source)
+        {
+            case AS_LOCAL:
+                if (n >= 0 && n < MAX_OTHER_SERVERS)
+                {
+                    cls.localServers[n].visible = visible;
+                }
+                break;
+            case AS_MPLAYER:
+            case AS_GLOBAL:
+                if (n >= 0 && n < MAX_GLOBAL_SERVERS)
+                {
+                    cls.globalServers[n].visible = visible;
+                }
+                break;
+            case AS_FAVORITES:
+                if (n >= 0 && n < MAX_OTHER_SERVERS)
+                {
+                    cls.favoriteServers[n].visible = visible;
+                }
+                break;
+        }
+    }
+}
+
+/*
+=======================
+LAN_ServerIsVisible
+=======================
+*/
+static bool LAN_ServerIsVisible(int source, int n)
+{
+    switch (source)
+    {
+        case AS_LOCAL:
+            if (n >= 0 && n < MAX_OTHER_SERVERS)
+            {
+                return cls.localServers[n].visible;
+            }
+            break;
+        case AS_MPLAYER:
+        case AS_GLOBAL:
+            if (n >= 0 && n < MAX_GLOBAL_SERVERS)
+            {
+                return cls.globalServers[n].visible;
+            }
+            break;
+        case AS_FAVORITES:
+            if (n >= 0 && n < MAX_OTHER_SERVERS)
+            {
+                return cls.favoriteServers[n].visible;
+            }
+            break;
+    }
+    return false;
+}
+
+/*
+=======================
+LAN_UpdateVisiblePings
+=======================
+*/
+static bool LAN_UpdateVisiblePings(int source) { return CL_UpdateVisiblePings_f(source); }
+/*
+====================
+LAN_GetServerStatus
+====================
+*/
+static bool LAN_GetServerStatus(char *serverAddress, char *serverStatus, int maxLen)
+{
+    return CL_ServerStatus(serverAddress, serverStatus, maxLen);
+}
+
+/*
+====================
+CL_GetGlConfig
+====================
+*/
+static void CL_GetGlconfig(glconfig_t *config) { *config = cls.glconfig; }
+/*
+====================
+GetConfigString
+====================
+*/
+static bool GetConfigString(int i, char *buf, int size)
+{
+    int offset;
+
+    if (i < 0 || i >= MAX_CONFIGSTRINGS) return false;
+
+    offset = cl.gameState.stringOffsets[i];
+    if (!offset)
+    {
+        if (size) buf[0] = '\0';
+        return false;
+    }
+
+    Q_strncpyz(buf, cl.gameState.stringData + offset, size);
+
+    return true;
+}
+
+/*
+====================
+FloatAsInt
+====================
+*/
+static int FloatAsInt(float f)
+{
+    floatint_t fi;
+    fi.f = f;
+    return fi.i;
+}
+
+static bool probingUI = false;
+
+/*
+====================
+CL_UISystemCalls
+
+The ui module is making a system call
+====================
+*/
+intptr_t CL_UISystemCalls(intptr_t *args)
+{
+    if (cls.uiInterface == 2)
+    {
+        if (args[0] >= UI_R_SETCLIPREGION && args[0] < UI_MEMSET)
+        {
+            if (args[0] < UI_S_STOPBACKGROUNDTRACK - 1)
+            {
+                args[0] += 1;
+            }
+            else if (args[0] < UI_S_STOPBACKGROUNDTRACK + 4)
+            {
+                args[0] += UI_PARSE_ADD_GLOBAL_DEFINE - UI_S_STOPBACKGROUNDTRACK + 1;
+            }
+            else if (args[0] >= UI_PARSE_ADD_GLOBAL_DEFINE + 4)
+            {
+                args[0] += UI_GETNEWS - UI_PARSE_ADD_GLOBAL_DEFINE - 5;
+                if (args[0] == UI_PARSE_SOURCE_FILE_AND_LINE || args[0] == UI_GETNEWS)
+                    args[0] = UI_PARSE_SOURCE_FILE_AND_LINE - 1337 - args[0];
+            }
+            else
+            {
+                args[0] -= 4;
+            }
+        }
+
+        switch (args[0])
+        {
+            case UI_LAN_GETSERVERCOUNT:
+            case UI_LAN_GETSERVERADDRESSSTRING:
+            case UI_LAN_GETSERVERINFO:
+            case UI_LAN_MARKSERVERVISIBLE:
+            case UI_LAN_UPDATEVISIBLEPINGS:
+            case UI_LAN_RESETPINGS:
+            case UI_LAN_ADDSERVER:
+            case UI_LAN_REMOVESERVER:
+            case UI_LAN_GETSERVERPING:
+            case UI_LAN_SERVERISVISIBLE:
+            case UI_LAN_COMPARESERVERS:
+                if (args[1] == AS_GLOBAL)
+                {
+                    args[1] = AS_LOCAL;
+                }
+                else if (args[1] == AS_LOCAL)
+                {
+                    args[1] = AS_GLOBAL;
+                }
+        }
+    }
+
+    switch (args[0])
+    {
+        case UI_ERROR:
+            if (probingUI)
+            {
+                cls.uiInterface = 2;
+                return 0;
+            }
+            Com_Error(ERR_DROP, "%s", (const char *)VMA(1));
+            return 0;
+
+        case UI_PRINT:
+            Com_Printf("%s", (const char *)VMA(1));
+            return 0;
+
+        case UI_MILLISECONDS:
+            return Sys_Milliseconds();
+
+        case UI_CVAR_REGISTER:
+            Cvar_Register((vmCvar_t *)VMA(1), (const char *)VMA(2), (const char *)VMA(3), args[4]);
+            return 0;
+
+        case UI_CVAR_UPDATE:
+            Cvar_Update((vmCvar_t *)VMA(1));
+            return 0;
+
+        case UI_CVAR_SET:
+            Cvar_SetSafe((const char *)VMA(1), (const char *)VMA(2));
+            return 0;
+
+        case UI_CVAR_VARIABLEVALUE:
+            return FloatAsInt(Cvar_VariableValue((const char *)VMA(1)));
+
+        case UI_CVAR_VARIABLESTRINGBUFFER:
+            Cvar_VariableStringBuffer((const char *)VMA(1), (char *)VMA(2), args[3]);
+            return 0;
+
+        case UI_CVAR_SETVALUE:
+            Cvar_SetValueSafe((const char *)VMA(1), VMF(2));
+            return 0;
+
+        case UI_CVAR_RESET:
+            Cvar_Reset((const char *)VMA(1));
+            return 0;
+
+        case UI_CVAR_CREATE:
+            Cvar_Register(NULL, (const char *)VMA(1), (const char *)VMA(2), args[3]);
+            return 0;
+
+        case UI_CVAR_INFOSTRINGBUFFER:
+            Cvar_InfoStringBuffer(args[1], (char *)VMA(2), args[3]);
+            return 0;
+
+        case UI_ARGC:
+            return Cmd_Argc();
+
+        case UI_ARGV:
+            Cmd_ArgvBuffer(args[1], (char *)VMA(2), args[3]);
+            return 0;
+
+        case UI_CMD_EXECUTETEXT:
+            if (args[1] == EXEC_NOW)
+            {
+                if (!strncmp((const char *)VMA(2), "snd_restart", 11)
+                 || !strncmp((const char *)VMA(2), "vid_restart", 11)
+                 || !strncmp((const char *)VMA(2), "quit", 5))
+                {
+                    Com_Printf(S_COLOR_YELLOW "turning EXEC_NOW '%.11s' into EXEC_INSERT\n", (const char *)VMA(2));
+                    args[1] = EXEC_INSERT;
+                }
+            }
+
+            //  TODO: Do this better
+            if (!strncmp((const char *)VMA(2), "checkForUpdate", 14))
+            {
+                CL_GetLatestRelease();
+                return 0;
+            }
+
+            Cbuf_ExecuteText(args[1], (const char *)VMA(2));
+            return 0;
+
+        case UI_FS_FOPENFILE:
+            return FS_FOpenFileByMode((const char *)VMA(1), (fileHandle_t *)VMA(2), (FS_Mode)args[3]);
+
+        case UI_FS_READ:
+            FS_Read(VMA(1), args[2], args[3]);
+            return 0;
+
+        case UI_FS_WRITE:
+            FS_Write(VMA(1), args[2], args[3]);
+            return 0;
+
+        case UI_FS_FCLOSEFILE:
+            FS_FCloseFile(args[1]);
+            return 0;
+
+        case UI_FS_GETFILELIST:
+            return FS_GetFileList((const char *)VMA(1), (const char *)VMA(2), (char *)VMA(3), args[4]);
+
+        case UI_FS_SEEK:
+            return FS_Seek((fileHandle_t)args[1], args[2], (FS_Origin)args[3]);
+
+        case UI_R_REGISTERMODEL:
+            return re.RegisterModel((const char *)VMA(1));
+
+        case UI_R_REGISTERSKIN:
+            return re.RegisterSkin((const char *)VMA(1));
+
+        case UI_R_REGISTERSHADERNOMIP:
+            return re.RegisterShaderNoMip((const char *)VMA(1));
+
+        case UI_R_CLEARSCENE:
+            re.ClearScene();
+            return 0;
+
+        case UI_R_ADDREFENTITYTOSCENE:
+            re.AddRefEntityToScene((const refEntity_t *)VMA(1));
+            return 0;
+
+        case UI_R_ADDPOLYTOSCENE:
+            re.AddPolyToScene(args[1], args[2], (const polyVert_t *)VMA(3), 1);
+            return 0;
+
+        case UI_R_ADDLIGHTTOSCENE:
+            re.AddLightToScene((const float *)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5));
+            return 0;
+
+        case UI_R_RENDERSCENE:
+            re.RenderScene((const refdef_t *)VMA(1));
+            return 0;
+
+        case UI_R_SETCOLOR:
+            re.SetColor((const float *)VMA(1));
+            return 0;
+
+        case UI_R_SETCLIPREGION:
+            re.SetClipRegion((const float *)VMA(1));
+            return 0;
+
+        case UI_R_DRAWSTRETCHPIC:
+            re.DrawStretchPic(VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9]);
+            return 0;
+
+        case UI_R_MODELBOUNDS:
+            re.ModelBounds(args[1], (float *)VMA(2), (float *)VMA(3));
+            return 0;
+
+        case UI_UPDATESCREEN:
+            SCR_UpdateScreen();
+            return 0;
+
+        case UI_CM_LERPTAG:
+            re.LerpTag((orientation_t *)VMA(1), args[2], args[3], args[4], VMF(5), (const char *)VMA(6));
+            return 0;
+
+        case UI_S_REGISTERSOUND:
+            return S_RegisterSound((const char *)VMA(1), (bool)args[2]);
+
+        case UI_S_STARTLOCALSOUND:
+            S_StartLocalSound(args[1], args[2]);
+            return 0;
+
+        case UI_KEY_KEYNUMTOSTRINGBUF:
+            Key_KeynumToStringBuf(args[1], (char *)VMA(2), args[3]);
+            return 0;
+
+        case UI_KEY_GETBINDINGBUF:
+            Key_GetBindingBuf(args[1], (char *)VMA(2), args[3]);
+            return 0;
+
+        case UI_KEY_SETBINDING:
+            Key_SetBinding(args[1], (const char *)VMA(2));
+            return 0;
+
+        case UI_KEY_ISDOWN:
+            return Key_IsDown(args[1]);
+
+        case UI_KEY_GETOVERSTRIKEMODE:
+            return Key_GetOverstrikeMode();
+
+        case UI_KEY_SETOVERSTRIKEMODE:
+            Key_SetOverstrikeMode((bool)args[1]);
+            return 0;
+
+        case UI_KEY_CLEARSTATES:
+            Key_ClearStates();
+            return 0;
+
+        case UI_KEY_GETCATCHER:
+            return Key_GetCatcher();
+
+        case UI_KEY_SETCATCHER:
+            // don't allow the ui module to toggle the console
+            Key_SetCatcher((args[1] & ~KEYCATCH_CONSOLE) | (Key_GetCatcher() & KEYCATCH_CONSOLE));
+            return 0;
+
+        case UI_GETCLIPBOARDDATA:
+            ((char *)VMA(1))[0] = '\0';
+            return 0;
+
+        case UI_GETCLIENTSTATE:
+            GetClientState((uiClientState_t *)VMA(1));
+            return 0;
+
+        case UI_GETGLCONFIG:
+            CL_GetGlconfig((glconfig_t *)VMA(1));
+            return 0;
+
+        case UI_GETCONFIGSTRING:
+            return GetConfigString(args[1], (char *)VMA(2), args[3]);
+
+        case UI_LAN_LOADCACHEDSERVERS:
+            LAN_LoadCachedServers();
+            return 0;
+
+        case UI_LAN_SAVECACHEDSERVERS:
+            LAN_SaveServersToCache();
+            return 0;
+
+        case UI_LAN_ADDSERVER:
+            return LAN_AddServer(args[1], (const char *)VMA(2), (const char *)VMA(3));
+
+        case UI_LAN_REMOVESERVER:
+            LAN_RemoveServer(args[1], (const char *)VMA(2));
+            return 0;
+
+        case UI_LAN_GETPINGQUEUECOUNT:
+            return LAN_GetPingQueueCount();
+
+        case UI_LAN_CLEARPING:
+            LAN_ClearPing(args[1]);
+            return 0;
+
+        case UI_LAN_GETPING:
+            LAN_GetPing(args[1], (char *)VMA(2), args[3], (int *)VMA(4));
+            return 0;
+
+        case UI_LAN_GETPINGINFO:
+            LAN_GetPingInfo(args[1], (char *)VMA(2), args[3]);
+            return 0;
+
+        case UI_LAN_GETSERVERCOUNT:
+            return LAN_GetServerCount(args[1]);
+
+        case UI_LAN_GETSERVERADDRESSSTRING:
+            LAN_GetServerAddressString(args[1], args[2], (char *)VMA(3), args[4]);
+            return 0;
+
+        case UI_LAN_GETSERVERINFO:
+            LAN_GetServerInfo(args[1], args[2], (char *)VMA(3), args[4]);
+            return 0;
+
+        case UI_LAN_GETSERVERPING:
+            return LAN_GetServerPing(args[1], args[2]);
+
+        case UI_LAN_MARKSERVERVISIBLE:
+            LAN_MarkServerVisible(args[1], args[2], (bool)args[3]);
+            return 0;
+
+        case UI_LAN_SERVERISVISIBLE:
+            return LAN_ServerIsVisible(args[1], args[2]);
+
+        case UI_LAN_UPDATEVISIBLEPINGS:
+            return LAN_UpdateVisiblePings(args[1]);
+
+        case UI_LAN_RESETPINGS:
+            LAN_ResetPings(args[1]);
+            return 0;
+
+        case UI_LAN_SERVERSTATUS:
+            return LAN_GetServerStatus((char *)VMA(1), (char *)VMA(2), args[3]);
+
+        case UI_GETNEWS:
+            return GetNews((bool)args[1]);
+
+        case UI_LAN_COMPARESERVERS:
+            return LAN_CompareServers(args[1], args[2], args[3], args[4], args[5]);
+
+        case UI_MEMORY_REMAINING:
+            return Hunk_MemoryRemaining();
+
+        case UI_SET_PBCLSTATUS:
+            return 0;
+
+        case UI_R_REGISTERFONT:
+            re.RegisterFont((const char *)VMA(1), args[2], (fontInfo_t *)VMA(3));
+            return 0;
+
+        case UI_MEMSET:
+            ::memset(VMA(1), args[2], args[3]);
+            return 0;
+
+        case UI_MEMCPY:
+            ::memcpy(VMA(1), VMA(2), args[3]);
+            return 0;
+
+        case UI_STRNCPY:
+            strncpy((char *)VMA(1), (const char *)VMA(2), args[3]);
+            return args[1];
+
+        case UI_SIN:
+            return FloatAsInt(sin(VMF(1)));
+
+        case UI_COS:
+            return FloatAsInt(cos(VMF(1)));
+
+        case UI_ATAN2:
+            return FloatAsInt(atan2(VMF(1), VMF(2)));
+
+        case UI_SQRT:
+            return FloatAsInt(sqrt(VMF(1)));
+
+        case UI_FLOOR:
+            return FloatAsInt(floor(VMF(1)));
+
+        case UI_CEIL:
+            return FloatAsInt(ceil(VMF(1)));
+
+        case UI_PARSE_ADD_GLOBAL_DEFINE:
+            return Parse_AddGlobalDefine((char *)VMA(1));
+        case UI_PARSE_LOAD_SOURCE:
+            return Parse_LoadSourceHandle((char *)VMA(1));
+        case UI_PARSE_FREE_SOURCE:
+            return Parse_FreeSourceHandle(args[1]);
+        case UI_PARSE_READ_TOKEN:
+            return Parse_ReadTokenHandle(args[1], (pc_token_t *)VMA(2));
+        case UI_PARSE_SOURCE_FILE_AND_LINE:
+            return Parse_SourceFileAndLine(args[1], (char *)VMA(2), (int *)VMA(3));
+
+        case UI_S_STOPBACKGROUNDTRACK:
+            S_StopBackgroundTrack();
+            return 0;
+        case UI_S_STARTBACKGROUNDTRACK:
+            S_StartBackgroundTrack((const char *)VMA(1), (const char *)VMA(2));
+            return 0;
+
+        case UI_REAL_TIME:
+            return Com_RealTime((qtime_t *)VMA(1));
+
+        case UI_CIN_PLAYCINEMATIC:
+            return CIN_PlayCinematic((const char *)VMA(1), args[2], args[3], args[4], args[5], args[6]);
+
+        case UI_CIN_STOPCINEMATIC:
+            return CIN_StopCinematic(args[1]);
+
+        case UI_CIN_RUNCINEMATIC:
+            return CIN_RunCinematic(args[1]);
+
+        case UI_CIN_DRAWCINEMATIC:
+            CIN_DrawCinematic(args[1]);
+            return 0;
+
+        case UI_CIN_SETEXTENTS:
+            CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
+            return 0;
+
+        case UI_R_REMAP_SHADER:
+            re.RemapShader((const char *)VMA(1), (const char *)VMA(2), (const char *)VMA(3));
+            return 0;
+
+        default:
+            Com_Error(ERR_DROP, "Bad UI system trap: %ld", (long int)args[0]);
+    }
+
+    return 0;
+}
+
+/*
+====================
+CL_ShutdownUI
+====================
+*/
+void CL_ShutdownUI(void)
+{
+    Key_SetCatcher(Key_GetCatcher() & ~KEYCATCH_UI);
+    cls.uiStarted = false;
+    if (!cls.ui)
+    {
+        return;
+    }
+    VM_Call(cls.ui, UI_SHUTDOWN);
+    VM_Free(cls.ui);
+    cls.ui = NULL;
+}
+
+/*
+====================
+CL_InitUI
+====================
+*/
+void CL_InitUI(void)
+{
+    // load the dll or bytecode
+    vmInterpret_t interpret = (vmInterpret_t)Cvar_VariableValue("vm_ui");
+    if (cl_connectedToPureServer)
+    {
+        // if sv_pure is set we only allow qvms to be loaded
+        if (interpret != VMI_COMPILED && interpret != VMI_BYTECODE) interpret = VMI_COMPILED;
+    }
+
+    cls.ui = VM_Create("ui", CL_UISystemCalls, interpret);
+    if (!cls.ui)
+    {
+        Com_Printf("Failed to find a valid UI vm. The following paths were searched:\n");
+        Cmd_ExecuteString("path /\n");
+        Com_Error(ERR_RECONNECT, "VM_Create on UI failed");
+    }
+
+    // sanity check
+    int v = VM_Call(cls.ui, UI_GETAPIVERSION);
+    if (v != UI_API_VERSION)
+    {
+        // Free cls.ui now, so UI_SHUTDOWN doesn't get called later.
+        VM_Free(cls.ui);
+        cls.ui = NULL;
+
+        cls.uiStarted = false;
+        Com_Error(ERR_DROP, "User Interface is version %d, expected %d", v, UI_API_VERSION);
+    }
+
+    // Probe UI interface
+    // Calls the GPP UI_CONSOLE_COMMAND (10), if GPP will return false 0. If a 1.1.0 qvm, will hit the error handler.
+    Cmd_TokenizeString("");
+    cls.uiInterface = 0;
+    probingUI = true;
+    if ( VM_Call(cls.ui, UI_CONSOLE_COMMAND, 0) < 0 )
+        cls.uiInterface = 2;
+
+    probingUI = false;
+
+    if (clc.state >= CA_CONNECTED && clc.state <= CA_ACTIVE &&
+        (clc.netchan.alternateProtocol == 2) != (cls.uiInterface == 2))
+    {
+        Com_Printf(S_COLOR_YELLOW "WARNING: %s protocol %i, but a ui module using the %s interface was found\n",
+            (clc.demoplaying ? "Demo was recorded using" : "Server uses"),
+            (clc.netchan.alternateProtocol == 0 ? PROTOCOL_VERSION : clc.netchan.alternateProtocol == 1 ? 70 : 69),
+            (cls.uiInterface == 2 ? "1.1" : "non-1.1"));
+    }
+
+    // init for this gamestate
+    VM_Call(cls.ui, UI_INIT, (clc.state >= CA_AUTHORIZING && clc.state < CA_ACTIVE));
+
+    // show where the ui folder was loaded from
+    Cmd_ExecuteString("which ui/\n");
+
+    clc.newsString[0] = '\0';
+}
+
+/*
+====================
+UI_GameCommand
+
+See if the current console command is claimed by the ui
+====================
+*/
+bool UI_GameCommand(void)
+{
+    if (!cls.ui) return false;
+
+    return (bool)VM_Call(cls.ui, UI_CONSOLE_COMMAND - (cls.uiInterface == 2 ? 2 : 0), cls.realtime);
+}
diff --git a/src/client/cl_updates.cpp b/src/client/cl_updates.cpp
new file mode 100644
index 0000000..0e6a237
--- /dev/null
+++ b/src/client/cl_updates.cpp
@@ -0,0 +1,476 @@
+#include "cl_updates.h"
+
+#include <libgen.h>
+#include <unistd.h>
+
+#include "nettle/rsa.h"
+#include "nettle/sha2.h"
+#include "rapidjson.h"
+#include "restclient/connection.h"
+#include "restclient/restclient.h"
+#include "semantic_version.h"
+
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <array>
+
+#include "qcommon/cvar.h"
+#include "qcommon/q_platform.h"
+#include "qcommon/q_shared.h"
+#include "qcommon/qcommon.h"
+#include "qcommon/unzip.h"
+#include "sys/sys_shared.h"
+
+#include "cl_rest.h"
+
+using namespace std;
+
+std::vector<std::string> release_package;
+static std::string granger_exe;
+static std::string granger_main_lua;
+static int nextCheckTime = 0;
+
+static const uint8_t release_key_pub[] = {
+  0x28, 0x31, 0x30, 0x3a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2d, 0x6b,
+  0x65, 0x79, 0x28, 0x39, 0x3a, 0x72, 0x73, 0x61, 0x2d, 0x70, 0x6b, 0x63,
+  0x73, 0x31, 0x28, 0x31, 0x3a, 0x6e, 0x35, 0x31, 0x33, 0x3a, 0x00, 0xaa,
+  0x4a, 0xe1, 0xdc, 0x08, 0xed, 0x90, 0x92, 0x66, 0x4a, 0xc2, 0x00, 0x43,
+  0x3e, 0x89, 0x40, 0x4d, 0x11, 0xaa, 0x98, 0x2d, 0x55, 0x08, 0xec, 0x43,
+  0x9f, 0x73, 0xfe, 0xc9, 0x67, 0xcb, 0xb0, 0x4a, 0x52, 0x89, 0x1d, 0x1a,
+  0xc1, 0x86, 0x29, 0x26, 0x32, 0xb2, 0x34, 0xb6, 0xa5, 0x42, 0x16, 0x08,
+  0x60, 0x8d, 0xf1, 0xe4, 0x45, 0xd4, 0x90, 0x2b, 0xfb, 0x98, 0xb2, 0x2e,
+  0xa7, 0xa9, 0x79, 0xff, 0x5e, 0xaa, 0xb5, 0xd6, 0xf9, 0xf9, 0x2e, 0x67,
+  0x5c, 0xb6, 0x6c, 0x36, 0x70, 0xf3, 0xea, 0x3f, 0xd8, 0xc8, 0xd0, 0xda,
+  0xd8, 0xfb, 0x1b, 0x55, 0xe9, 0x69, 0x9d, 0x4a, 0xea, 0xf2, 0xb1, 0xdd,
+  0x6b, 0xea, 0xb4, 0x99, 0xd7, 0x5e, 0xca, 0x5f, 0x34, 0xcf, 0xee, 0xbb,
+  0xc6, 0x07, 0xa8, 0x3b, 0x59, 0xc3, 0xc1, 0x53, 0x15, 0x2b, 0xe4, 0x2f,
+  0x17, 0x2d, 0x0c, 0x0f, 0x4e, 0xee, 0x2e, 0xef, 0x97, 0x9c, 0xff, 0x58,
+  0xec, 0x6a, 0xf1, 0x12, 0x21, 0x5a, 0xc5, 0xbb, 0x6a, 0xef, 0xb0, 0xc8,
+  0x4b, 0x7d, 0x33, 0xca, 0x53, 0x03, 0x31, 0x4a, 0xbd, 0x82, 0x01, 0x56,
+  0x8f, 0x4e, 0x1d, 0x21, 0x7d, 0x2e, 0x8d, 0xaa, 0x0d, 0xcd, 0xe6, 0x19,
+  0x09, 0x79, 0x76, 0x11, 0x16, 0xb5, 0xd2, 0xc1, 0x03, 0xdb, 0xaa, 0x11,
+  0xd5, 0x89, 0x70, 0xc8, 0x71, 0xbf, 0x1a, 0xea, 0x9d, 0xd6, 0xaa, 0x77,
+  0x97, 0xa4, 0xcc, 0x1d, 0xd6, 0x1c, 0x1a, 0x14, 0x6f, 0x35, 0x34, 0x6a,
+  0x10, 0x32, 0x13, 0x33, 0x41, 0x27, 0xad, 0x1b, 0x59, 0x41, 0xff, 0xb0,
+  0x1b, 0x64, 0x14, 0xea, 0x29, 0x44, 0x2b, 0x62, 0xdc, 0x63, 0xbc, 0xc7,
+  0xf8, 0xac, 0xf7, 0x5c, 0x9d, 0x3c, 0xbd, 0x17, 0x84, 0xd9, 0x56, 0x09,
+  0x44, 0x1b, 0xdd, 0x72, 0x16, 0xf6, 0x67, 0xc4, 0x49, 0xd3, 0x56, 0x74,
+  0x42, 0x2d, 0x08, 0xe2, 0x0b, 0x0c, 0x40, 0x97, 0x62, 0x97, 0xb3, 0xd6,
+  0x0c, 0x69, 0x04, 0x6a, 0xd7, 0x7b, 0xf0, 0xe1, 0x37, 0x0b, 0xe0, 0xee,
+  0x6b, 0x2d, 0x79, 0xa0, 0x72, 0xa5, 0x75, 0x97, 0xb1, 0x6b, 0x01, 0xa2,
+  0xb8, 0xe3, 0xc7, 0x3c, 0x10, 0x50, 0x59, 0xe4, 0xda, 0x9e, 0x8d, 0xe6,
+  0x1b, 0xef, 0xa6, 0xae, 0xc4, 0xd7, 0xd8, 0x9b, 0x57, 0x4c, 0xa3, 0xd7,
+  0x9f, 0x37, 0x17, 0x72, 0x7f, 0x60, 0xd6, 0x4c, 0x42, 0x14, 0x54, 0x66,
+  0x88, 0xc6, 0xa2, 0x1e, 0xdf, 0x55, 0xfc, 0xef, 0xb9, 0x05, 0x63, 0x8a,
+  0xc4, 0x5b, 0xe7, 0x45, 0x28, 0x0e, 0x55, 0x8e, 0xcc, 0x74, 0x25, 0xf2,
+  0xea, 0x2a, 0x66, 0x51, 0xf2, 0x8f, 0x72, 0x1d, 0x97, 0x5a, 0xfb, 0x1c,
+  0x95, 0x01, 0x93, 0x6b, 0x2b, 0xa5, 0x87, 0x5d, 0xd8, 0xea, 0xb2, 0x24,
+  0x78, 0xb1, 0x58, 0x63, 0x47, 0x86, 0xed, 0xd9, 0xbc, 0xe9, 0xd2, 0xea,
+  0xa8, 0x90, 0x5b, 0xe8, 0x82, 0x89, 0xa2, 0xe2, 0x52, 0x1f, 0x78, 0x00,
+  0x93, 0x64, 0x54, 0xdb, 0x9b, 0x93, 0xc3, 0xee, 0xa2, 0x37, 0xab, 0x2e,
+  0x7e, 0x8f, 0xec, 0xb1, 0x0b, 0x69, 0xad, 0x21, 0xda, 0xa9, 0xaf, 0xd2,
+  0x22, 0x52, 0x2f, 0x1a, 0x6b, 0xb9, 0x21, 0x5e, 0xe9, 0x1a, 0xe1, 0x4c,
+  0x33, 0x26, 0x46, 0xa1, 0xde, 0x52, 0xf3, 0x87, 0xf4, 0x8c, 0x99, 0xe4,
+  0x5d, 0xe7, 0x5b, 0x76, 0x6c, 0xf5, 0xe1, 0xae, 0x5b, 0xaa, 0xbb, 0x3a,
+  0xf4, 0x90, 0xa7, 0x5c, 0x5c, 0x72, 0xab, 0xb8, 0x71, 0xdc, 0x47, 0xb1,
+  0x75, 0x0d, 0xc8, 0xcc, 0xfd, 0xce, 0x62, 0xbe, 0xe5, 0x9f, 0x85, 0x00,
+  0x53, 0x35, 0x91, 0x44, 0x29, 0x5f, 0x64, 0x8d, 0x7c, 0x37, 0x32, 0x28,
+  0x45, 0x9d, 0xa3, 0x49, 0xbb, 0xe3, 0xd3, 0x1e, 0x0a, 0xae, 0x53, 0xbd,
+  0x66, 0x86, 0x8c, 0x4d, 0xa6, 0xd3, 0x85, 0x29, 0x28, 0x31, 0x3a, 0x65,
+  0x33, 0x3a, 0x01, 0x00, 0x01, 0x29, 0x29, 0x29
+};
+static const size_t release_key_pub_len = 560;
+
+struct UpdateManager {
+
+    static void refresh();
+    static void download();
+    static void validate_signature(std::string path, std::string signature_path);
+    static void extract(std::string extract_path, std::string path);
+    static void execute();
+
+private:
+    static constexpr auto url = "https://api.github.com/repos/GrangerHub/tremulous/releases";
+    static constexpr auto package_name = RELEASE_PACKAGE_NAME;
+    static constexpr auto signature_name = RELEASE_SIGNATURE_NAME;
+    static constexpr auto granger_binary_name = GRANGER_EXE;
+};
+
+#define AU_ACT_NIL 0
+#define AU_ACT_GET 1
+#define AU_ACT_RUN 2
+
+void UpdateManager::refresh()
+{
+	auto currentTime = Sys_Milliseconds();
+
+    if ( nextCheckTime > currentTime )
+        return;
+
+    nextCheckTime = currentTime + 10000;
+
+    Cvar_SetValue("ui_autoupdate_action", 0);
+    Cvar_Set("cl_latestDownload", "");
+    Cvar_Set("cl_latestRelease", "");
+    Cvar_Set("cl_latestSignature", "");
+
+    RestClient::Response r = RestClient::get(url);
+    if ( r.code != 200 )
+    {
+        std::string msg { va("Server did not return OK status code: %d", r.code) };
+        
+        Cvar_Set("cl_latestRelease", 
+                S_COLOR_RED "ERROR:\n"
+                S_COLOR_WHITE "Server did not return OK status code");
+
+        return;
+    }
+
+    rapidjson::Document d;
+    d.Parse( r.body.c_str() );
+
+    rapidjson::Value &release = d[0];
+    std::string txt;
+    
+    semver::v2::Version current { PRODUCT_VERSION + 1 };
+    semver::v2::Version latest { release["tag_name"].GetString() + 1 };
+
+    if ( current == latest )
+    {
+        txt += "You are up to date\n\n";
+    }
+    else if ( current < latest )
+    {
+        txt += "A new release is available!\n\n";
+    }
+    else if ( current > latest )
+    { 
+        txt += "Wow! You are ahead of the release.\n\n";
+    }
+    
+    txt += release["tag_name"].GetString();
+    if (release["prerelease"].IsTrue())
+        txt += S_COLOR_YELLOW " (Prerelease)";
+
+    txt += '\n';
+    txt += S_COLOR_CYAN "Released:" S_COLOR_WHITE;
+    txt += release["published_at"].GetString();
+
+    txt += '\n';
+    txt += S_COLOR_RED "Release Notes:\n" S_COLOR_WHITE;
+
+    if (!release["body"].IsNull())
+    {
+        txt += '\n';
+        txt += release["body"].GetString();
+    }
+
+    rapidjson::Value &assets = release["assets"];
+    for ( rapidjson::SizeType i = 0; i < assets.Size(); ++i )
+    {
+        auto &a = assets[i];
+        std::string name = a["name"].GetString();
+
+        if ( name == package_name )
+        {
+            std::string dl = a["browser_download_url"].GetString();
+            Cvar_Set("cl_latestDownload", dl.c_str());
+            Cvar_Set("cl_latestPackage", package_name);
+            Cvar_Set("cl_latestRelease", txt.c_str());
+            Cvar_SetValue("ui_autoupdate_action", AU_ACT_GET);
+        }
+        else if ( name == signature_name )
+        {
+            std::string dl = a["browser_download_url"].GetString();
+            Cvar_Set("cl_latestSignature", dl.c_str());
+        }
+    }
+}
+
+void UpdateManager::extract(std::string extract_path, std::string path)
+{
+    // Extract the release package
+    auto z = unzOpen(path.c_str());
+    assert( z != nullptr );
+
+    unz_global_info zi;
+    unzGetGlobalInfo(z, &zi);
+
+    // Iterate through all files in the package
+    unzGoToFirstFile(z);
+    for (int i = 0; i < zi.number_entry; ++i)
+    {
+        unz_file_info fi;
+        char filename[256] = ""; // 256 == MAX_ZPATH
+        int err;
+        
+        err = unzGetCurrentFileInfo(z, &fi, filename, sizeof(filename),
+                nullptr, 0, nullptr, 0);
+        assert( err == UNZ_OK ); // != OK means corrupt archive
+
+        std::string fn = { filename };
+
+        // FIXME stop doing dumb string stuff
+        std::string fullpath = extract_path;
+        fullpath += PATH_SEP;
+        fullpath += fn;
+        release_package.emplace_back(fn);
+
+        // Bad assumption of a directory?
+        if ( !fi.compressed_size && !fi.uncompressed_size )
+        {
+            Com_DPrintf(S_COLOR_CYAN"ARCHIVED DIR: "
+                        S_COLOR_WHITE"%s\n",
+                        fn.c_str());
+
+            MakeDir(extract_path, fn);
+
+            unzGoToNextFile(z);
+            continue;
+        }
+
+        // Must be a file
+        Com_DPrintf(S_COLOR_CYAN"ARCHIVED FILE: "
+                    S_COLOR_WHITE"%s (%lu/%lu)\n",
+                    filename,
+                    fi.compressed_size,
+                    fi.uncompressed_size);
+
+        if ( fn.rfind(granger_binary_name) != std::string::npos )
+            granger_exe = fn;
+
+        else if ( fn.rfind("main.lua") != std::string::npos )
+            granger_main_lua = fn;
+
+        err = unzOpenCurrentFile(z);
+        assert( err == UNZ_OK );
+
+        // FIXME cleanup all this shit string stuff
+        std::string path = extract_path;
+        path += PATH_SEP;
+        path += fn;
+
+        Com_DPrintf(S_COLOR_YELLOW"Extracted FILE: "
+                    S_COLOR_WHITE"%s\n",
+                    path.c_str());
+
+        std::fstream dl;
+        dl.open(path, fstream::out|ios::binary);
+    
+        // Extract the release package
+        size_t numwrote;
+        do {
+            // Extract 16k at a time
+            unsigned blocksiz = 16384; 
+
+            if ( blocksiz > fi.uncompressed_size - numwrote )
+                blocksiz = fi.uncompressed_size - numwrote;
+
+            uint8_t block[blocksiz];
+            unzReadCurrentFile(z, static_cast<void*>(&block), blocksiz);
+
+            dl.write((const char*)block, blocksiz);
+            numwrote += blocksiz;
+
+        } while ( fi.uncompressed_size > numwrote ); 
+        dl.close();
+
+        unzCloseCurrentFile(z);
+        unzGoToNextFile(z);
+    }
+
+    unzClose(z);
+}
+
+void UpdateManager::download()
+{
+    cvar_t *cl_enableSignatureCheck = Cvar_Get("cl_enableSignatureCheck", "0", CVAR_ARCHIVE | CVAR_PROTECTED);
+
+    // Check for and download signature
+    std::string signature_url = Cvar_VariableString("cl_latestSignature");
+    if ( signature_url.empty() && cl_enableSignatureCheck->integer)
+        throw exception();
+
+    // Download the latest release
+    auto url = Cvar_VariableString("cl_latestDownload");
+    auto r = RestClient::get(url);
+    if ( r.code != 200 )
+        throw exception();
+
+    Com_DPrintf(S_COLOR_CYAN "URL: " S_COLOR_WHITE "%s\n", url);
+
+    // FIXME Cleanup this string bullshit
+    std::string extract_path, signature_path, path { Cvar_VariableString("fs_homepath") };
+    path += PATH_SEP;
+    extract_path = path;
+    signature_path = path + signature_name;
+    path += package_name;
+
+    MakeDir(extract_path, "extract");
+    extract_path += "extract";
+
+    Com_DPrintf(S_COLOR_CYAN"PATH: " S_COLOR_WHITE "%s\n",
+            path.c_str());
+
+    // Write the release package to disk
+    {
+        std::fstream dl;
+        dl.open( path, fstream::out|ios::binary );
+        dl.write( r.body.c_str(), r.body.length() );
+        dl.close();
+    }
+
+    if (cl_enableSignatureCheck->integer)
+    {
+        auto r = RestClient::get(signature_url);
+        if ( r.code != 200 )
+            throw exception();
+
+        std::fstream dl;
+        dl.open( signature_path, fstream::out|ios::binary );
+        dl.write( r.body.c_str(), r.body.length() );
+        dl.close();
+
+        // Validate the signature of the package if enabled
+        UpdateManager::validate_signature(path, signature_path);
+    }
+
+    // Extract the contents of the release package
+    UpdateManager::extract(extract_path, path);
+
+    // Delete the release package
+    unlink(path.c_str());
+
+    Cvar_SetValue("au_autoupdate_action", AU_ACT_RUN);
+}
+
+void UpdateManager::validate_signature(std::string path, std::string signature_path)
+{
+    // Load public key
+    rsa_public_key public_key;
+    rsa_public_key_init(&public_key);
+    rsa_keypair_from_sexp(&public_key, NULL, 0, release_key_pub_len, release_key_pub);
+
+    auto min = [](auto a, auto b) { return a < b ? a : b; };
+
+    // Read in signature
+    mpz_t signature;
+    {
+        std::ifstream f(signature_path, ios::binary);
+        f.seekg (0, f.end);
+        size_t length = f.tellg();
+        f.seekg (0, f.beg);
+
+        std::vector<char> buffer(512, 0);
+        f.read(buffer.data(), min(length, buffer.size()));
+        nettle_mpz_init_set_str_256_u(signature, f.gcount(), (uint8_t *)buffer.data());
+    }
+
+    // Hash file
+    sha256_ctx ctx;
+    sha256_init(&ctx);
+    {
+        std::ifstream f(path, ios::binary);
+        f.seekg (0, f.end);
+        size_t length = f.tellg();
+        f.seekg (0, f.beg);
+
+        std::vector<unsigned char> buffer(16384, 0);
+        while (f.read((char *)buffer.data(), min(length, buffer.size()))) {
+            auto nbytes = f.gcount();
+            sha256_update(&ctx, nbytes, buffer.data());
+            length -= nbytes;
+            if (length <= 0) {
+                break;
+            }
+        }
+    }
+
+    // Verify signature
+    if (!rsa_sha256_verify(&public_key, &ctx, signature)) {
+        rsa_public_key_clear(&public_key);
+        mpz_clear(signature);
+        Com_Error( ERR_DROP, "Update signature was not verified\n" );
+        return;
+    }
+
+    unlink(signature_path.c_str());
+    rsa_public_key_clear(&public_key);
+    mpz_clear(signature);
+}
+
+extern char** environ;
+
+class FailInstaller : public std::exception {
+    std::string msg;
+public:
+    FailInstaller(int e)
+    { msg = strerror(e); }
+
+    virtual const char* what() throw()
+    { return msg.c_str(); }
+};
+
+void UpdateManager::execute()
+{
+    granger_exe = "";
+    granger_main_lua = "";
+
+    if ( granger_exe == "" || granger_main_lua == "" )
+    {
+        for ( auto const& i : release_package )
+        {
+            Com_Printf(S_COLOR_RED " Unlink %s\n", i.c_str());
+            unlink(i.c_str());
+        }
+
+        Com_Error( ERR_DROP, "Missing Granger or GrangerScript\n" );
+        return;
+    }
+
+	std::array<const char*, 4> argv{};
+
+    char* tmp = strdup(granger_exe.c_str());
+    const char* dir = dirname(tmp);
+
+	argv[0] = granger_exe.c_str();
+    argv[1] = va(" -C %s", dir);
+    argv[2] = granger_main_lua.c_str();
+
+    // Dump the details
+	Com_Printf(S_COLOR_YELLOW"Launching "
+               S_COLOR_WHITE"%s %s %s\n",
+               argv[0], argv[1], argv[2]);
+
+#ifndef _WIN32
+    // Fork solely to try cleanup SDL2/GL states
+	auto pid = fork();
+	if (pid == -1)
+		throw FailInstaller(errno);
+
+	if (pid == 0)
+	{
+		execve(argv[0],
+			const_cast<char **>(argv.data()),
+			environ);
+
+		throw FailInstaller(errno);
+	}
+	else
+	{
+		Engine_Exit("");
+	}
+#else
+    // FIXME Dirty exit on Windows...
+	execve(argv[0],
+		const_cast<char **>(argv.data()),
+		environ);
+
+	throw FailInstaller(errno);
+#endif
+}
+
+void CL_GetLatestRelease() { UpdateManager::refresh(); }
+void CL_DownloadRelease() { UpdateManager::download(); }
+void CL_ExecuteInstaller() { UpdateManager::execute(); }
diff --git a/src/client/cl_updates.h b/src/client/cl_updates.h
new file mode 100644
index 0000000..f85c64a
--- /dev/null
+++ b/src/client/cl_updates.h
@@ -0,0 +1,8 @@
+#ifndef CL_UPDATES
+#define CL_UPDATES
+
+void CL_GetLatestRelease();
+void CL_DownloadRelease();
+void CL_ExecuteInstaller();
+
+#endif
diff --git a/src/client/client.h b/src/client/client.h
new file mode 100644
index 0000000..2474a3d
--- /dev/null
+++ b/src/client/client.h
@@ -0,0 +1,716 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+// client.h -- primary header for client
+
+#ifndef _CLIENT_H_
+#define _CLIENT_H_
+
+#ifdef USE_VOIP
+#include <opus.h>
+#endif
+
+#include "cgame/cg_public.h"
+#include "qcommon/alternatePlayerstate.h"
+#include "qcommon/cmd.h"
+#include "qcommon/crypto.h"
+#include "qcommon/cvar.h"
+#include "qcommon/files.h"
+#include "qcommon/huffman.h"
+#include "qcommon/msg.h"
+#include "qcommon/net.h"
+#include "qcommon/q_shared.h"
+#include "qcommon/qcommon.h"
+#include "qcommon/vm.h"
+#include "renderercommon/tr_public.h"
+#include "sys/sys_shared.h"
+#include "ui/ui_public.h"
+
+#include "cl_curl.h"
+#include "keys.h"
+#include "snd_public.h"
+
+struct alternateEntityState_t {
+    int number;  // entity index
+    int eType;  // entityType_t
+    int eFlags;
+
+    trajectory_t pos;  // for calculating position
+    trajectory_t apos;  // for calculating angles
+
+    int time;
+    int time2;
+
+    vec3_t origin;
+    vec3_t origin2;
+
+    vec3_t angles;
+    vec3_t angles2;
+
+    int otherEntityNum;  // shotgun sources, etc
+    int otherEntityNum2;
+
+    int groundEntityNum;  // ENTITYNUM_NONE = in air
+
+    int constantLight;  // r + (g<<8) + (b<<16) + (intensity<<24)
+    int loopSound;  // constantly loop this sound
+
+    int modelindex;
+    int modelindex2;
+    int clientNum;  // 0 to (MAX_CLIENTS - 1), for players and corpses
+    int frame;
+
+    int solid;  // for client side prediction, trap_linkentity sets this properly
+
+    int event;  // impulse events -- muzzle flashes, footsteps, etc
+    int eventParm;
+
+    // for players
+    int misc;  // bit flags
+    int weapon;  // determines weapon and flash model, etc
+    int legsAnim;  // mask off ANIM_TOGGLEBIT
+    int torsoAnim;  // mask off ANIM_TOGGLEBIT
+
+    int generic1;
+};
+
+struct alternateSnapshot_t {
+    int snapFlags;  // SNAPFLAG_RATE_DELAYED, etc
+    int ping;
+
+    int serverTime;  // server time the message is valid for (in msec)
+
+    byte areamask[MAX_MAP_AREA_BYTES];  // portalarea visibility bits
+
+    alternatePlayerState_t ps;  // complete information about the current player at this time
+
+    int numEntities;  // all of the entities that need to be presented
+    alternateEntityState_t entities[MAX_ENTITIES_IN_SNAPSHOT];  // at the time of this snapshot
+
+    int numServerCommands;  // text based server commands to execute when this
+    int serverCommandSequence;  // snapshot becomes current
+};
+
+// file full of random crap that gets used to create cl_guid
+#define QKEY_FILE "qkey"
+#define QKEY_SIZE 2048
+
+#define RETRANSMIT_TIMEOUT 3000  // time between connection packet retransmits
+
+// snapshots are a view of the server at a given time
+struct clSnapshot_t {
+    bool valid;  // cleared if delta parsing was invalid
+    int snapFlags;  // rate delayed and dropped commands
+
+    int serverTime;  // server time the message is valid for (in msec)
+
+    int messageNum;  // copied from netchan->incoming_sequence
+    int deltaNum;  // messageNum the delta is from
+    int ping;  // time from when cmdNum-1 was sent to time packet was reeceived
+    byte areamask[MAX_MAP_AREA_BYTES];  // portalarea visibility bits
+
+    int cmdNum;  // the next cmdNum the server is expecting
+    playerState_t ps;  // complete information about the current player at this time
+    alternatePlayerState_t alternatePs;  // complete information about the current player at this time
+
+    int numEntities;  // all of the entities that need to be presented
+    int parseEntitiesNum;  // at the time of this snapshot
+
+    int serverCommandNum;  // execute all commands up to this before
+    // making the snapshot current
+};
+
+/*
+=============================================================================
+
+the clientActive_t structure is wiped completely at every
+new gamestate_t, potentially several times during an established connection
+
+=============================================================================
+*/
+
+struct outPacket_t {
+    int p_cmdNumber;  // cl.cmdNumber when packet was sent
+    int p_serverTime;  // usercmd->serverTime when packet was sent
+    int p_realtime;  // cls.realtime when packet was sent
+};
+
+// the parseEntities array must be large enough to hold PACKET_BACKUP frames of
+// entities, so that when a delta compressed message arives from the server
+// it can be un-deltad from the original
+#define MAX_PARSE_ENTITIES (PACKET_BACKUP * MAX_SNAPSHOT_ENTITIES)
+
+extern int g_console_field_width;
+
+struct clientActive_t {
+    int timeoutcount;  // it requres several frames in a timeout condition
+    // to disconnect, preventing debugging breaks from
+    // causing immediate disconnects on continue
+    clSnapshot_t snap;  // latest received from server
+
+    int serverTime;  // may be paused during play
+    int oldServerTime;  // to prevent time from flowing bakcwards
+    int oldFrameServerTime;  // to check tournament restarts
+    int serverTimeDelta;  // cl.serverTime = cls.realtime + cl.serverTimeDelta
+    // this value changes as net lag varies
+    bool extrapolatedSnapshot;  // set if any cgame frame has been forced to extrapolate
+    // cleared when CL_AdjustTimeDelta looks at it
+    bool newSnapshots;  // set on parse of any valid packet
+
+    gameState_t gameState;  // configstrings
+    char mapname[MAX_QPATH];  // extracted from CS_SERVERINFO
+
+    int parseEntitiesNum;  // index (not anded off) into cl_parse_entities[]
+
+    int mouseDx[2], mouseDy[2];  // added to by mouse events
+    int mouseIndex;
+    int joystickAxis[MAX_JOYSTICK_AXIS];  // set by joystick events
+
+    // cgame communicates a few values to the client system
+    int cgameUserCmdValue;  // current weapon to add to usercmd_t
+    float cgameSensitivity;
+
+    // cmds[cmdNumber] is the predicted command, [cmdNumber-1] is the last
+    // properly generated command
+    usercmd_t cmds[CMD_BACKUP];  // each mesage will send several old cmds
+    int cmdNumber;  // incremented each frame, because multiple
+    // frames may need to be packed into a single packet
+
+    outPacket_t outPackets[PACKET_BACKUP];  // information about each packet we have sent out
+
+    // the client maintains its own idea of view angles, which are
+    // sent to the server each frame.  It is cleared to 0 upon entering each level.
+    // the server sends a delta each frame which is added to the locally
+    // tracked view angles to account for standing on rotating objects,
+    // and teleport direction changes
+    vec3_t viewangles;
+
+    int serverId;  // included in each client message so the server
+    // can tell if it is for a prior map_restart
+    // big stuff at end of structure so most offsets are 15 bits or less
+    clSnapshot_t snapshots[PACKET_BACKUP];
+
+    entityState_t entityBaselines[MAX_GENTITIES];  // for delta compression when not in previous frame
+
+    entityState_t parseEntities[MAX_PARSE_ENTITIES];
+};
+
+extern clientActive_t cl;
+
+/*
+=============================================================================
+
+the clientConnection_t structure is wiped when disconnecting from a server,
+either to go to a full screen console, play a demo, or connect to a different server
+
+A connection can be to either a server through the network layer or a
+demo through a file.
+
+=============================================================================
+*/
+
+#define MAX_TIMEDEMO_DURATIONS 4096
+
+struct clientConnection_t {
+    connstate_t state;  // connection status
+
+    int clientNum;
+    int lastPacketSentTime;  // for retransmits during connection
+    int lastPacketTime;  // for timeouts
+
+    char servername[MAX_OSPATH];  // name of server from original connect (used by reconnect)
+    netadr_t serverAddress;
+    int connectTime;  // for connection retransmits
+    int connectPacketCount;  // for display on connection dialog
+    char serverMessage[MAX_STRING_TOKENS];  // for display on connection dialog
+
+    int challenge;  // from the server to use for connecting
+    char challenge2[33];
+    bool sendSignature;
+    int checksumFeed;  // from the server for checksum calculations
+
+    // these are our reliable messages that go to the server
+    int reliableSequence;
+    int reliableAcknowledge;  // the last one the server has executed
+    char reliableCommands[MAX_RELIABLE_COMMANDS][MAX_STRING_CHARS];
+
+    // server message (unreliable) and command (reliable) sequence
+    // numbers are NOT cleared at level changes, but continue to
+    // increase as long as the connection is valid
+
+    // message sequence is used by both the network layer and the
+    // delta compression layer
+    int serverMessageSequence;
+
+    // reliable messages received from server
+    int serverCommandSequence;
+    int lastExecutedServerCommand;  // last server command grabbed or executed with CL_GetServerCommand
+    char serverCommands[MAX_RELIABLE_COMMANDS][MAX_STRING_CHARS];
+
+    // file transfer from server
+    fileHandle_t download;
+    char downloadTempName[MAX_OSPATH];
+    char downloadName[MAX_OSPATH];
+
+    // XXX Refactor this -vjr
+    bool cURLEnabled;
+    bool cURLUsed;
+    bool cURLDisconnected;
+
+    char downloadURL[MAX_OSPATH];
+    CURL *downloadCURL;
+    CURLM *downloadCURLM;
+    bool activeCURLNotGameRelated;
+
+    int sv_allowDownload;
+    char sv_dlURL[MAX_CVAR_VALUE_STRING];
+    int downloadNumber;
+    int downloadBlock;  // block we are waiting for
+    int downloadCount;  // how many bytes we got
+    int downloadSize;  // how many bytes we got
+    char downloadList[MAX_INFO_STRING];  // list of paks we need to download
+    bool downloadRestart;  // if true, we need to do another FS_Restart because we downloaded a pak
+    char newsString[MAX_NEWS_STRING];
+
+    // demo information
+    char demoName[MAX_QPATH];
+    bool spDemoRecording;
+    bool demorecording;
+    bool demoplaying;
+    bool demowaiting;  // don't record until a non-delta message is received
+    bool firstDemoFrameSkipped;
+    fileHandle_t demofile;
+
+    int timeDemoFrames;  // counter of rendered frames
+    int timeDemoStart;  // cls.realtime before first frame
+    int timeDemoBaseTime;  // each frame will be at this time + frameNum * 50
+    int timeDemoLastFrame;  // time the last frame was rendered
+    int timeDemoMinDuration;  // minimum frame duration
+    int timeDemoMaxDuration;  // maximum frame duration
+    unsigned char timeDemoDurations[MAX_TIMEDEMO_DURATIONS];  // log of frame durations
+
+    float aviVideoFrameRemainder;
+    float aviSoundFrameRemainder;
+
+#ifdef USE_VOIP
+    bool voipEnabled;
+    bool voipCodecInitialized;
+
+    // incoming data...
+    // !!! FIXME: convert from parallel arrays to array of a struct.
+    OpusDecoder *opusDecoder[MAX_CLIENTS];
+    byte voipIncomingGeneration[MAX_CLIENTS];
+    int voipIncomingSequence[MAX_CLIENTS];
+    float voipGain[MAX_CLIENTS];
+    bool voipIgnore[MAX_CLIENTS];
+    bool voipMuteAll;
+
+    // outgoing data...
+    // if voipTargets[i / 8] & (1 << (i % 8)),
+    // then we are sending to clientnum i.
+    uint8_t voipTargets[(MAX_CLIENTS + 7) / 8];
+    uint8_t voipFlags;
+    OpusEncoder *opusEncoder;
+    int voipOutgoingDataSize;
+    int voipOutgoingDataFrames;
+    int voipOutgoingSequence;
+    byte voipOutgoingGeneration;
+    byte voipOutgoingData[1024];
+    float voipPower;
+#endif
+
+    // big stuff at end of structure so most offsets are 15 bits or less
+    netchan_t netchan;
+};
+
+extern clientConnection_t clc;
+
+/*
+==================================================================
+
+the clientStatic_t structure is never wiped, and is used even when
+no client connection is active at all
+(except when CL_Shutdown is called)
+
+==================================================================
+*/
+
+struct ping_t {
+    netadr_t adr;
+    int start;
+    int time;
+    char info[MAX_INFO_STRING];
+};
+
+#define MAX_FEATLABEL_CHARS 32
+struct serverInfo_t {
+    netadr_t adr;
+    char hostName[MAX_HOSTNAME_LENGTH];
+    char mapName[MAX_NAME_LENGTH];
+    char game[MAX_NAME_LENGTH];
+    char label[MAX_FEATLABEL_CHARS];  // for featured servers, NULL otherwise
+    int netType;
+    int gameType;
+    int clients;
+    int maxClients;
+    int minPing;
+    int maxPing;
+    int ping;
+    bool visible;
+};
+
+struct clientStatic_t {
+    // when the server clears the hunk, all of these must be restarted
+    bool rendererStarted;
+    bool soundStarted;
+    bool soundRegistered;
+    bool uiStarted;
+    bool cgameStarted;
+
+    int framecount;
+    int frametime;  // msec since last frame
+
+    int realtime;  // ignores pause
+    int realFrametime;  // ignoring pause, so console always works
+
+    // master server sequence information
+    int numAlternateMasterPackets[3];
+    unsigned int receivedAlternateMasterPackets[3];  // bitfield
+
+    int numlocalservers;
+    serverInfo_t localServers[MAX_OTHER_SERVERS];
+
+    int numglobalservers;
+    serverInfo_t globalServers[MAX_GLOBAL_SERVERS];
+    // additional global servers
+    int numGlobalServerAddresses;
+    netadr_t globalServerAddresses[MAX_GLOBAL_SERVERS];
+
+    int numfavoriteservers;
+    serverInfo_t favoriteServers[MAX_OTHER_SERVERS];
+
+    int pingUpdateSource;  // source currently pinging or updating
+
+    // update server info
+    netadr_t updateServer;
+    char updateChallenge[MAX_TOKEN_CHARS];
+    char updateInfoString[MAX_INFO_STRING];
+
+    netadr_t authorizeServer;
+
+    // rendering info
+    glconfig_t glconfig;
+    qhandle_t charSetShader;
+    qhandle_t whiteShader;
+    qhandle_t consoleShader;
+
+    vm_t *cgame;
+    int cgInterface; // 0 == gpp, 2 == 1.1.0
+
+    vm_t *ui;
+    int uiInterface;
+
+    struct {
+        struct rsa_public_key public_key;
+        struct rsa_private_key private_key;
+    } rsa;
+};
+
+extern clientStatic_t cls;
+
+extern char cl_oldGame[MAX_QPATH];
+extern bool cl_oldGameSet;
+
+//=============================================================================
+
+extern refexport_t re;  // interface to refresh .dll
+
+//
+// cvars
+//
+extern cvar_t *cl_nodelta;
+extern cvar_t *cl_debugMove;
+extern cvar_t *cl_noprint;
+extern cvar_t *cl_timegraph;
+extern cvar_t *cl_maxpackets;
+extern cvar_t *cl_packetdup;
+extern cvar_t *cl_shownet;
+extern cvar_t *cl_showSend;
+extern cvar_t *cl_timeNudge;
+extern cvar_t *cl_showTimeDelta;
+extern cvar_t *cl_freezeDemo;
+
+extern cvar_t *cl_yawspeed;
+extern cvar_t *cl_pitchspeed;
+extern cvar_t *cl_run;
+extern cvar_t *cl_anglespeedkey;
+
+extern cvar_t *cl_sensitivity;
+extern cvar_t *cl_freelook;
+
+extern cvar_t *cl_mouseAccel;
+extern cvar_t *cl_mouseAccelOffset;
+extern cvar_t *cl_mouseAccelStyle;
+extern cvar_t *cl_showMouseRate;
+
+extern cvar_t *m_pitch;
+extern cvar_t *m_yaw;
+extern cvar_t *m_forward;
+extern cvar_t *m_side;
+extern cvar_t *m_filter;
+
+extern cvar_t *j_pitch;
+extern cvar_t *j_yaw;
+extern cvar_t *j_forward;
+extern cvar_t *j_side;
+extern cvar_t *j_up;
+extern cvar_t *j_pitch_axis;
+extern cvar_t *j_yaw_axis;
+extern cvar_t *j_forward_axis;
+extern cvar_t *j_side_axis;
+extern cvar_t *j_up_axis;
+
+extern cvar_t *cl_timedemo;
+extern cvar_t *cl_aviFrameRate;
+extern cvar_t *cl_aviMotionJpeg;
+
+extern cvar_t *cl_activeAction;
+
+extern cvar_t *cl_allowDownload;
+extern cvar_t *cl_downloadMethod;
+extern cvar_t *cl_conXOffset;
+extern cvar_t *cl_inGameVideo;
+
+extern cvar_t *cl_lanForcePackets;
+extern cvar_t *cl_autoRecordDemo;
+
+extern cvar_t *cl_clantag;
+
+extern cvar_t *cl_consoleKeys;
+
+#ifdef USE_MUMBLE
+extern cvar_t *cl_useMumble;
+extern cvar_t *cl_mumbleScale;
+#endif
+
+#ifdef USE_VOIP
+// cl_voipSendTarget is a string: "all" to broadcast to everyone, "none" to
+//  send to no one, or a comma-separated list of client numbers:
+//  "0,7,2,23" ... an empty string is treated like "all".
+extern cvar_t *cl_voipUseVAD;
+extern cvar_t *cl_voipVADThreshold;
+extern cvar_t *cl_voipSend;
+extern cvar_t *cl_voipSendTarget;
+extern cvar_t *cl_voipGainDuringCapture;
+extern cvar_t *cl_voipCaptureMult;
+extern cvar_t *cl_voipShowMeter;
+extern cvar_t *cl_voip;
+
+// 20ms at 48k
+#define VOIP_MAX_FRAME_SAMPLES (20 * 48)
+
+// 3 frame is 60ms of audio, the max opus will encode at once
+#define VOIP_MAX_PACKET_FRAMES 3
+#define VOIP_MAX_PACKET_SAMPLES (VOIP_MAX_FRAME_SAMPLES * VOIP_MAX_PACKET_FRAMES)
+#endif
+
+extern cvar_t *cl_rsaAuth;
+
+//=================================================
+
+//
+// cl_main
+//
+
+void CL_Init(void);
+void CL_AddReliableCommand(const char *cmd, bool isDisconnectCmd);
+
+void CL_StartHunkUsers(bool rendererOnly);
+
+void CL_Disconnect_f(void);
+void CL_NextDemo(void);
+void CL_ReadDemoMessage(void);
+demoState_t CL_DemoState(void);
+int CL_DemoPos(void);
+void CL_DemoName(char *buffer, int size);
+void CL_StopRecord_f(void);
+
+void CL_InitDownloads(void);
+void CL_NextDownload(void);
+
+void CL_GetPing(int n, char *buf, int buflen, int *pingtime);
+void CL_GetPingInfo(int n, char *buf, int buflen);
+void CL_ClearPing(int n);
+int CL_GetPingQueueCount(void);
+
+bool CL_ServerStatus(char *serverAddress, char *serverStatusString, int maxLen);
+
+bool CL_CheckPaused(void);
+
+//
+// cl_input
+//
+typedef struct {
+    int down[2];  // key nums holding it down
+    unsigned downtime;  // msec timestamp
+    unsigned msec;  // msec down this frame if both a down and up happened
+    bool active;  // current state
+    bool wasPressed;  // set when down, not cleared when up
+} kbutton_t;
+
+void CL_InitInput(void);
+void CL_ShutdownInput(void);
+void CL_SendCmd(void);
+void CL_ClearState(void);
+void CL_ReadPackets(void);
+
+void CL_WritePacket(void);
+//void IN_CenterView(void);
+
+int Key_StringToKeynum(const char *str);
+const char *Key_KeynumToString(int keynum);
+
+//
+// cl_parse.c
+//
+extern bool cl_connectedToPureServer;
+extern bool cl_connectedToCheatServer;
+
+#ifdef USE_VOIP
+void CL_Voip_f(void);
+#endif
+
+void CL_SystemInfoChanged(void);
+void CL_ParseServerMessage(msg_t *msg);
+
+//====================================================================
+
+bool CL_UpdateVisiblePings_f(int source);
+
+//
+// console
+//
+void Con_DrawCharacter(int cx, int line, int num);
+
+void Con_CheckResize(void);
+void Con_MessageModesInit(void);
+void CL_ProtocolSpecificCommandsInit(void);
+void Con_Init(void);
+void Con_Shutdown(void);
+void Con_Clear_f(void);
+void Con_ToggleConsole_f(void);
+void Con_ClearNotify(void);
+void Con_RunConsole(void);
+void Con_DrawConsole(void);
+void Con_PageUp(void);
+void Con_PageDown(void);
+void Con_Top(void);
+void Con_Bottom(void);
+void Con_Close(void);
+
+void CL_LoadConsoleHistory(void);
+void CL_SaveConsoleHistory(void);
+
+//
+// cl_scrn.c
+//
+void SCR_Init(void);
+void SCR_UpdateScreen(void);
+
+void SCR_DebugGraph(float value);
+
+int SCR_GetBigStringWidth(const char *str);  // returns in virtual 640x480 coordinates
+
+void SCR_AdjustFrom640(float *x, float *y, float *w, float *h);
+void SCR_FillRect(float x, float y, float width, float height, const float *color);
+void SCR_DrawPic(float x, float y, float width, float height, qhandle_t hShader);
+void SCR_DrawNamedPic(float x, float y, float width, float height, const char *picname);
+
+void SCR_DrawBigString(int x, int y, const char *s, float alpha,
+    bool noColorEscape);  // draws a string with embedded color control characters with fade
+void SCR_DrawBigStringColor(
+    int x, int y, const char *s, vec4_t color, bool noColorEscape);  // ignores embedded color control characters
+void SCR_DrawSmallStringExt(int x, int y, const char *string, float *setColor, bool forceColor, bool noColorEscape);
+void SCR_DrawSmallChar(int x, int y, int ch);
+
+//
+// cl_cin.c
+//
+
+void CL_PlayCinematic_f(void);
+void SCR_DrawCinematic(void);
+void SCR_RunCinematic(void);
+void SCR_StopCinematic(void);
+int CIN_PlayCinematic(const char *arg0, int xpos, int ypos, int width, int height, int bits);
+e_status CIN_StopCinematic(int handle);
+e_status CIN_RunCinematic(int handle);
+void CIN_DrawCinematic(int handle);
+void CIN_SetExtents(int handle, int x, int y, int w, int h);
+void CIN_UploadCinematic(int handle);
+void CIN_CloseAllVideos(void);
+
+//
+// cl_cgame.c
+//
+void CL_InitCGame(void);
+void CL_ShutdownCGame(void);
+bool CL_GameCommand(void);
+void CL_GameConsoleText(void);
+void CL_CGameRendering(stereoFrame_t stereo);
+void CL_SetCGameTime(void);
+void CL_FirstSnapshot(void);
+void CL_ShaderStateChanged(void);
+
+//
+// cl_ui.c
+//
+void CL_InitUI(void);
+void CL_ShutdownUI(void);
+int Key_GetCatcher(void);
+void Key_SetCatcher(int catcher);
+void LAN_LoadCachedServers(void);
+void LAN_SaveServersToCache(void);
+
+//
+// cl_net_chan.c
+//
+void CL_Netchan_Transmit(netchan_t *chan, msg_t *msg);  // int length, const byte *data );
+bool CL_Netchan_Process(netchan_t *chan, msg_t *msg);
+
+//
+// cl_avi.c
+//
+bool CL_OpenAVIForWriting(const char *filename);
+void CL_TakeVideoFrame(void);
+void CL_WriteAVIVideoFrame(const byte *imageBuffer, int size);
+void CL_WriteAVIAudioFrame(const byte *pcmBuffer, int size);
+bool CL_CloseAVI(void);
+bool CL_VideoRecording(void);
+
+//
+// cl_main.c
+//
+void CL_WriteDemoMessage(msg_t *msg, int headerBytes);
+int CL_ScaledMilliseconds(void);
+
+#endif
diff --git a/src/client/keycodes.h b/src/client/keycodes.h
index ae6f189..3b2958d 100644
--- a/src/client/keycodes.h
+++ b/src/client/keycodes.h
@@ -1,13 +1,14 @@
 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
-Copyright (C) 2000-2006 Tim Angus
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
 
 This file is part of Tremulous.
 
 Tremulous is free software; you can redistribute it
 and/or modify it under the terms of the GNU General Public License as
-published by the Free Software Foundation; either version 2 of the License,
+published by the Free Software Foundation; either version 3 of the License,
 or (at your option) any later version.
 
 Tremulous is distributed in the hope that it will be
@@ -16,8 +17,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with Tremulous; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
 ===========================================================================
 */
 //
@@ -262,6 +263,39 @@ typedef enum {
 	K_EURO,
 	K_UNDO,
 
+	// Gamepad controls
+	// Ordered to match SDL2 game controller buttons and axes
+	// Do not change this order without also changing IN_GamepadMove() in SDL_input.c
+	K_PAD0_A,
+	K_PAD0_B,
+	K_PAD0_X,
+	K_PAD0_Y,
+	K_PAD0_BACK,
+	K_PAD0_GUIDE,
+	K_PAD0_START,
+	K_PAD0_LEFTSTICK_CLICK,
+	K_PAD0_RIGHTSTICK_CLICK,
+	K_PAD0_LEFTSHOULDER,
+	K_PAD0_RIGHTSHOULDER,
+	K_PAD0_DPAD_UP,
+	K_PAD0_DPAD_DOWN,
+	K_PAD0_DPAD_LEFT,
+	K_PAD0_DPAD_RIGHT,
+
+	K_PAD0_LEFTSTICK_LEFT,
+	K_PAD0_LEFTSTICK_RIGHT,
+	K_PAD0_LEFTSTICK_UP,
+	K_PAD0_LEFTSTICK_DOWN,
+	K_PAD0_RIGHTSTICK_LEFT,
+	K_PAD0_RIGHTSTICK_RIGHT,
+	K_PAD0_RIGHTSTICK_UP,
+	K_PAD0_RIGHTSTICK_DOWN,
+	K_PAD0_LEFTTRIGGER,
+	K_PAD0_RIGHTTRIGGER,
+
+	// Pseudo-key that brings the console down
+	K_CONSOLE,
+
 	MAX_KEYS
 } keyNum_t;
 
diff --git a/src/client/keys.h b/src/client/keys.h
new file mode 100644
index 0000000..5c8877f
--- /dev/null
+++ b/src/client/keys.h
@@ -0,0 +1,66 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+#ifndef _KEYS_H_
+#define _KEYS_H_
+
+#include "keycodes.h"
+
+typedef struct {
+    bool down;
+    int repeats;  // if > 1, it is autorepeating
+    char *binding;
+} qkey_t;
+
+extern bool key_overstrikeMode;
+extern qkey_t keys[MAX_KEYS];
+
+// NOTE TTimo the declaration of field_t and Field_Clear is now in qcommon/qcommon.h
+void Field_KeyDownEvent(field_t *edit, int key);
+void Field_CharEvent(field_t *edit, int ch);
+void Field_Draw(field_t *edit, int x, int y, int width, bool showCursor, bool noColorEscape);
+void Field_BigDraw(field_t *edit, int x, int y, int width, bool showCursor, bool noColorEscape);
+
+#define COMMAND_HISTORY 32
+extern field_t historyEditLines[COMMAND_HISTORY];
+
+extern field_t g_consoleField;
+extern field_t chatField;
+extern int anykeydown;
+extern bool chat_team;
+extern bool chat_admins;
+extern bool chat_clans;
+extern int chat_playerNum;
+
+void Key_WriteBindings(fileHandle_t f);
+void Key_SetBinding(int keynum, const char *binding);
+const char *Key_GetBinding(int keynum);
+bool Key_IsDown(int keynum);
+bool Key_GetOverstrikeMode(void);
+void Key_SetOverstrikeMode(bool state);
+void Key_ClearStates(void);
+int Key_GetKey(const char *binding);
+void Key_KeynumToStringBuf(int keynum, char *buf, int buflen);
+void Key_GetBindingBuf(int keynum, char *buf, int buflen);
+
+#endif
diff --git a/src/client/libmumblelink.cpp b/src/client/libmumblelink.cpp
new file mode 100644
index 0000000..59d59d3
--- /dev/null
+++ b/src/client/libmumblelink.cpp
@@ -0,0 +1,190 @@
+/* libmumblelink.c -- mumble link interface
+
+  Copyright (C) 2008 Ludwig Nussel <ludwig.nussel@suse.de>
+  Copyright (C) 2000-2013 Darklegion Development
+	Copyright (C) 2015-2019 GrangerHub
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+*/
+
+#include "libmumblelink.h"
+
+#include <fcntl.h>
+#ifdef _WIN32
+#include <windows.h>
+#define uint32_t UINT32
+#else
+#include <unistd.h>
+#ifdef __sun
+#define _POSIX_C_SOURCE 199309L
+#endif
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#endif
+
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#ifndef MIN
+#define MIN(a, b) ((a)<(b)?(a):(b))
+#endif
+
+typedef struct
+{
+	uint32_t uiVersion;
+	uint32_t uiTick;
+	float   fAvatarPosition[3];
+	float   fAvatarFront[3];
+	float   fAvatarTop[3];
+	wchar_t name[256];
+	/* new in mumble 1.2 */
+	float   fCameraPosition[3];
+	float   fCameraFront[3];
+	float   fCameraTop[3];
+	wchar_t identity[256];
+	uint32_t context_len;
+	unsigned char context[256];
+	wchar_t description[2048];
+} LinkedMem;
+
+static LinkedMem *lm = NULL;
+
+#ifdef WIN32
+static HANDLE hMapObject = NULL;
+#else
+static int32_t GetTickCount(void)
+{
+	struct timeval tv;
+	gettimeofday(&tv,NULL);
+
+	return tv.tv_usec / 1000 + tv.tv_sec * 1000;
+}
+#endif
+
+int mumble_link(const char* name)
+{
+#ifdef WIN32
+	if(lm)
+		return 0;
+
+	hMapObject = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, L"MumbleLink");
+	if (hMapObject == NULL)
+		return -1;
+
+	lm = (LinkedMem *) MapViewOfFile(hMapObject, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(LinkedMem));
+	if (lm == NULL) {
+		CloseHandle(hMapObject);
+		hMapObject = NULL;
+		return -1;
+	}
+#else
+	char file[256];
+	int shmfd;
+	if(lm)
+		return 0;
+
+	snprintf(file, sizeof (file), "/MumbleLink.%d", getuid());
+	shmfd = shm_open(file, O_RDWR, S_IRUSR | S_IWUSR);
+	if(shmfd < 0) {
+		return -1;
+	}
+
+	lm = (LinkedMem *) (mmap(NULL, sizeof(LinkedMem), PROT_READ | PROT_WRITE, MAP_SHARED, shmfd,0));
+	if (lm == (void *) (-1)) {
+		lm = NULL;
+		close(shmfd);
+		return -1;
+	}
+	close(shmfd);
+#endif
+	memset(lm, 0, sizeof(LinkedMem));
+	mbstowcs(lm->name, name, sizeof(lm->name) / sizeof(wchar_t));
+
+	return 0;
+}
+
+void mumble_update_coordinates(float fPosition[3], float fFront[3], float fTop[3])
+{
+	mumble_update_coordinates2(fPosition, fFront, fTop, fPosition, fFront, fTop);
+}
+
+void mumble_update_coordinates2(float fAvatarPosition[3], float fAvatarFront[3], float fAvatarTop[3],
+		float fCameraPosition[3], float fCameraFront[3], float fCameraTop[3])
+{
+	if (!lm)
+		return;
+
+	memcpy(lm->fAvatarPosition, fAvatarPosition, sizeof(lm->fAvatarPosition));
+	memcpy(lm->fAvatarFront, fAvatarFront, sizeof(lm->fAvatarFront));
+	memcpy(lm->fAvatarTop, fAvatarTop, sizeof(lm->fAvatarTop));
+	memcpy(lm->fCameraPosition, fCameraPosition, sizeof(lm->fCameraPosition));
+	memcpy(lm->fCameraFront, fCameraFront, sizeof(lm->fCameraFront));
+	memcpy(lm->fCameraTop, fCameraTop, sizeof(lm->fCameraTop));
+	lm->uiVersion = 2;
+	lm->uiTick = GetTickCount();
+}
+
+void mumble_set_identity(const char* identity)
+{
+	size_t len;
+	if (!lm)
+		return;
+	len = MIN(sizeof(lm->identity)/sizeof(wchar_t), strlen(identity)+1);
+	mbstowcs(lm->identity, identity, len);
+}
+
+void mumble_set_context(const unsigned char* context, size_t len)
+{
+	if (!lm)
+		return;
+	len = MIN(sizeof(lm->context), len);
+	lm->context_len = len;
+	memcpy(lm->context, context, len);
+}
+
+void mumble_set_description(const char* description)
+{
+	size_t len;
+	if (!lm)
+		return;
+	len = MIN(sizeof(lm->description)/sizeof(wchar_t), strlen(description)+1);
+	mbstowcs(lm->description, description, len);
+}
+
+void mumble_unlink()
+{
+	if(!lm)
+		return;
+#ifdef WIN32
+	UnmapViewOfFile(lm);
+	CloseHandle(hMapObject);
+	hMapObject = NULL;
+#else
+	munmap(lm, sizeof(LinkedMem));
+#endif
+	lm = NULL;
+}
+
+int mumble_islinked(void)
+{
+	return lm != NULL;
+}
diff --git a/src/client/libmumblelink.h b/src/client/libmumblelink.h
new file mode 100644
index 0000000..aa8e2ce
--- /dev/null
+++ b/src/client/libmumblelink.h
@@ -0,0 +1,41 @@
+/* libmumblelink.h -- mumble link interface
+
+  Copyright (C) 2008 Ludwig Nussel <ludwig.nussel@suse.de>
+  Copyright (C) 2000-2013 Darklegion Development
+	Copyright (C) 2015-2019 GrangerHub
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+*/
+#ifndef _LIBMUMBLELINK_H_
+#define _LIBMUMBLELINK_H_
+
+int mumble_link(const char* name);
+int mumble_islinked(void);
+void mumble_update_coordinates(float fPosition[3], float fFront[3], float fTop[3]);
+
+/* new for mumble 1.2: also set camera position */
+void mumble_update_coordinates2(float fAvatarPosition[3], float fAvatarFront[3], float fAvatarTop[3],
+		float fCameraPosition[3], float fCameraFront[3], float fCameraTop[3]);
+
+void mumble_set_description(const char* description);
+void mumble_set_context(const unsigned char* context, size_t len);
+void mumble_set_identity(const char* identity);
+
+void mumble_unlink(void);
+
+#endif // _LIBMUMBLELINK_H_
diff --git a/src/client/qal.cpp b/src/client/qal.cpp
new file mode 100644
index 0000000..466a45e
--- /dev/null
+++ b/src/client/qal.cpp
@@ -0,0 +1,337 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2005 Stuart Dalton (badcdev@gmail.com)
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+// Dynamically loads OpenAL
+
+#ifdef USE_OPENAL
+
+#include "qal.h"
+
+#ifdef USE_OPENAL_DLOPEN
+#include "sys/sys_loadlib.h"
+
+LPALENABLE qalEnable;
+LPALDISABLE qalDisable;
+LPALISENABLED qalIsEnabled;
+LPALGETSTRING qalGetString;
+LPALGETBOOLEANV qalGetBooleanv;
+LPALGETINTEGERV qalGetIntegerv;
+LPALGETFLOATV qalGetFloatv;
+LPALGETDOUBLEV qalGetDoublev;
+LPALGETBOOLEAN qalGetBoolean;
+LPALGETINTEGER qalGetInteger;
+LPALGETFLOAT qalGetFloat;
+LPALGETDOUBLE qalGetDouble;
+LPALGETERROR qalGetError;
+LPALISEXTENSIONPRESENT qalIsExtensionPresent;
+LPALGETPROCADDRESS qalGetProcAddress;
+LPALGETENUMVALUE qalGetEnumValue;
+LPALLISTENERF qalListenerf;
+LPALLISTENER3F qalListener3f;
+LPALLISTENERFV qalListenerfv;
+LPALLISTENERI qalListeneri;
+LPALGETLISTENERF qalGetListenerf;
+LPALGETLISTENER3F qalGetListener3f;
+LPALGETLISTENERFV qalGetListenerfv;
+LPALGETLISTENERI qalGetListeneri;
+LPALGENSOURCES qalGenSources;
+LPALDELETESOURCES qalDeleteSources;
+LPALISSOURCE qalIsSource;
+LPALSOURCEF qalSourcef;
+LPALSOURCE3F qalSource3f;
+LPALSOURCEFV qalSourcefv;
+LPALSOURCEI qalSourcei;
+LPALGETSOURCEF qalGetSourcef;
+LPALGETSOURCE3F qalGetSource3f;
+LPALGETSOURCEFV qalGetSourcefv;
+LPALGETSOURCEI qalGetSourcei;
+LPALSOURCEPLAYV qalSourcePlayv;
+LPALSOURCESTOPV qalSourceStopv;
+LPALSOURCEREWINDV qalSourceRewindv;
+LPALSOURCEPAUSEV qalSourcePausev;
+LPALSOURCEPLAY qalSourcePlay;
+LPALSOURCESTOP qalSourceStop;
+LPALSOURCEREWIND qalSourceRewind;
+LPALSOURCEPAUSE qalSourcePause;
+LPALSOURCEQUEUEBUFFERS qalSourceQueueBuffers;
+LPALSOURCEUNQUEUEBUFFERS qalSourceUnqueueBuffers;
+LPALGENBUFFERS qalGenBuffers;
+LPALDELETEBUFFERS qalDeleteBuffers;
+LPALISBUFFER qalIsBuffer;
+LPALBUFFERDATA qalBufferData;
+LPALGETBUFFERF qalGetBufferf;
+LPALGETBUFFERI qalGetBufferi;
+LPALDOPPLERFACTOR qalDopplerFactor;
+LPALSPEEDOFSOUND qalSpeedOfSound;
+LPALDISTANCEMODEL qalDistanceModel;
+
+LPALCCREATECONTEXT qalcCreateContext;
+LPALCMAKECONTEXTCURRENT qalcMakeContextCurrent;
+LPALCPROCESSCONTEXT qalcProcessContext;
+LPALCSUSPENDCONTEXT qalcSuspendContext;
+LPALCDESTROYCONTEXT qalcDestroyContext;
+LPALCGETCURRENTCONTEXT qalcGetCurrentContext;
+LPALCGETCONTEXTSDEVICE qalcGetContextsDevice;
+LPALCOPENDEVICE qalcOpenDevice;
+LPALCCLOSEDEVICE qalcCloseDevice;
+LPALCGETERROR qalcGetError;
+LPALCISEXTENSIONPRESENT qalcIsExtensionPresent;
+LPALCGETPROCADDRESS qalcGetProcAddress;
+LPALCGETENUMVALUE qalcGetEnumValue;
+LPALCGETSTRING qalcGetString;
+LPALCGETINTEGERV qalcGetIntegerv;
+LPALCCAPTUREOPENDEVICE qalcCaptureOpenDevice;
+LPALCCAPTURECLOSEDEVICE qalcCaptureCloseDevice;
+LPALCCAPTURESTART qalcCaptureStart;
+LPALCCAPTURESTOP qalcCaptureStop;
+LPALCCAPTURESAMPLES qalcCaptureSamples;
+
+static void *OpenALLib = NULL;
+
+static bool alinit_fail = false;
+
+/*
+=================
+GPA
+=================
+*/
+static void *GPA(const char *str)
+{
+	void *rv;
+
+	rv = Sys_LoadFunction(OpenALLib, str);
+	if(!rv)
+	{
+		Com_Printf( " Can't load symbol %s\n", str);
+		alinit_fail = true;
+		return NULL;
+	}
+	else
+	{
+		Com_DPrintf( " Loaded symbol %s (%p)\n", str, rv);
+        return rv;
+	}
+}
+
+/*
+=================
+QAL_Init
+=================
+*/
+bool QAL_Init(const char *libname)
+{
+	if(OpenALLib)
+		return true;
+
+	if(!(OpenALLib = Sys_LoadDll(libname, true)))
+		return false;
+
+	alinit_fail = false;
+
+	qalEnable = (LPALENABLE)GPA("alEnable");
+	qalDisable = (LPALDISABLE)GPA("alDisable");
+	qalIsEnabled = (LPALISENABLED)GPA("alIsEnabled");
+	qalGetString = (LPALGETSTRING)GPA("alGetString");
+	qalGetBooleanv = (LPALGETBOOLEANV)GPA("alGetBooleanv");
+	qalGetIntegerv = (LPALGETINTEGERV)GPA("alGetIntegerv");
+	qalGetFloatv = (LPALGETFLOATV)GPA("alGetFloatv");
+	qalGetDoublev = (LPALGETDOUBLEV)GPA("alGetDoublev");
+	qalGetBoolean = (LPALGETBOOLEAN)GPA("alGetBoolean");
+	qalGetInteger = (LPALGETINTEGER)GPA("alGetInteger");
+	qalGetFloat = (LPALGETFLOAT)GPA("alGetFloat");
+	qalGetDouble = (LPALGETDOUBLE)GPA("alGetDouble");
+	qalGetError = (LPALGETERROR)GPA("alGetError");
+	qalIsExtensionPresent = (LPALISEXTENSIONPRESENT)GPA("alIsExtensionPresent");
+	qalGetProcAddress = (LPALGETPROCADDRESS)GPA("alGetProcAddress");
+	qalGetEnumValue = (LPALGETENUMVALUE)GPA("alGetEnumValue");
+	qalListenerf = (LPALLISTENERF)GPA("alListenerf");
+	qalListener3f = (LPALLISTENER3F)GPA("alListener3f");
+	qalListenerfv = (LPALLISTENERFV)GPA("alListenerfv");
+	qalListeneri = (LPALLISTENERI)GPA("alListeneri");
+	qalGetListenerf = (LPALGETLISTENERF)GPA("alGetListenerf");
+	qalGetListener3f = (LPALGETLISTENER3F)GPA("alGetListener3f");
+	qalGetListenerfv = (LPALGETLISTENERFV)GPA("alGetListenerfv");
+	qalGetListeneri = (LPALGETLISTENERI)GPA("alGetListeneri");
+	qalGenSources = (LPALGENSOURCES)GPA("alGenSources");
+	qalDeleteSources = (LPALDELETESOURCES)GPA("alDeleteSources");
+	qalIsSource = (LPALISSOURCE)GPA("alIsSource");
+	qalSourcef = (LPALSOURCEF)GPA("alSourcef");
+	qalSource3f = (LPALSOURCE3F)GPA("alSource3f");
+	qalSourcefv = (LPALSOURCEFV)GPA("alSourcefv");
+	qalSourcei = (LPALSOURCEI)GPA("alSourcei");
+	qalGetSourcef = (LPALGETSOURCEF)GPA("alGetSourcef");
+	qalGetSource3f = (LPALGETSOURCE3F)GPA("alGetSource3f");
+	qalGetSourcefv = (LPALGETSOURCEFV)GPA("alGetSourcefv");
+	qalGetSourcei = (LPALGETSOURCEI)GPA("alGetSourcei");
+	qalSourcePlayv = (LPALSOURCEPLAYV)GPA("alSourcePlayv");
+	qalSourceStopv = (LPALSOURCESTOPV)GPA("alSourceStopv");
+	qalSourceRewindv = (LPALSOURCEREWINDV)GPA("alSourceRewindv");
+	qalSourcePausev = (LPALSOURCEPAUSEV)GPA("alSourcePausev");
+	qalSourcePlay = (LPALSOURCEPLAY)GPA("alSourcePlay");
+	qalSourceStop = (LPALSOURCESTOP)GPA("alSourceStop");
+	qalSourceRewind = (LPALSOURCEREWIND)GPA("alSourceRewind");
+	qalSourcePause = (LPALSOURCEPAUSE)GPA("alSourcePause");
+	qalSourceQueueBuffers = (LPALSOURCEQUEUEBUFFERS)GPA("alSourceQueueBuffers");
+	qalSourceUnqueueBuffers = (LPALSOURCEUNQUEUEBUFFERS)GPA("alSourceUnqueueBuffers");
+	qalGenBuffers = (LPALGENBUFFERS)GPA("alGenBuffers");
+	qalDeleteBuffers = (LPALDELETEBUFFERS)GPA("alDeleteBuffers");
+	qalIsBuffer = (LPALISBUFFER)GPA("alIsBuffer");
+	qalBufferData = (LPALBUFFERDATA)GPA("alBufferData");
+	qalGetBufferf = (LPALGETBUFFERF)GPA("alGetBufferf");
+	qalGetBufferi = (LPALGETBUFFERI)GPA("alGetBufferi");
+	qalDopplerFactor = (LPALDOPPLERFACTOR)GPA("alDopplerFactor");
+	qalSpeedOfSound = (LPALSPEEDOFSOUND)GPA("alSpeedOfSound");
+	qalDistanceModel = (LPALDISTANCEMODEL)GPA("alDistanceModel");
+
+	qalcCreateContext = (LPALCCREATECONTEXT)GPA("alcCreateContext");
+	qalcMakeContextCurrent = (LPALCMAKECONTEXTCURRENT)GPA("alcMakeContextCurrent");
+	qalcProcessContext = (LPALCPROCESSCONTEXT)GPA("alcProcessContext");
+	qalcSuspendContext = (LPALCSUSPENDCONTEXT)GPA("alcSuspendContext");
+	qalcDestroyContext = (LPALCDESTROYCONTEXT)GPA("alcDestroyContext");
+	qalcGetCurrentContext = (LPALCGETCURRENTCONTEXT)GPA("alcGetCurrentContext");
+	qalcGetContextsDevice = (LPALCGETCONTEXTSDEVICE)GPA("alcGetContextsDevice");
+	qalcOpenDevice = (LPALCOPENDEVICE)GPA("alcOpenDevice");
+	qalcCloseDevice = (LPALCCLOSEDEVICE)GPA("alcCloseDevice");
+	qalcGetError = (LPALCGETERROR)GPA("alcGetError");
+	qalcIsExtensionPresent = (LPALCISEXTENSIONPRESENT)GPA("alcIsExtensionPresent");
+	qalcGetProcAddress = (LPALCGETPROCADDRESS)GPA("alcGetProcAddress");
+	qalcGetEnumValue = (LPALCGETENUMVALUE)GPA("alcGetEnumValue");
+	qalcGetString = (LPALCGETSTRING)GPA("alcGetString");
+	qalcGetIntegerv = (LPALCGETINTEGERV)GPA("alcGetIntegerv");
+	qalcCaptureOpenDevice = (LPALCCAPTUREOPENDEVICE)GPA("alcCaptureOpenDevice");
+	qalcCaptureCloseDevice = (LPALCCAPTURECLOSEDEVICE)GPA("alcCaptureCloseDevice");
+	qalcCaptureStart = (LPALCCAPTURESTART)GPA("alcCaptureStart");
+	qalcCaptureStop = (LPALCCAPTURESTOP)GPA("alcCaptureStop");
+	qalcCaptureSamples = (LPALCCAPTURESAMPLES)GPA("alcCaptureSamples");
+
+	if(alinit_fail)
+	{
+		QAL_Shutdown();
+		Com_Printf( " One or more symbols not found\n");
+		return false;
+	}
+
+	return true;
+}
+
+/*
+=================
+QAL_Shutdown
+=================
+*/
+void QAL_Shutdown( void )
+{
+	if(OpenALLib)
+	{
+		Sys_UnloadLibrary(OpenALLib);
+		OpenALLib = NULL;
+	}
+
+	qalEnable = NULL;
+	qalDisable = NULL;
+	qalIsEnabled = NULL;
+	qalGetString = NULL;
+	qalGetBooleanv = NULL;
+	qalGetIntegerv = NULL;
+	qalGetFloatv = NULL;
+	qalGetDoublev = NULL;
+	qalGetBoolean = NULL;
+	qalGetInteger = NULL;
+	qalGetFloat = NULL;
+	qalGetDouble = NULL;
+	qalGetError = NULL;
+	qalIsExtensionPresent = NULL;
+	qalGetProcAddress = NULL;
+	qalGetEnumValue = NULL;
+	qalListenerf = NULL;
+	qalListener3f = NULL;
+	qalListenerfv = NULL;
+	qalListeneri = NULL;
+	qalGetListenerf = NULL;
+	qalGetListener3f = NULL;
+	qalGetListenerfv = NULL;
+	qalGetListeneri = NULL;
+	qalGenSources = NULL;
+	qalDeleteSources = NULL;
+	qalIsSource = NULL;
+	qalSourcef = NULL;
+	qalSource3f = NULL;
+	qalSourcefv = NULL;
+	qalSourcei = NULL;
+	qalGetSourcef = NULL;
+	qalGetSource3f = NULL;
+	qalGetSourcefv = NULL;
+	qalGetSourcei = NULL;
+	qalSourcePlayv = NULL;
+	qalSourceStopv = NULL;
+	qalSourceRewindv = NULL;
+	qalSourcePausev = NULL;
+	qalSourcePlay = NULL;
+	qalSourceStop = NULL;
+	qalSourceRewind = NULL;
+	qalSourcePause = NULL;
+	qalSourceQueueBuffers = NULL;
+	qalSourceUnqueueBuffers = NULL;
+	qalGenBuffers = NULL;
+	qalDeleteBuffers = NULL;
+	qalIsBuffer = NULL;
+	qalBufferData = NULL;
+	qalGetBufferf = NULL;
+	qalGetBufferi = NULL;
+	qalDopplerFactor = NULL;
+	qalSpeedOfSound = NULL;
+	qalDistanceModel = NULL;
+
+	qalcCreateContext = NULL;
+	qalcMakeContextCurrent = NULL;
+	qalcProcessContext = NULL;
+	qalcSuspendContext = NULL;
+	qalcDestroyContext = NULL;
+	qalcGetCurrentContext = NULL;
+	qalcGetContextsDevice = NULL;
+	qalcOpenDevice = NULL;
+	qalcCloseDevice = NULL;
+	qalcGetError = NULL;
+	qalcIsExtensionPresent = NULL;
+	qalcGetProcAddress = NULL;
+	qalcGetEnumValue = NULL;
+	qalcGetString = NULL;
+	qalcGetIntegerv = NULL;
+	qalcCaptureOpenDevice = NULL;
+	qalcCaptureCloseDevice = NULL;
+	qalcCaptureStart = NULL;
+	qalcCaptureStop = NULL;
+	qalcCaptureSamples = NULL;
+}
+#else
+bool QAL_Init(const char *libname)
+{
+	return true;
+}
+void QAL_Shutdown( void )
+{
+}
+#endif
+#endif
diff --git a/src/client/qal.h b/src/client/qal.h
new file mode 100644
index 0000000..41d6244
--- /dev/null
+++ b/src/client/qal.h
@@ -0,0 +1,252 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2005 Stuart Dalton (badcdev@gmail.com)
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#ifndef __QAL_H__
+#define __QAL_H__
+
+#ifdef USE_LOCAL_HEADERS
+# include "AL/al.h"
+# include "AL/alc.h"
+#else
+# if defined(_MSC_VER) || defined(__APPLE__)
+// MSVC users must install the OpenAL SDK which doesn't use the AL/*.h scheme.
+// OSX framework also needs this
+#  include <al.h>
+#  include <alc.h>
+# else
+#  include <AL/al.h>
+#  include <AL/alc.h>
+# endif
+#endif
+
+#include "qcommon/q_shared.h"
+#include "qcommon/qcommon.h"
+
+#ifdef USE_OPENAL_DLOPEN
+#define AL_NO_PROTOTYPES
+#define ALC_NO_PROTOTYPES
+#endif
+
+/* Hack to enable compiling both on OpenAL SDK and OpenAL-soft. */
+#ifndef ALC_ENUMERATE_ALL_EXT
+#  define ALC_ENUMERATE_ALL_EXT 1
+#  define ALC_DEFAULT_ALL_DEVICES_SPECIFIER        0x1012
+#  define ALC_ALL_DEVICES_SPECIFIER                0x1013
+#endif
+
+#ifdef USE_OPENAL_DLOPEN
+extern LPALENABLE qalEnable;
+extern LPALDISABLE qalDisable;
+extern LPALISENABLED qalIsEnabled;
+extern LPALGETSTRING qalGetString;
+extern LPALGETBOOLEANV qalGetBooleanv;
+extern LPALGETINTEGERV qalGetIntegerv;
+extern LPALGETFLOATV qalGetFloatv;
+extern LPALGETDOUBLEV qalGetDoublev;
+extern LPALGETBOOLEAN qalGetBoolean;
+extern LPALGETINTEGER qalGetInteger;
+extern LPALGETFLOAT qalGetFloat;
+extern LPALGETDOUBLE qalGetDouble;
+extern LPALGETERROR qalGetError;
+extern LPALISEXTENSIONPRESENT qalIsExtensionPresent;
+extern LPALGETPROCADDRESS qalGetProcAddress;
+extern LPALGETENUMVALUE qalGetEnumValue;
+extern LPALLISTENERF qalListenerf;
+extern LPALLISTENER3F qalListener3f;
+extern LPALLISTENERFV qalListenerfv;
+extern LPALLISTENERI qalListeneri;
+extern LPALLISTENER3I qalListener3i;
+extern LPALLISTENERIV qalListeneriv;
+extern LPALGETLISTENERF qalGetListenerf;
+extern LPALGETLISTENER3F qalGetListener3f;
+extern LPALGETLISTENERFV qalGetListenerfv;
+extern LPALGETLISTENERI qalGetListeneri;
+extern LPALGETLISTENER3I qalGetListener3i;
+extern LPALGETLISTENERIV qalGetListeneriv;
+extern LPALGENSOURCES qalGenSources;
+extern LPALDELETESOURCES qalDeleteSources;
+extern LPALISSOURCE qalIsSource;
+extern LPALSOURCEF qalSourcef;
+extern LPALSOURCE3F qalSource3f;
+extern LPALSOURCEFV qalSourcefv;
+extern LPALSOURCEI qalSourcei;
+extern LPALSOURCE3I qalSource3i;
+extern LPALSOURCEIV qalSourceiv;
+extern LPALGETSOURCEF qalGetSourcef;
+extern LPALGETSOURCE3F qalGetSource3f;
+extern LPALGETSOURCEFV qalGetSourcefv;
+extern LPALGETSOURCEI qalGetSourcei;
+extern LPALGETSOURCE3I qalGetSource3i;
+extern LPALGETSOURCEIV qalGetSourceiv;
+extern LPALSOURCEPLAYV qalSourcePlayv;
+extern LPALSOURCESTOPV qalSourceStopv;
+extern LPALSOURCEREWINDV qalSourceRewindv;
+extern LPALSOURCEPAUSEV qalSourcePausev;
+extern LPALSOURCEPLAY qalSourcePlay;
+extern LPALSOURCESTOP qalSourceStop;
+extern LPALSOURCEREWIND qalSourceRewind;
+extern LPALSOURCEPAUSE qalSourcePause;
+extern LPALSOURCEQUEUEBUFFERS qalSourceQueueBuffers;
+extern LPALSOURCEUNQUEUEBUFFERS qalSourceUnqueueBuffers;
+extern LPALGENBUFFERS qalGenBuffers;
+extern LPALDELETEBUFFERS qalDeleteBuffers;
+extern LPALISBUFFER qalIsBuffer;
+extern LPALBUFFERDATA qalBufferData;
+extern LPALBUFFERF qalBufferf;
+extern LPALBUFFER3F qalBuffer3f;
+extern LPALBUFFERFV qalBufferfv;
+extern LPALBUFFERF qalBufferi;
+extern LPALBUFFER3F qalBuffer3i;
+extern LPALBUFFERFV qalBufferiv;
+extern LPALGETBUFFERF qalGetBufferf;
+extern LPALGETBUFFER3F qalGetBuffer3f;
+extern LPALGETBUFFERFV qalGetBufferfv;
+extern LPALGETBUFFERI qalGetBufferi;
+extern LPALGETBUFFER3I qalGetBuffer3i;
+extern LPALGETBUFFERIV qalGetBufferiv;
+extern LPALDOPPLERFACTOR qalDopplerFactor;
+extern LPALSPEEDOFSOUND qalSpeedOfSound;
+extern LPALDISTANCEMODEL qalDistanceModel;
+
+extern LPALCCREATECONTEXT qalcCreateContext;
+extern LPALCMAKECONTEXTCURRENT qalcMakeContextCurrent;
+extern LPALCPROCESSCONTEXT qalcProcessContext;
+extern LPALCSUSPENDCONTEXT qalcSuspendContext;
+extern LPALCDESTROYCONTEXT qalcDestroyContext;
+extern LPALCGETCURRENTCONTEXT qalcGetCurrentContext;
+extern LPALCGETCONTEXTSDEVICE qalcGetContextsDevice;
+extern LPALCOPENDEVICE qalcOpenDevice;
+extern LPALCCLOSEDEVICE qalcCloseDevice;
+extern LPALCGETERROR qalcGetError;
+extern LPALCISEXTENSIONPRESENT qalcIsExtensionPresent;
+extern LPALCGETPROCADDRESS qalcGetProcAddress;
+extern LPALCGETENUMVALUE qalcGetEnumValue;
+extern LPALCGETSTRING qalcGetString;
+extern LPALCGETINTEGERV qalcGetIntegerv;
+extern LPALCCAPTUREOPENDEVICE qalcCaptureOpenDevice;
+extern LPALCCAPTURECLOSEDEVICE qalcCaptureCloseDevice;
+extern LPALCCAPTURESTART qalcCaptureStart;
+extern LPALCCAPTURESTOP qalcCaptureStop;
+extern LPALCCAPTURESAMPLES qalcCaptureSamples;
+#else
+#define qalEnable alEnable
+#define qalDisable alDisable
+#define qalIsEnabled alIsEnabled
+#define qalGetString alGetString
+#define qalGetBooleanv alGetBooleanv
+#define qalGetIntegerv alGetIntegerv
+#define qalGetFloatv alGetFloatv
+#define qalGetDoublev alGetDoublev
+#define qalGetBoolean alGetBoolean
+#define qalGetInteger alGetInteger
+#define qalGetFloat alGetFloat
+#define qalGetDouble alGetDouble
+#define qalGetError alGetError
+#define qalIsExtensionPresent alIsExtensionPresent
+#define qalGetProcAddress alGetProcAddress
+#define qalGetEnumValue alGetEnumValue
+#define qalListenerf alListenerf
+#define qalListener3f alListener3f
+#define qalListenerfv alListenerfv
+#define qalListeneri alListeneri
+#define qalListener3i alListener3i
+#define qalListeneriv alListeneriv
+#define qalGetListenerf alGetListenerf
+#define qalGetListener3f alGetListener3f
+#define qalGetListenerfv alGetListenerfv
+#define qalGetListeneri alGetListeneri
+#define qalGetListener3i alGetListener3i
+#define qalGetListeneriv alGetListeneriv
+#define qalGenSources alGenSources
+#define qalDeleteSources alDeleteSources
+#define qalIsSource alIsSource
+#define qalSourcef alSourcef
+#define qalSource3f alSource3f
+#define qalSourcefv alSourcefv
+#define qalSourcei alSourcei
+#define qalSource3i alSource3i
+#define qalSourceiv alSourceiv
+#define qalGetSourcef alGetSourcef
+#define qalGetSource3f alGetSource3f
+#define qalGetSourcefv alGetSourcefv
+#define qalGetSourcei alGetSourcei
+#define qalGetSource3i alGetSource3i
+#define qalGetSourceiv alGetSourceiv
+#define qalSourcePlayv alSourcePlayv
+#define qalSourceStopv alSourceStopv
+#define qalSourceRewindv alSourceRewindv
+#define qalSourcePausev alSourcePausev
+#define qalSourcePlay alSourcePlay
+#define qalSourceStop alSourceStop
+#define qalSourceRewind alSourceRewind
+#define qalSourcePause alSourcePause
+#define qalSourceQueueBuffers alSourceQueueBuffers
+#define qalSourceUnqueueBuffers alSourceUnqueueBuffers
+#define qalGenBuffers alGenBuffers
+#define qalDeleteBuffers alDeleteBuffers
+#define qalIsBuffer alIsBuffer
+#define qalBufferData alBufferData
+#define qalBufferf alBufferf
+#define qalBuffer3f alBuffer3f
+#define qalBufferfv alBufferfv
+#define qalBufferi alBufferi
+#define qalBuffer3i alBuffer3i
+#define qalBufferiv alBufferiv
+#define qalGetBufferf alGetBufferf
+#define qalGetBuffer3f alGetBuffer3f
+#define qalGetBufferfv alGetBufferfv
+#define qalGetBufferi alGetBufferi
+#define qalGetBuffer3i alGetBuffer3i
+#define qalGetBufferiv alGetBufferiv
+#define qalDopplerFactor alDopplerFactor
+#define qalSpeedOfSound alSpeedOfSound
+#define qalDistanceModel alDistanceModel
+
+#define qalcCreateContext alcCreateContext
+#define qalcMakeContextCurrent alcMakeContextCurrent
+#define qalcProcessContext alcProcessContext
+#define qalcSuspendContext alcSuspendContext
+#define qalcDestroyContext alcDestroyContext
+#define qalcGetCurrentContext alcGetCurrentContext
+#define qalcGetContextsDevice alcGetContextsDevice
+#define qalcOpenDevice alcOpenDevice
+#define qalcCloseDevice alcCloseDevice
+#define qalcGetError alcGetError
+#define qalcIsExtensionPresent alcIsExtensionPresent
+#define qalcGetProcAddress alcGetProcAddress
+#define qalcGetEnumValue alcGetEnumValue
+#define qalcGetString alcGetString
+#define qalcGetIntegerv alcGetIntegerv
+#define qalcCaptureOpenDevice alcCaptureOpenDevice
+#define qalcCaptureCloseDevice alcCaptureCloseDevice
+#define qalcCaptureStart alcCaptureStart
+#define qalcCaptureStop alcCaptureStop
+#define qalcCaptureSamples alcCaptureSamples
+#endif
+
+bool QAL_Init(const char *libname);
+void QAL_Shutdown( void );
+
+#endif	// __QAL_H__
diff --git a/src/client/snd_adpcm.cpp b/src/client/snd_adpcm.cpp
new file mode 100644
index 0000000..d5d9930
--- /dev/null
+++ b/src/client/snd_adpcm.cpp
@@ -0,0 +1,329 @@
+/***********************************************************
+Copyright 1992 by Stichting Mathematisch Centrum, Amsterdam, The
+Netherlands.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/*
+** Intel/DVI ADPCM coder/decoder.
+**
+** The algorithm for this coder was taken from the IMA Compatability Project
+** proceedings, Vol 2, Number 2; May 1992.
+**
+** Version 1.2, 18-Dec-92.
+*/
+
+#include "snd_local.h"
+
+/* Intel ADPCM step variation table */
+static int indexTable[16] = {
+    -1, -1, -1, -1, 2, 4, 6, 8,
+    -1, -1, -1, -1, 2, 4, 6, 8,
+};
+
+static int stepsizeTable[89] = {
+    7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
+    19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
+    50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
+    130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
+    337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
+    876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
+    2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
+    5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
+    15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
+};
+
+   
+void S_AdpcmEncode( short indata[], char outdata[], int len, struct adpcm_state *state ) {
+    short *inp;			/* Input buffer pointer */
+    signed char *outp;		/* output buffer pointer */
+    int val;			/* Current input sample value */
+    int sign;			/* Current adpcm sign bit */
+    int delta;			/* Current adpcm output value */
+    int diff;			/* Difference between val and sample */
+    int step;			/* Stepsize */
+    int valpred;		/* Predicted output value */
+    int vpdiff;			/* Current change to valpred */
+    int index;			/* Current step change index */
+    int outputbuffer;		/* place to keep previous 4-bit value */
+    int bufferstep;		/* toggle between outputbuffer/output */
+
+    outp = (signed char *)outdata;
+    inp = indata;
+
+    valpred = state->sample;
+    index = state->index;
+    step = stepsizeTable[index];
+    
+	outputbuffer = 0;	// quiet a compiler warning
+    bufferstep = 1;
+
+    for ( ; len > 0 ; len-- ) {
+		val = *inp++;
+
+		/* Step 1 - compute difference with previous value */
+		diff = val - valpred;
+		sign = (diff < 0) ? 8 : 0;
+		if ( sign ) diff = (-diff);
+
+		/* Step 2 - Divide and clamp */
+		/* Note:
+		** This code *approximately* computes:
+		**    delta = diff*4/step;
+		**    vpdiff = (delta+0.5)*step/4;
+		** but in shift step bits are dropped. The net result of this is
+		** that even if you have fast mul/div hardware you cannot put it to
+		** good use since the fixup would be too expensive.
+		*/
+		delta = 0;
+		vpdiff = (step >> 3);
+		
+		if ( diff >= step ) {
+			delta = 4;
+			diff -= step;
+			vpdiff += step;
+		}
+		step >>= 1;
+		if ( diff >= step  ) {
+			delta |= 2;
+			diff -= step;
+			vpdiff += step;
+		}
+		step >>= 1;
+		if ( diff >= step ) {
+			delta |= 1;
+			vpdiff += step;
+		}
+
+		/* Step 3 - Update previous value */
+		if ( sign )
+		  valpred -= vpdiff;
+		else
+		  valpred += vpdiff;
+
+		/* Step 4 - Clamp previous value to 16 bits */
+		if ( valpred > 32767 )
+		  valpred = 32767;
+		else if ( valpred < -32768 )
+		  valpred = -32768;
+
+		/* Step 5 - Assemble value, update index and step values */
+		delta |= sign;
+		
+		index += indexTable[delta];
+		if ( index < 0 ) index = 0;
+		if ( index > 88 ) index = 88;
+		step = stepsizeTable[index];
+
+		/* Step 6 - Output value */
+		if ( bufferstep ) {
+			outputbuffer = (delta << 4) & 0xf0;
+		} else {
+			*outp++ = (delta & 0x0f) | outputbuffer;
+		}
+		bufferstep = !bufferstep;
+    }
+
+    /* Output last step, if needed */
+    if ( !bufferstep )
+      *outp++ = outputbuffer;
+    
+    state->sample = valpred;
+    state->index = index;
+}
+
+
+/* static */ void S_AdpcmDecode( const char indata[], short *outdata, int len, struct adpcm_state *state ) {
+    signed char *inp;		/* Input buffer pointer */
+    int outp;			/* output buffer pointer */
+    int sign;			/* Current adpcm sign bit */
+    int delta;			/* Current adpcm output value */
+    int step;			/* Stepsize */
+    int valpred;		/* Predicted value */
+    int vpdiff;			/* Current change to valpred */
+    int index;			/* Current step change index */
+    int inputbuffer;		/* place to keep next 4-bit value */
+    int bufferstep;		/* toggle between inputbuffer/input */
+
+    outp = 0;
+    inp = (signed char *)indata;
+
+    valpred = state->sample;
+    index = state->index;
+    step = stepsizeTable[index];
+
+    bufferstep = 0;
+    inputbuffer = 0;	// quiet a compiler warning
+    for ( ; len > 0 ; len-- ) {
+		
+		/* Step 1 - get the delta value */
+		if ( bufferstep ) {
+			delta = inputbuffer & 0xf;
+		} else {
+			inputbuffer = *inp++;
+			delta = (inputbuffer >> 4) & 0xf;
+		}
+		bufferstep = !bufferstep;
+
+		/* Step 2 - Find new index value (for later) */
+		index += indexTable[delta];
+		if ( index < 0 ) index = 0;
+		if ( index > 88 ) index = 88;
+
+		/* Step 3 - Separate sign and magnitude */
+		sign = delta & 8;
+		delta = delta & 7;
+
+		/* Step 4 - Compute difference and new predicted value */
+		/*
+		** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
+		** in adpcm_coder.
+		*/
+		vpdiff = step >> 3;
+		if ( delta & 4 ) vpdiff += step;
+		if ( delta & 2 ) vpdiff += step>>1;
+		if ( delta & 1 ) vpdiff += step>>2;
+
+		if ( sign )
+		  valpred -= vpdiff;
+		else
+		  valpred += vpdiff;
+
+		/* Step 5 - clamp output value */
+		if ( valpred > 32767 )
+		  valpred = 32767;
+		else if ( valpred < -32768 )
+		  valpred = -32768;
+
+		/* Step 6 - Update step value */
+		step = stepsizeTable[index];
+
+		/* Step 7 - Output value */
+		outdata[outp] = valpred;
+		outp++;
+    }
+
+    state->sample = valpred;
+    state->index = index;
+}
+
+
+/*
+====================
+S_AdpcmMemoryNeeded
+
+Returns the amount of memory (in bytes) needed to store the samples in out internal adpcm format
+====================
+*/
+int S_AdpcmMemoryNeeded( const wavinfo_t *info ) {
+	float	scale;
+	int		scaledSampleCount;
+	int		sampleMemory;
+	int		blockCount;
+	int		headerMemory;
+
+	// determine scale to convert from input sampling rate to desired sampling rate
+	scale = (float)info->rate / dma.speed;
+
+	// calc number of samples at playback sampling rate
+	scaledSampleCount = info->samples / scale;
+
+	// calc memory need to store those samples using ADPCM at 4 bits per sample
+	sampleMemory = scaledSampleCount / 2;
+
+	// calc number of sample blocks needed of PAINTBUFFER_SIZE
+	blockCount = scaledSampleCount / PAINTBUFFER_SIZE;
+	if( scaledSampleCount % PAINTBUFFER_SIZE ) {
+		blockCount++;
+	}
+
+	// calc memory needed to store the block headers
+	headerMemory = blockCount * sizeof(adpcm_state_t);
+
+	return sampleMemory + headerMemory;
+}
+
+
+/*
+====================
+S_AdpcmGetSamples
+====================
+*/
+void S_AdpcmGetSamples(sndBuffer *chunk, short *to) {
+	adpcm_state_t	state;
+	byte			*out;
+
+	// get the starting state from the block header
+	state.index = chunk->adpcm.index;
+	state.sample = chunk->adpcm.sample;
+
+	out = (byte *)chunk->sndChunk;
+	// get samples
+	S_AdpcmDecode((char *) out, to, SND_CHUNK_SIZE_BYTE*2, &state );
+}
+
+
+/*
+====================
+S_AdpcmEncodeSound
+====================
+*/
+void S_AdpcmEncodeSound( sfx_t *sfx, short *samples ) {
+	adpcm_state_t	state;
+	int				inOffset;
+	int				count;
+	int				n;
+	sndBuffer		*newchunk, *chunk;
+	byte			*out;
+
+	inOffset = 0;
+	count = sfx->soundLength;
+	state.index = 0;
+	state.sample = samples[0];
+
+	chunk = NULL;
+	while( count ) {
+		n = count;
+		if( n > SND_CHUNK_SIZE_BYTE*2 ) {
+			n = SND_CHUNK_SIZE_BYTE*2;
+		}
+
+		newchunk = SND_malloc();
+		if (sfx->soundData == NULL) {
+			sfx->soundData = newchunk;
+		} else if (chunk != NULL) {
+			chunk->next = newchunk;
+		}
+		chunk = newchunk;
+
+		// output the header
+		chunk->adpcm.index  = state.index;
+		chunk->adpcm.sample = state.sample;
+
+		out = (byte *)chunk->sndChunk;
+
+		// encode the samples
+		S_AdpcmEncode( samples + inOffset, (char *) out, n, &state );
+
+		inOffset += n;
+		count -= n;
+	}
+}
diff --git a/src/client/snd_codec.cpp b/src/client/snd_codec.cpp
new file mode 100644
index 0000000..a794b90
--- /dev/null
+++ b/src/client/snd_codec.cpp
@@ -0,0 +1,239 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2005 Stuart Dalton (badcdev@gmail.com)
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include "client.h"
+#include "snd_codec.h"
+
+static snd_codec_t *codecs;
+
+/*
+=================
+S_CodecGetSound
+
+Opens/loads a sound, tries codec based on the sound's file extension
+then tries all supported codecs.
+=================
+*/
+static void *S_CodecGetSound(const char *filename, snd_info_t *info)
+{
+	snd_codec_t *codec;
+	snd_codec_t *orgCodec = NULL;
+	bool	orgNameFailed = false;
+	char		localName[ MAX_QPATH ];
+	const char	*ext;
+	char		altName[ MAX_QPATH ];
+	void		*rtn = NULL;
+
+	Q_strncpyz(localName, filename, MAX_QPATH);
+
+	ext = COM_GetExtension(localName);
+
+	if( *ext )
+	{
+		// Look for the correct loader and use it
+		for( codec = codecs; codec; codec = codec->next )
+		{
+			if( !Q_stricmp( ext, codec->ext ) )
+			{
+				// Load
+				if( info )
+					rtn = codec->load(localName, info);
+				else
+					rtn = codec->open(localName);
+				break;
+			}
+		}
+
+		// A loader was found
+		if( codec )
+		{
+			if( !rtn )
+			{
+				// Loader failed, most likely because the file isn't there;
+				// try again without the extension
+				orgNameFailed = true;
+				orgCodec = codec;
+				COM_StripExtension( filename, localName, MAX_QPATH );
+			}
+			else
+			{
+				// Something loaded
+				return rtn;
+			}
+		}
+	}
+
+	// Try and find a suitable match using all
+	// the sound codecs supported
+	for( codec = codecs; codec; codec = codec->next )
+	{
+		if( codec == orgCodec )
+			continue;
+
+		Com_sprintf( altName, sizeof (altName), "%s.%s", localName, codec->ext );
+
+		// Load
+		if( info )
+			rtn = codec->load(altName, info);
+		else
+			rtn = codec->open(altName);
+
+		if( rtn )
+		{
+			if( orgNameFailed )
+			{
+				Com_DPrintf(S_COLOR_YELLOW "WARNING: %s not present, using %s instead\n",
+						filename, altName );
+			}
+
+			return rtn;
+		}
+	}
+
+	Com_Printf(S_COLOR_YELLOW "WARNING: Failed to %s sound %s!\n", info ? "load" : "open", filename);
+
+	return NULL;
+}
+
+/*
+=================
+S_CodecInit
+=================
+*/
+void S_CodecInit()
+{
+	codecs = NULL;
+
+#ifdef USE_CODEC_OPUS
+	S_CodecRegister(&opus_codec);
+#endif
+
+#ifdef USE_CODEC_VORBIS
+	S_CodecRegister(&ogg_codec);
+#endif
+
+// Register wav codec last so that it is always tried first when a file extension was not found
+	S_CodecRegister(&wav_codec);
+}
+
+/*
+=================
+S_CodecShutdown
+=================
+*/
+void S_CodecShutdown()
+{
+	codecs = NULL;
+}
+
+/*
+=================
+S_CodecRegister
+=================
+*/
+void S_CodecRegister(snd_codec_t *codec)
+{
+	codec->next = codecs;
+	codecs = codec;
+}
+
+/*
+=================
+S_CodecLoad
+=================
+*/
+void *S_CodecLoad(const char *filename, snd_info_t *info)
+{
+	return S_CodecGetSound(filename, info);
+}
+
+/*
+=================
+S_CodecOpenStream
+=================
+*/
+snd_stream_t *S_CodecOpenStream(const char *filename)
+{
+	return (snd_stream_t*)S_CodecGetSound(filename, NULL);
+}
+
+void S_CodecCloseStream(snd_stream_t *stream)
+{
+	stream->codec->close(stream);
+}
+
+int S_CodecReadStream(snd_stream_t *stream, int bytes, void *buffer)
+{
+	return stream->codec->read(stream, bytes, buffer);
+}
+
+//=======================================================================
+// Util functions (used by codecs)
+
+/*
+=================
+S_CodecUtilOpen
+=================
+*/
+snd_stream_t *S_CodecUtilOpen(const char *filename, snd_codec_t *codec)
+{
+	snd_stream_t *stream;
+	fileHandle_t hnd;
+	int length;
+
+	// Try to open the file
+	length = FS_FOpenFileRead(filename, &hnd, true);
+	if(!hnd)
+	{
+		Com_DPrintf("Can't read sound file %s\n", filename);
+		return NULL;
+	}
+
+	// Allocate a stream
+	stream = (snd_stream_t*)Z_Malloc(sizeof(snd_stream_t));
+	if(!stream)
+	{
+		FS_FCloseFile(hnd);
+		return NULL;
+	}
+
+	// Copy over, return
+	stream->codec = codec;
+	stream->file = hnd;
+	stream->length = length;
+	return stream;
+}
+
+/*
+=================
+S_CodecUtilClose
+=================
+*/
+void S_CodecUtilClose(snd_stream_t **stream)
+{
+	FS_FCloseFile((*stream)->file);
+	Z_Free(*stream);
+	*stream = NULL;
+}
diff --git a/src/client/snd_codec.h b/src/client/snd_codec.h
new file mode 100644
index 0000000..a5f4358
--- /dev/null
+++ b/src/client/snd_codec.h
@@ -0,0 +1,109 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2005 Stuart Dalton (badcdev@gmail.com)
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#ifndef _SND_CODEC_H_
+#define _SND_CODEC_H_
+
+#include "qcommon/q_shared.h"
+#include "qcommon/qcommon.h"
+
+typedef struct snd_info_s
+{
+	int rate;
+	int width;
+	int channels;
+	int samples;
+	int size;
+	int dataofs;
+} snd_info_t;
+
+typedef struct snd_codec_s snd_codec_t;
+
+typedef struct snd_stream_s
+{
+	snd_codec_t *codec;
+	fileHandle_t file;
+	snd_info_t info;
+	int length;
+	int pos;
+	void *ptr;
+} snd_stream_t;
+
+// Codec functions
+typedef void *(*CODEC_LOAD)(const char *filename, snd_info_t *info);
+typedef snd_stream_t *(*CODEC_OPEN)(const char *filename);
+typedef int (*CODEC_READ)(snd_stream_t *stream, int bytes, void *buffer);
+typedef void (*CODEC_CLOSE)(snd_stream_t *stream);
+
+// Codec data structure
+struct snd_codec_s
+{
+	const char *ext;
+	CODEC_LOAD load;
+	CODEC_OPEN open;
+	CODEC_READ read;
+	CODEC_CLOSE close;
+	snd_codec_t *next;
+};
+
+// Codec management
+void S_CodecInit( void );
+void S_CodecShutdown( void );
+void S_CodecRegister(snd_codec_t *codec);
+void *S_CodecLoad(const char *filename, snd_info_t *info);
+snd_stream_t *S_CodecOpenStream(const char *filename);
+void S_CodecCloseStream(snd_stream_t *stream);
+int S_CodecReadStream(snd_stream_t *stream, int bytes, void *buffer);
+
+// Util functions (used by codecs)
+snd_stream_t *S_CodecUtilOpen(const char *filename, snd_codec_t *codec);
+void S_CodecUtilClose(snd_stream_t **stream);
+
+// WAV Codec
+extern snd_codec_t wav_codec;
+void *S_WAV_CodecLoad(const char *filename, snd_info_t *info);
+snd_stream_t *S_WAV_CodecOpenStream(const char *filename);
+void S_WAV_CodecCloseStream(snd_stream_t *stream);
+int S_WAV_CodecReadStream(snd_stream_t *stream, int bytes, void *buffer);
+
+// Ogg Vorbis codec
+#ifdef USE_CODEC_VORBIS
+extern snd_codec_t ogg_codec;
+void *S_OGG_CodecLoad(const char *filename, snd_info_t *info);
+snd_stream_t *S_OGG_CodecOpenStream(const char *filename);
+void S_OGG_CodecCloseStream(snd_stream_t *stream);
+int S_OGG_CodecReadStream(snd_stream_t *stream, int bytes, void *buffer);
+#endif // USE_CODEC_VORBIS
+
+// Ogg Opus codec
+#ifdef USE_CODEC_OPUS
+extern snd_codec_t opus_codec;
+void *S_OggOpus_CodecLoad(const char *filename, snd_info_t *info);
+snd_stream_t *S_OggOpus_CodecOpenStream(const char *filename);
+void S_OggOpus_CodecCloseStream(snd_stream_t *stream);
+int S_OggOpus_CodecReadStream(snd_stream_t *stream, int bytes, void *buffer);
+#endif // USE_CODEC_OPUS
+
+#endif // !_SND_CODEC_H_
diff --git a/src/client/snd_codec_ogg.cpp b/src/client/snd_codec_ogg.cpp
new file mode 100644
index 0000000..15fcd37
--- /dev/null
+++ b/src/client/snd_codec_ogg.cpp
@@ -0,0 +1,479 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2005 Stuart Dalton (badcdev@gmail.com)
+Copyright (C) 2005-2006 Joerg Dietrich <dietrich_joerg@gmx.de>
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+// OGG support is enabled by this define
+#ifdef USE_CODEC_VORBIS
+
+// includes for the Q3 sound system
+#include "client.h"
+
+// includes for the OGG codec
+#define OV_EXCLUDE_STATIC_CALLBACKS
+#include <vorbis/vorbisfile.h>
+
+#include <cerrno>
+
+#include "snd_codec.h"
+
+// The OGG codec can return the samples in a number of different formats,
+// we use the standard signed short format.
+#define OGG_SAMPLEWIDTH 2
+
+// Q3 OGG codec
+snd_codec_t ogg_codec =
+{
+	"ogg",
+	S_OGG_CodecLoad,
+	S_OGG_CodecOpenStream,
+	S_OGG_CodecReadStream,
+	S_OGG_CodecCloseStream,
+	NULL
+};
+
+// callbacks for vobisfile
+
+// fread() replacement
+size_t S_OGG_Callback_read(void *ptr, size_t size, size_t nmemb, void *datasource)
+{
+	snd_stream_t *stream;
+	int byteSize = 0;
+	int bytesRead = 0;
+	size_t nMembRead = 0;
+
+	// check if input is valid
+	if(!ptr)
+	{
+		errno = EFAULT; 
+		return 0;
+	}
+	
+	if(!(size && nmemb))
+	{
+		// It's not an error, caller just wants zero bytes!
+		errno = 0;
+		return 0;
+	}
+ 
+	if(!datasource)
+	{
+		errno = EBADF; 
+		return 0;
+	}
+	
+	// we use a snd_stream_t in the generic pointer to pass around
+	stream = (snd_stream_t *) datasource;
+
+	// FS_Read does not support multi-byte elements
+	byteSize = nmemb * size;
+
+	// read it with the Q3 function FS_Read()
+	bytesRead = FS_Read(ptr, byteSize, stream->file);
+
+	// update the file position
+	stream->pos += bytesRead;
+
+	// this function returns the number of elements read not the number of bytes
+	nMembRead = bytesRead / size;
+
+	// even if the last member is only read partially
+	// it is counted as a whole in the return value	
+	if(bytesRead % size)
+	{
+		nMembRead++;
+	}
+	
+	return nMembRead;
+}
+
+// fseek() replacement
+int S_OGG_Callback_seek(void *datasource, ogg_int64_t offset, int whence)
+{
+	snd_stream_t *stream;
+	int retVal = 0;
+
+	// check if input is valid
+	if(!datasource)
+	{
+		errno = EBADF; 
+		return -1;
+	}
+
+	// snd_stream_t in the generic pointer
+	stream = (snd_stream_t *) datasource;
+
+	// we must map the whence to its Q3 counterpart
+	switch(whence)
+	{
+		case SEEK_SET :
+		{
+			// set the file position in the actual file with the Q3 function
+			retVal = FS_Seek(stream->file, (long) offset, FS_SEEK_SET);
+
+			// something has gone wrong, so we return here
+			if(retVal < 0)
+			{
+			 return retVal;
+			}
+
+			// keep track of file position
+			stream->pos = (int) offset;
+			break;
+		}
+  
+		case SEEK_CUR :
+		{
+			// set the file position in the actual file with the Q3 function
+			retVal = FS_Seek(stream->file, (long) offset, FS_SEEK_CUR);
+
+			// something has gone wrong, so we return here
+			if(retVal < 0)
+			{
+			 return retVal;
+			}
+
+			// keep track of file position
+			stream->pos += (int) offset;
+			break;
+		}
+ 
+		case SEEK_END :
+		{
+			// set the file position in the actual file with the Q3 function
+			retVal = FS_Seek(stream->file, (long) offset, FS_SEEK_END);
+
+			// something has gone wrong, so we return here
+			if(retVal < 0)
+			{
+			 return retVal;
+			}
+
+			// keep track of file position
+			stream->pos = stream->length + (int) offset;
+			break;
+		}
+  
+		default :
+		{
+			// unknown whence, so we return an error
+			errno = EINVAL;
+			return -1;
+		}
+	}
+
+	// stream->pos shouldn't be smaller than zero or bigger than the filesize
+	stream->pos = (stream->pos < 0) ? 0 : stream->pos;
+	stream->pos = (stream->pos > stream->length) ? stream->length : stream->pos;
+
+	return 0;
+}
+
+// fclose() replacement
+int S_OGG_Callback_close(void *datasource)
+{
+	// we do nothing here and close all things manually in S_OGG_CodecCloseStream()
+	return 0;
+}
+
+// ftell() replacement
+long S_OGG_Callback_tell(void *datasource)
+{
+	snd_stream_t   *stream;
+
+	// check if input is valid
+	if(!datasource)
+	{
+		errno = EBADF;
+		return -1;
+	}
+
+	// snd_stream_t in the generic pointer
+	stream = (snd_stream_t *) datasource;
+
+	return (long) FS_FTell(stream->file);
+}
+
+// the callback structure
+const ov_callbacks S_OGG_Callbacks =
+{
+ &S_OGG_Callback_read,
+ &S_OGG_Callback_seek,
+ &S_OGG_Callback_close,
+ &S_OGG_Callback_tell
+};
+
+/*
+=================
+S_OGG_CodecOpenStream
+=================
+*/
+snd_stream_t *S_OGG_CodecOpenStream(const char *filename)
+{
+	snd_stream_t *stream;
+
+	// OGG codec control structure
+	OggVorbis_File *vf;
+
+	// some variables used to get informations about the OGG 
+	vorbis_info *OGGInfo;
+	ogg_int64_t numSamples;
+
+	// check if input is valid
+	if(!filename)
+	{
+		return NULL;
+	}
+
+	// Open the stream
+	stream = S_CodecUtilOpen(filename, &ogg_codec);
+	if(!stream)
+	{
+		return NULL;
+	}
+
+	// alloctate the OggVorbis_File
+	vf = (OggVorbis_File*)Z_Malloc(sizeof(OggVorbis_File));
+	if(!vf)
+	{
+		S_CodecUtilClose(&stream);
+
+		return NULL;
+	}
+
+	// open the codec with our callbacks and stream as the generic pointer
+	if(ov_open_callbacks(stream, vf, NULL, 0, S_OGG_Callbacks) != 0)
+	{
+		Z_Free(vf);
+
+		S_CodecUtilClose(&stream);
+
+		return NULL;
+	}
+
+	// the stream must be seekable
+	if(!ov_seekable(vf))
+	{
+		ov_clear(vf);
+
+		Z_Free(vf);
+
+		S_CodecUtilClose(&stream);
+
+		return NULL;
+	}
+ 
+	// we only support OGGs with one substream
+	if(ov_streams(vf) != 1)
+	{
+		ov_clear(vf);
+
+		Z_Free(vf);
+
+		S_CodecUtilClose(&stream);
+
+		return NULL;  
+	}
+
+	// get the info about channels and rate
+	OGGInfo = ov_info(vf, 0);
+	if(!OGGInfo)
+	{
+		ov_clear(vf);
+
+		Z_Free(vf);
+
+		S_CodecUtilClose(&stream);
+
+		return NULL;  
+	}
+
+	// get the number of sample-frames in the OGG
+	numSamples = ov_pcm_total(vf, 0);
+
+	// fill in the info-structure in the stream
+	stream->info.rate = OGGInfo->rate;
+	stream->info.width = OGG_SAMPLEWIDTH;
+	stream->info.channels = OGGInfo->channels;
+	stream->info.samples = numSamples;
+	stream->info.size = stream->info.samples * stream->info.channels * stream->info.width;
+	stream->info.dataofs = 0;
+
+	// We use stream->pos for the file pointer in the compressed ogg file 
+	stream->pos = 0;
+	
+	// We use the generic pointer in stream for the OGG codec control structure
+	stream->ptr = vf;
+
+	return stream;
+}
+
+/*
+=================
+S_OGG_CodecCloseStream
+=================
+*/
+void S_OGG_CodecCloseStream(snd_stream_t *stream)
+{
+	// check if input is valid
+	if(!stream)
+	{
+		return;
+	}
+	
+	// let the OGG codec cleanup its stuff
+	ov_clear((OggVorbis_File *) stream->ptr);
+
+	// free the OGG codec control struct
+	Z_Free(stream->ptr);
+
+	// close the stream
+	S_CodecUtilClose(&stream);
+}
+
+/*
+=================
+S_OGG_CodecReadStream
+=================
+*/
+int S_OGG_CodecReadStream(snd_stream_t *stream, int bytes, void *buffer)
+{
+	// buffer handling
+	int bytesRead, bytesLeft, c;
+	char *bufPtr;
+	
+	// Bitstream for the decoder
+	int BS = 0;
+
+	// big endian machines want their samples in big endian order
+	int IsBigEndian = 0;
+
+#	ifdef Q3_BIG_ENDIAN
+	IsBigEndian = 1;
+#	endif // Q3_BIG_ENDIAN
+
+	// check if input is valid
+	if(!(stream && buffer))
+	{
+		return 0;
+	}
+
+	if(bytes <= 0)
+	{
+		return 0;
+	}
+
+	bytesRead = 0;
+	bytesLeft = bytes;
+	bufPtr = (char*)buffer;
+
+	// cycle until we have the requested or all available bytes read
+	while(-1)
+	{
+		// read some bytes from the OGG codec
+		c = ov_read((OggVorbis_File *) stream->ptr, bufPtr, bytesLeft, IsBigEndian, OGG_SAMPLEWIDTH, 1, &BS);
+		
+		// no more bytes are left
+		if(c <= 0)
+		{
+			break;
+		}
+
+		bytesRead += c;
+		bytesLeft -= c;
+		bufPtr += c;
+  
+		// we have enough bytes
+		if(bytesLeft <= 0)
+		{
+			break;
+		}
+	}
+
+	return bytesRead;
+}
+
+/*
+=====================================================================
+S_OGG_CodecLoad
+
+We handle S_OGG_CodecLoad as a special case of the streaming functions 
+where we read the whole stream at once.
+======================================================================
+*/
+void *S_OGG_CodecLoad(const char *filename, snd_info_t *info)
+{
+	snd_stream_t *stream;
+	byte *buffer;
+	int bytesRead;
+	
+	// check if input is valid
+	if(!(filename && info))
+	{
+		return NULL;
+	}
+	
+	// open the file as a stream
+	stream = S_OGG_CodecOpenStream(filename);
+	if(!stream)
+	{
+		return NULL;
+	}
+	
+	// copy over the info
+	info->rate = stream->info.rate;
+	info->width = stream->info.width;
+	info->channels = stream->info.channels;
+	info->samples = stream->info.samples;
+	info->size = stream->info.size;
+	info->dataofs = stream->info.dataofs;
+
+	// allocate a buffer
+	// this buffer must be free-ed by the caller of this function
+    	buffer = (byte*)Hunk_AllocateTempMemory(info->size);
+	if(!buffer)
+	{
+		S_OGG_CodecCloseStream(stream);
+	
+		return NULL;	
+	}
+
+	// fill the buffer
+	bytesRead = S_OGG_CodecReadStream(stream, info->size, buffer);
+	
+	// we don't even have read a single byte
+	if(bytesRead <= 0)
+	{
+		Hunk_FreeTempMemory(buffer);
+		S_OGG_CodecCloseStream(stream);
+
+		return NULL;	
+	}
+
+	S_OGG_CodecCloseStream(stream);
+	
+	return buffer;
+}
+
+#endif // USE_CODEC_VORBIS
diff --git a/src/client/snd_codec_opus.cpp b/src/client/snd_codec_opus.cpp
new file mode 100644
index 0000000..a8ffba5
--- /dev/null
+++ b/src/client/snd_codec_opus.cpp
@@ -0,0 +1,452 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2005 Stuart Dalton (badcdev@gmail.com)
+Copyright (C) 2005-2006 Joerg Dietrich <dietrich_joerg@gmx.de>
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+// Ogg Opus support is enabled by this define
+#ifdef USE_CODEC_OPUS
+
+// includes for the Q3 sound system
+#include "client.h"
+
+// includes for the Ogg Opus codec
+#include <opusfile.h>
+
+#include <cerrno>
+
+#include "snd_codec.h"
+
+// samples are 16 bit
+#define OPUS_SAMPLEWIDTH 2
+
+// Q3 Ogg Opus codec
+snd_codec_t opus_codec =
+{
+	"opus",
+	S_OggOpus_CodecLoad,
+	S_OggOpus_CodecOpenStream,
+	S_OggOpus_CodecReadStream,
+	S_OggOpus_CodecCloseStream,
+	NULL
+};
+
+// callbacks for opusfile
+
+// fread() replacement
+int S_OggOpus_Callback_read(void *datasource, unsigned char *ptr, int size )
+{
+	snd_stream_t *stream;
+	int bytesRead = 0;
+
+	// check if input is valid
+	if(!ptr)
+	{
+		errno = EFAULT;
+		return -1;
+	}
+	
+	if(!size)
+	{
+		// It's not an error, caller just wants zero bytes!
+		errno = 0;
+		return 0;
+	}
+ 
+	if (size < 0)
+	{
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(!datasource)
+	{
+		errno = EBADF;
+		return -1;
+	}
+	
+	// we use a snd_stream_t in the generic pointer to pass around
+	stream = (snd_stream_t *) datasource;
+
+	// read it with the Q3 function FS_Read()
+	bytesRead = FS_Read(ptr, size, stream->file);
+
+	// update the file position
+	stream->pos += bytesRead;
+
+	return bytesRead;
+}
+
+// fseek() replacement
+int S_OggOpus_Callback_seek(void *datasource, opus_int64 offset, int whence)
+{
+	snd_stream_t *stream;
+	int retVal = 0;
+
+	// check if input is valid
+	if(!datasource)
+	{
+		errno = EBADF; 
+		return -1;
+	}
+
+	// snd_stream_t in the generic pointer
+	stream = (snd_stream_t *) datasource;
+
+	// we must map the whence to its Q3 counterpart
+	switch(whence)
+	{
+		case SEEK_SET :
+		{
+			// set the file position in the actual file with the Q3 function
+			retVal = FS_Seek(stream->file, (long) offset, FS_SEEK_SET);
+
+			// something has gone wrong, so we return here
+			if(retVal < 0)
+			{
+			 return retVal;
+			}
+
+			// keep track of file position
+			stream->pos = (int) offset;
+			break;
+		}
+  
+		case SEEK_CUR :
+		{
+			// set the file position in the actual file with the Q3 function
+			retVal = FS_Seek(stream->file, (long) offset, FS_SEEK_CUR);
+
+			// something has gone wrong, so we return here
+			if(retVal < 0)
+			{
+			 return retVal;
+			}
+
+			// keep track of file position
+			stream->pos += (int) offset;
+			break;
+		}
+ 
+		case SEEK_END :
+		{
+			// set the file position in the actual file with the Q3 function
+			retVal = FS_Seek(stream->file, (long) offset, FS_SEEK_END);
+
+			// something has gone wrong, so we return here
+			if(retVal < 0)
+			{
+			 return retVal;
+			}
+
+			// keep track of file position
+			stream->pos = stream->length + (int) offset;
+			break;
+		}
+  
+		default :
+		{
+			// unknown whence, so we return an error
+			errno = EINVAL;
+			return -1;
+		}
+	}
+
+	// stream->pos shouldn't be smaller than zero or bigger than the filesize
+	stream->pos = (stream->pos < 0) ? 0 : stream->pos;
+	stream->pos = (stream->pos > stream->length) ? stream->length : stream->pos;
+
+	return 0;
+}
+
+// fclose() replacement
+int S_OggOpus_Callback_close(void *datasource)
+{
+	// we do nothing here and close all things manually in S_OggOpus_CodecCloseStream()
+	return 0;
+}
+
+// ftell() replacement
+opus_int64 S_OggOpus_Callback_tell(void *datasource)
+{
+	snd_stream_t   *stream;
+
+	// check if input is valid
+	if(!datasource)
+	{
+		errno = EBADF;
+		return -1;
+	}
+
+	// snd_stream_t in the generic pointer
+	stream = (snd_stream_t *) datasource;
+
+	return (opus_int64) FS_FTell(stream->file);
+}
+
+// the callback structure
+const OpusFileCallbacks S_OggOpus_Callbacks =
+{
+ &S_OggOpus_Callback_read,
+ &S_OggOpus_Callback_seek,
+ &S_OggOpus_Callback_tell,
+ &S_OggOpus_Callback_close
+};
+
+/*
+=================
+S_OggOpus_CodecOpenStream
+=================
+*/
+snd_stream_t *S_OggOpus_CodecOpenStream(const char *filename)
+{
+	snd_stream_t *stream;
+
+	// Opus codec control structure
+	OggOpusFile *of;
+
+	// some variables used to get informations about the file
+	const OpusHead *opusInfo;
+	ogg_int64_t numSamples;
+
+	// check if input is valid
+	if(!filename)
+	{
+		return NULL;
+	}
+
+	// Open the stream
+	stream = S_CodecUtilOpen(filename, &opus_codec);
+	if(!stream)
+	{
+		return NULL;
+	}
+
+	// open the codec with our callbacks and stream as the generic pointer
+	of = op_open_callbacks(stream, &S_OggOpus_Callbacks, NULL, 0, NULL );
+	if (!of)
+	{
+		S_CodecUtilClose(&stream);
+
+		return NULL;
+	}
+
+	// the stream must be seekable
+	if(!op_seekable(of))
+	{
+		op_free(of);
+
+		S_CodecUtilClose(&stream);
+
+		return NULL;
+	}
+
+	// get the info about channels and rate
+	opusInfo = op_head(of, -1);
+	if(!opusInfo)
+	{
+		op_free(of);
+
+		S_CodecUtilClose(&stream);
+
+		return NULL;
+	}
+
+	if(opusInfo->stream_count != 1)
+	{
+		op_free(of);
+
+		S_CodecUtilClose(&stream);
+
+		Com_Printf("Only Ogg Opus files with one stream are support\n");
+		return NULL;
+	}
+
+	if(opusInfo->channel_count != 1 && opusInfo->channel_count != 2)
+	{
+		op_free(of);
+
+		S_CodecUtilClose(&stream);
+
+		Com_Printf("Only mono and stereo Ogg Opus files are supported\n");
+		return NULL;
+	}
+
+	// get the number of sample-frames in the file
+	numSamples = op_pcm_total(of, -1);
+
+	// fill in the info-structure in the stream
+	stream->info.rate = 48000;
+	stream->info.width = OPUS_SAMPLEWIDTH;
+	stream->info.channels = opusInfo->channel_count;
+	stream->info.samples = numSamples;
+	stream->info.size = stream->info.samples * stream->info.channels * stream->info.width;
+	stream->info.dataofs = 0;
+
+	// We use stream->pos for the file pointer in the compressed ogg file
+	stream->pos = 0;
+	
+	// We use the generic pointer in stream for the opus codec control structure
+	stream->ptr = of;
+
+	return stream;
+}
+
+/*
+=================
+S_OggOpus_CodecCloseStream
+=================
+*/
+void S_OggOpus_CodecCloseStream(snd_stream_t *stream)
+{
+	// check if input is valid
+	if(!stream)
+	{
+		return;
+	}
+	
+	// let the opus codec cleanup its stuff
+	op_free((OggOpusFile *) stream->ptr);
+
+	// close the stream
+	S_CodecUtilClose(&stream);
+}
+
+/*
+=================
+S_OggOpus_CodecReadStream
+=================
+*/
+int S_OggOpus_CodecReadStream(snd_stream_t *stream, int bytes, void *buffer)
+{
+	// buffer handling
+	int samplesRead, samplesLeft, c;
+	opus_int16 *bufPtr;
+
+	// check if input is valid
+	if(!(stream && buffer))
+	{
+		return 0;
+	}
+
+	if(bytes <= 0)
+	{
+		return 0;
+	}
+
+	samplesRead = 0;
+	samplesLeft = bytes / stream->info.channels / stream->info.width;
+	bufPtr = (opus_int16*)buffer;
+
+	if(samplesLeft <= 0)
+	{
+		return 0;
+	}
+
+	// cycle until we have the requested or all available bytes read
+	while(-1)
+	{
+		// read some samples from the opus codec
+		c = op_read((OggOpusFile *) stream->ptr, bufPtr + samplesRead * stream->info.channels, samplesLeft * stream->info.channels, NULL);
+		
+		// no more samples are left
+		if(c <= 0)
+		{
+			break;
+		}
+
+		samplesRead += c;
+		samplesLeft -= c;
+  
+		// we have enough samples
+		if(samplesLeft <= 0)
+		{
+			break;
+		}
+	}
+
+	return samplesRead * stream->info.channels * stream->info.width;
+}
+
+/*
+=====================================================================
+S_OggOpus_CodecLoad
+
+We handle S_OggOpus_CodecLoad as a special case of the streaming functions 
+where we read the whole stream at once.
+======================================================================
+*/
+void *S_OggOpus_CodecLoad(const char *filename, snd_info_t *info)
+{
+	snd_stream_t *stream;
+	byte *buffer;
+	int bytesRead;
+	
+	// check if input is valid
+	if(!(filename && info))
+	{
+		return NULL;
+	}
+	
+	// open the file as a stream
+	stream = S_OggOpus_CodecOpenStream(filename);
+	if(!stream)
+	{
+		return NULL;
+	}
+	
+	// copy over the info
+	info->rate = stream->info.rate;
+	info->width = stream->info.width;
+	info->channels = stream->info.channels;
+	info->samples = stream->info.samples;
+	info->size = stream->info.size;
+	info->dataofs = stream->info.dataofs;
+
+	// allocate a buffer
+	// this buffer must be free-ed by the caller of this function
+    	buffer = (byte*)Hunk_AllocateTempMemory(info->size);
+	if(!buffer)
+	{
+		S_OggOpus_CodecCloseStream(stream);
+	
+		return NULL;	
+	}
+
+	// fill the buffer
+	bytesRead = S_OggOpus_CodecReadStream(stream, info->size, buffer);
+	
+	// we don't even have read a single byte
+	if(bytesRead <= 0)
+	{
+		Hunk_FreeTempMemory(buffer);
+		S_OggOpus_CodecCloseStream(stream);
+
+		return NULL;	
+	}
+
+	S_OggOpus_CodecCloseStream(stream);
+	
+	return buffer;
+}
+
+#endif // USE_CODEC_OPUS
diff --git a/src/client/snd_codec_wav.cpp b/src/client/snd_codec_wav.cpp
new file mode 100644
index 0000000..a4016e2
--- /dev/null
+++ b/src/client/snd_codec_wav.cpp
@@ -0,0 +1,293 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2005 Stuart Dalton (badcdev@gmail.com)
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include "client.h"
+#include "snd_codec.h"
+
+/*
+=================
+FGetLittleLong
+=================
+*/
+static int FGetLittleLong( fileHandle_t f ) {
+	int		v;
+
+	FS_Read( &v, sizeof(v), f );
+
+	return LittleLong( v);
+}
+
+/*
+=================
+FGetLittleShort
+=================
+*/
+static short FGetLittleShort( fileHandle_t f ) {
+	short	v;
+
+	FS_Read( &v, sizeof(v), f );
+
+	return LittleShort( v);
+}
+
+/*
+=================
+S_ReadChunkInfo
+=================
+*/
+static int S_ReadChunkInfo(fileHandle_t f, char *name)
+{
+	int len, r;
+
+	name[4] = 0;
+
+	r = FS_Read(name, 4, f);
+	if(r != 4)
+		return -1;
+
+	len = FGetLittleLong(f);
+	if( len < 0 ) {
+		Com_Printf( S_COLOR_YELLOW "WARNING: Negative chunk length\n" );
+		return -1;
+	}
+
+	return len;
+}
+
+/*
+=================
+S_FindRIFFChunk
+
+Returns the length of the data in the chunk, or -1 if not found
+=================
+*/
+static int S_FindRIFFChunk( fileHandle_t f, const char *chunk ) {
+	char	name[5];
+	int		len;
+
+	while( ( len = S_ReadChunkInfo(f, name) ) >= 0 )
+	{
+		// If this is the right chunk, return
+		if( !Q_strncmp( name, chunk, 4 ) )
+			return len;
+
+		len = PAD( len, 2 );
+
+		// Not the right chunk - skip it
+		FS_Seek( f, len, FS_SEEK_CUR );
+	}
+
+	return -1;
+}
+
+/*
+=================
+S_ByteSwapRawSamples
+=================
+*/
+static void S_ByteSwapRawSamples( int samples, int width, int s_channels, const byte *data ) {
+	int		i;
+
+	if ( width != 2 ) {
+		return;
+	}
+	if ( LittleShort( 256 ) == 256 ) {
+		return;
+	}
+
+	if ( s_channels == 2 ) {
+		samples <<= 1;
+	}
+	for ( i = 0 ; i < samples ; i++ ) {
+		((short *)data)[i] = LittleShort( ((short *)data)[i] );
+	}
+}
+
+/*
+=================
+S_ReadRIFFHeader
+=================
+*/
+static bool S_ReadRIFFHeader(fileHandle_t file, snd_info_t *info)
+{
+	char dump[16];
+	int bits;
+	int fmtlen = 0;
+
+	// skip the riff wav header
+	FS_Read(dump, 12, file);
+
+	// Scan for the format chunk
+	if((fmtlen = S_FindRIFFChunk(file, "fmt ")) < 0)
+	{
+		Com_Printf( S_COLOR_RED "ERROR: Couldn't find \"fmt\" chunk\n");
+		return false;
+	}
+
+	// Save the parameters
+	FGetLittleShort(file); // wav_format
+	info->channels = FGetLittleShort(file);
+	info->rate = FGetLittleLong(file);
+	FGetLittleLong(file);
+	FGetLittleShort(file);
+	bits = FGetLittleShort(file);
+
+	if( bits < 8 )
+	{
+	  Com_Printf( S_COLOR_RED "ERROR: Less than 8 bit sound is not supported\n");
+	  return false;
+	}
+
+	info->width = bits / 8;
+	info->dataofs = 0;
+
+	// Skip the rest of the format chunk if required
+	if(fmtlen > 16)
+	{
+		fmtlen -= 16;
+		FS_Seek( file, fmtlen, FS_SEEK_CUR );
+	}
+
+	// Scan for the data chunk
+	if( (info->size = S_FindRIFFChunk(file, "data")) < 0)
+	{
+		Com_Printf( S_COLOR_RED "ERROR: Couldn't find \"data\" chunk\n");
+		return false;
+	}
+	info->samples = (info->size / info->width) / info->channels;
+
+	return true;
+}
+
+// WAV codec
+snd_codec_t wav_codec =
+{
+	"wav",
+	S_WAV_CodecLoad,
+	S_WAV_CodecOpenStream,
+	S_WAV_CodecReadStream,
+	S_WAV_CodecCloseStream,
+	NULL
+};
+
+/*
+=================
+S_WAV_CodecLoad
+=================
+*/
+void *S_WAV_CodecLoad(const char *filename, snd_info_t *info)
+{
+	fileHandle_t file;
+	void *buffer;
+
+	// Try to open the file
+	FS_FOpenFileRead(filename, &file, true);
+	if(!file)
+	{
+		return NULL;
+	}
+
+	// Read the RIFF header
+	if(!S_ReadRIFFHeader(file, info))
+	{
+		FS_FCloseFile(file);
+		Com_Printf( S_COLOR_RED "ERROR: Incorrect/unsupported format in \"%s\"\n",
+				filename);
+		return NULL;
+	}
+
+	// Allocate some memory
+	buffer = Hunk_AllocateTempMemory(info->size);
+	if(!buffer)
+	{
+		FS_FCloseFile(file);
+		Com_Printf( S_COLOR_RED "ERROR: Out of memory reading \"%s\"\n",
+				filename);
+		return NULL;
+	}
+
+	// Read, byteswap
+	FS_Read(buffer, info->size, file);
+	S_ByteSwapRawSamples(info->samples, info->width, info->channels, (byte *)buffer);
+
+	// Close and return
+	FS_FCloseFile(file);
+	return buffer;
+}
+
+/*
+=================
+S_WAV_CodecOpenStream
+=================
+*/
+snd_stream_t *S_WAV_CodecOpenStream(const char *filename)
+{
+	snd_stream_t *rv;
+
+	// Open
+	rv = S_CodecUtilOpen(filename, &wav_codec);
+	if(!rv)
+		return NULL;
+
+	// Read the RIFF header
+	if(!S_ReadRIFFHeader(rv->file, &rv->info))
+	{
+		S_CodecUtilClose(&rv);
+		return NULL;
+	}
+
+	return rv;
+}
+
+/*
+=================
+S_WAV_CodecCloseStream
+=================
+*/
+void S_WAV_CodecCloseStream(snd_stream_t *stream)
+{
+	S_CodecUtilClose(&stream);
+}
+
+/*
+=================
+S_WAV_CodecReadStream
+=================
+*/
+int S_WAV_CodecReadStream(snd_stream_t *stream, int bytes, void *buffer)
+{
+	int remaining = stream->info.size - stream->pos;
+	int samples;
+
+	if(remaining <= 0)
+		return 0;
+	if(bytes > remaining)
+		bytes = remaining;
+	stream->pos += bytes;
+	samples = (bytes / stream->info.width) / stream->info.channels;
+	FS_Read(buffer, bytes, stream->file);
+	S_ByteSwapRawSamples(samples, stream->info.width, stream->info.channels, (byte*)buffer);
+	return bytes;
+}
diff --git a/src/client/snd_dma.cpp b/src/client/snd_dma.cpp
new file mode 100644
index 0000000..bef2b69
--- /dev/null
+++ b/src/client/snd_dma.cpp
@@ -0,0 +1,1644 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+/*****************************************************************************
+ * name:		snd_dma.c
+ *
+ * desc:		main control for any streaming sound output device
+ *
+ * $Archive: /MissionPack/code/client/snd_dma.c $
+ *
+ *****************************************************************************/
+
+#include "snd_local.h"
+#include "snd_codec.h"
+#include "client.h"
+
+void S_Update_( void );
+void S_Base_StopAllSounds(void);
+void S_Base_StopBackgroundTrack( void );
+
+snd_stream_t	*s_backgroundStream = NULL;
+static char		s_backgroundLoop[MAX_QPATH];
+//static char		s_backgroundMusic[MAX_QPATH]; //TTimo: unused
+
+
+// =======================================================================
+// Internal sound data & structures
+// =======================================================================
+
+// only begin attenuating sound volumes when outside the FULLVOLUME range
+#define		SOUND_FULLVOLUME	80
+
+#define		SOUND_ATTENUATE		0.0008f
+
+channel_t   s_channels[MAX_CHANNELS];
+channel_t   loop_channels[MAX_CHANNELS];
+int			numLoopChannels;
+
+static bool s_soundStarted;
+static bool s_soundMuted;
+
+dma_t		dma;
+
+static int			listener_number;
+static vec3_t		listener_origin;
+static vec3_t		listener_axis[3];
+
+int			s_soundtime;		// sample PAIRS
+int   		s_paintedtime; 		// sample PAIRS
+
+// MAX_SFX may be larger than MAX_SOUNDS because
+// of custom player sounds
+#define		MAX_SFX			4096
+sfx_t		s_knownSfx[MAX_SFX];
+int			s_numSfx = 0;
+
+#define		LOOP_HASH		128
+static	sfx_t		*sfxHash[LOOP_HASH];
+
+cvar_t		*s_testsound;
+cvar_t		*s_show;
+cvar_t		*s_mixahead;
+cvar_t		*s_mixPreStep;
+
+static loopSound_t		loopSounds[MAX_GENTITIES];
+static	channel_t		*freelist = NULL;
+
+int						s_rawend[MAX_RAW_STREAMS];
+portable_samplepair_t s_rawsamples[MAX_RAW_STREAMS][MAX_RAW_SAMPLES];
+
+
+// ====================================================================
+// User-setable variables
+// ====================================================================
+
+
+void S_Base_SoundInfo(void) {	
+	Com_Printf("----- Sound Info -----\n" );
+	if (!s_soundStarted) {
+		Com_Printf ("sound system not started\n");
+	} else {
+		Com_Printf("%5d stereo\n", dma.channels - 1);
+		Com_Printf("%5d samples\n", dma.samples);
+		Com_Printf("%5d samplebits\n", dma.samplebits);
+		Com_Printf("%5d submission_chunk\n", dma.submission_chunk);
+		Com_Printf("%5d speed\n", dma.speed);
+		Com_Printf("%p dma buffer\n", dma.buffer);
+		if ( s_backgroundStream ) {
+			Com_Printf("Background file: %s\n", s_backgroundLoop );
+		} else {
+			Com_Printf("No background file.\n" );
+		}
+
+	}
+	Com_Printf("----------------------\n" );
+}
+
+
+#ifdef USE_VOIP
+static
+void S_Base_StartCapture( void )
+{
+	// !!! FIXME: write me.
+}
+
+static
+int S_Base_AvailableCaptureSamples( void )
+{
+	// !!! FIXME: write me.
+	return 0;
+}
+
+static
+void S_Base_Capture( int samples, byte *data )
+{
+	// !!! FIXME: write me.
+}
+
+static
+void S_Base_StopCapture( void )
+{
+	// !!! FIXME: write me.
+}
+
+static
+void S_Base_MasterGain( float val )
+{
+	// !!! FIXME: write me.
+}
+#endif
+
+
+
+/*
+=================
+S_Base_SoundList
+=================
+*/
+void S_Base_SoundList( void ) {
+	int		i;
+	sfx_t	*sfx;
+	int		size, total;
+	char	type[4][16];
+	char	mem[2][16];
+
+	strcpy(type[0], "16bit");
+	strcpy(type[1], "adpcm");
+	strcpy(type[2], "daub4");
+	strcpy(type[3], "mulaw");
+	strcpy(mem[0], "paged out");
+	strcpy(mem[1], "resident ");
+	total = 0;
+	for (sfx=s_knownSfx, i=0 ; i<s_numSfx ; i++, sfx++) {
+		size = sfx->soundLength;
+		total += size;
+		Com_Printf("%6i[%s] : %s[%s]\n", size, type[sfx->soundCompressionMethod],
+				sfx->soundName, mem[sfx->inMemory] );
+	}
+	Com_Printf ("Total resident: %i\n", total);
+	S_DisplayFreeMemory();
+}
+
+
+
+void S_ChannelFree(channel_t *v) {
+	v->thesfx = NULL;
+	*(channel_t **)v = freelist;
+	freelist = (channel_t*)v;
+}
+
+channel_t*	S_ChannelMalloc( void ) {
+	channel_t *v;
+	if (freelist == NULL) {
+		return NULL;
+	}
+	v = freelist;
+	freelist = *(channel_t **)freelist;
+	v->allocTime = Com_Milliseconds();
+	return v;
+}
+
+void S_ChannelSetup( void ) {
+	channel_t *p, *q;
+
+	// clear all the sounds so they don't
+	::memset( s_channels, 0, sizeof( s_channels ) );
+
+	p = s_channels;;
+	q = p + MAX_CHANNELS;
+	while (--q > p) {
+		*(channel_t **)q = q-1;
+	}
+	
+	*(channel_t **)q = NULL;
+	freelist = p + MAX_CHANNELS - 1;
+	Com_DPrintf("Channel memory manager started\n");
+}
+
+
+
+// =======================================================================
+// Load a sound
+// =======================================================================
+
+/*
+================
+return a hash value for the sfx name
+================
+*/
+static long S_HashSFXName(const char *name) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (name[i] != '\0') {
+		letter = tolower(name[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (LOOP_HASH-1);
+	return hash;
+}
+
+/*
+==================
+S_FindName
+
+Will allocate a new sfx if it isn't found
+==================
+*/
+static sfx_t *S_FindName( const char *name ) {
+	int		i;
+	int		hash;
+
+	sfx_t	*sfx;
+
+	if (!name) {
+		Com_Error(ERR_FATAL, "Sound name is NULL");
+	}
+
+	if (!name[0]) {
+		Com_Printf( S_COLOR_YELLOW "WARNING: Sound name is empty\n" );
+		return NULL;
+	}
+
+	if (strlen(name) >= MAX_QPATH) {
+		Com_Printf( S_COLOR_YELLOW "WARNING: Sound name is too long: %s\n", name );
+		return NULL;
+	}
+
+	if (name[0] == '*') {
+		Com_Printf( S_COLOR_YELLOW "WARNING: Tried to load player sound directly: %s\n", name );
+		return NULL;
+	}
+
+	hash = S_HashSFXName(name);
+
+	sfx = sfxHash[hash];
+	// see if already loaded
+	while (sfx) {
+		if (!Q_stricmp(sfx->soundName, name) ) {
+			return sfx;
+		}
+		sfx = sfx->next;
+	}
+
+	// find a free sfx
+	for (i=0 ; i < s_numSfx ; i++) {
+		if (!s_knownSfx[i].soundName[0]) {
+			break;
+		}
+	}
+
+	if (i == s_numSfx) {
+		if (s_numSfx == MAX_SFX) {
+			Com_Error (ERR_FATAL, "S_FindName: out of sfx_t");
+		}
+		s_numSfx++;
+	}
+	
+	sfx = &s_knownSfx[i];
+	::memset (sfx, 0, sizeof(*sfx));
+	strcpy (sfx->soundName, name);
+
+	sfx->next = sfxHash[hash];
+	sfxHash[hash] = sfx;
+
+	return sfx;
+}
+
+/*
+=================
+S_DefaultSound
+=================
+*/
+void S_DefaultSound( sfx_t *sfx ) {
+	
+	int		i;
+
+	sfx->soundLength = 512;
+	sfx->soundData = SND_malloc();
+	sfx->soundData->next = NULL;
+
+
+	for ( i = 0 ; i < sfx->soundLength ; i++ ) {
+		sfx->soundData->sndChunk[i] = i;
+	}
+}
+
+/*
+===================
+S_DisableSounds
+
+Disables sounds until the next S_BeginRegistration.
+This is called when the hunk is cleared and the sounds
+are no longer valid.
+===================
+*/
+void S_Base_DisableSounds( void ) {
+	S_Base_StopAllSounds();
+	s_soundMuted = true;
+}
+
+/*
+==================
+S_RegisterSound
+
+Creates a default buzz sound if the file can't be loaded
+==================
+*/
+sfxHandle_t	S_Base_RegisterSound( const char *name, bool compressed ) {
+	sfx_t	*sfx;
+
+	compressed = false;
+	if (!s_soundStarted) {
+		return 0;
+	}
+
+	sfx = S_FindName( name );
+	if ( !sfx ) {
+		return 0;
+	}
+
+	if ( sfx->soundData ) {
+		if ( sfx->defaultSound ) {
+			Com_Printf( S_COLOR_YELLOW "WARNING: could not find %s - using default\n", sfx->soundName );
+			return 0;
+		}
+		return sfx - s_knownSfx;
+	}
+
+	sfx->inMemory = false;
+	sfx->soundCompressed = compressed;
+
+  S_memoryLoad(sfx);
+
+	if ( sfx->defaultSound ) {
+		Com_Printf( S_COLOR_YELLOW "WARNING: could not find %s - using default\n", sfx->soundName );
+		return 0;
+	}
+
+	return sfx - s_knownSfx;
+}
+
+/*
+==================
+S_Base_SoundDuration
+==================
+*/
+static int S_Base_SoundDuration( sfxHandle_t handle ) {
+	if ( handle < 0 || handle >= s_numSfx ) {
+		Com_Printf( S_COLOR_YELLOW "S_Base_SoundDuration: handle %i out of range\n", handle );
+		return 0;
+	}
+	return s_knownSfx[ handle ].duration;
+}
+
+
+
+/*
+=====================
+S_BeginRegistration
+
+=====================
+*/
+void S_Base_BeginRegistration( void ) {
+	s_soundMuted = false;		// we can play again
+
+	if (s_numSfx == 0) {
+		SND_setup();
+
+		::memset(s_knownSfx, '\0', sizeof(s_knownSfx));
+		::memset(sfxHash, '\0', sizeof(sfx_t *) * LOOP_HASH);
+
+		S_Base_RegisterSound("sound/feedback/hit.wav", false);		// changed to a sound in baseq3
+	}
+}
+
+void S_memoryLoad(sfx_t	*sfx) {
+	// load the sound file
+	if ( !S_LoadSound ( sfx ) ) {
+//		Com_Printf( S_COLOR_YELLOW "WARNING: couldn't load sound: %s\n", sfx->soundName );
+		sfx->defaultSound = true;
+	}
+	sfx->inMemory = true;
+}
+
+//=============================================================================
+
+/*
+=================
+S_SpatializeOrigin
+
+Used for spatializing s_channels
+=================
+*/
+void S_SpatializeOrigin (vec3_t origin, int master_vol, int *left_vol, int *right_vol)
+{
+    vec_t		dot;
+    vec_t		dist;
+    vec_t		lscale, rscale, scale;
+    vec3_t		source_vec;
+    vec3_t		vec;
+
+	const float dist_mult = SOUND_ATTENUATE;
+	
+	// calculate stereo seperation and distance attenuation
+	VectorSubtract(origin, listener_origin, source_vec);
+
+	dist = VectorNormalize(source_vec);
+	dist -= SOUND_FULLVOLUME;
+	if (dist < 0)
+		dist = 0;			// close enough to be at full volume
+	dist *= dist_mult;		// different attenuation levels
+	
+	VectorRotate( source_vec, listener_axis, vec );
+
+	dot = -vec[1];
+
+	if (dma.channels == 1)
+	{ // no attenuation = no spatialization
+		rscale = 1.0;
+		lscale = 1.0;
+	}
+	else
+	{
+		rscale = 0.5 * (1.0 + dot);
+		lscale = 0.5 * (1.0 - dot);
+		if ( rscale < 0 ) {
+			rscale = 0;
+		}
+		if ( lscale < 0 ) {
+			lscale = 0;
+		}
+	}
+
+	// add in distance effect
+	scale = (1.0 - dist) * rscale;
+	*right_vol = (master_vol * scale);
+	if (*right_vol < 0)
+		*right_vol = 0;
+
+	scale = (1.0 - dist) * lscale;
+	*left_vol = (master_vol * scale);
+	if (*left_vol < 0)
+		*left_vol = 0;
+}
+
+// =======================================================================
+// Start a sound effect
+// =======================================================================
+
+/*
+=================
+S_Base_HearingThroughEntity
+
+Also see S_AL_HearingThroughEntity
+=================
+*/
+static bool S_Base_HearingThroughEntity( int entityNum, vec3_t origin )
+{
+	float	distanceSq;
+	vec3_t	sorigin;
+
+	if (origin)
+		VectorCopy(origin, sorigin);
+	else
+		VectorCopy(loopSounds[entityNum].origin, sorigin);
+
+	if( listener_number == entityNum )
+	{
+		// This is an outrageous hack to detect
+		// whether or not the player is rendering in third person or not. We can't
+		// ask the renderer because the renderer has no notion of entities and we
+		// can't ask cgame since that would involve changing the API and hence mod
+		// compatibility. I don't think there is any way around this, but I'll leave
+		// the FIXME just in case anyone has a bright idea.
+		distanceSq = DistanceSquared(
+				sorigin,
+				listener_origin );
+
+		if( distanceSq > THIRD_PERSON_THRESHOLD_SQ )
+			return false; //we're the player, but third person
+		else
+			return true;  //we're the player
+	}
+	else
+		return false; //not the player
+}
+
+/*
+====================
+S_Base_StartSoundEx
+
+Validates the parms and ques the sound up
+if origin is NULL, the sound will be dynamically sourced from the entity
+Entchannel 0 will never override a playing sound
+====================
+*/
+static void S_Base_StartSoundEx( vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfxHandle, bool localSound ) {
+	channel_t	*ch;
+	sfx_t		*sfx;
+  int i, oldest, chosen, time;
+  int	inplay, allowed;
+	bool	fullVolume;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( !origin && ( entityNum < 0 || entityNum >= MAX_GENTITIES ) ) {
+		Com_Error( ERR_DROP, "S_StartSound: bad entitynum %i", entityNum );
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Printf( S_COLOR_YELLOW "S_StartSound: handle %i out of range\n", sfxHandle );
+		return;
+	}
+
+	sfx = &s_knownSfx[ sfxHandle ];
+
+	if (sfx->inMemory == false) {
+		S_memoryLoad(sfx);
+	}
+
+	if ( s_show->integer == 1 ) {
+		Com_Printf( "%i : %s\n", s_paintedtime, sfx->soundName );
+	}
+
+	time = Com_Milliseconds();
+
+//	Com_Printf("playing %s\n", sfx->soundName);
+	// pick a channel to play on
+
+	allowed = 4;
+	if (entityNum == listener_number) {
+		allowed = 8;
+	}
+
+	fullVolume = false;
+	if (localSound || S_Base_HearingThroughEntity(entityNum, origin)) {
+		fullVolume = true;
+	}
+
+	ch = s_channels;
+	inplay = 0;
+	for ( i = 0; i < MAX_CHANNELS ; i++, ch++ ) {		
+		if (ch->entnum == entityNum && ch->thesfx == sfx) {
+			if (time - ch->allocTime < 50) {
+//				if (Cvar_VariableValue( "cg_showmiss" )) {
+//					Com_Printf("double sound start\n");
+//				}
+				return;
+			}
+			inplay++;
+		}
+	}
+
+	if (inplay>allowed) {
+		return;
+	}
+
+	sfx->lastTimeUsed = time;
+
+	ch = S_ChannelMalloc();	// entityNum, entchannel);
+	if (!ch) {
+		ch = s_channels;
+
+		oldest = sfx->lastTimeUsed;
+		chosen = -1;
+		for ( i = 0 ; i < MAX_CHANNELS ; i++, ch++ ) {
+			if (ch->entnum != listener_number && ch->entnum == entityNum && ch->allocTime<oldest && ch->entchannel != CHAN_ANNOUNCER) {
+				oldest = ch->allocTime;
+				chosen = i;
+			}
+		}
+		if (chosen == -1) {
+			ch = s_channels;
+			for ( i = 0 ; i < MAX_CHANNELS ; i++, ch++ ) {
+				if (ch->entnum != listener_number && ch->allocTime<oldest && ch->entchannel != CHAN_ANNOUNCER) {
+					oldest = ch->allocTime;
+					chosen = i;
+				}
+			}
+			if (chosen == -1) {
+				ch = s_channels;
+				if (ch->entnum == listener_number) {
+					for ( i = 0 ; i < MAX_CHANNELS ; i++, ch++ ) {
+						if (ch->allocTime<oldest) {
+							oldest = ch->allocTime;
+							chosen = i;
+						}
+					}
+				}
+				if (chosen == -1) {
+					Com_DPrintf("dropping sound\n");
+					return;
+				}
+			}
+		}
+		ch = &s_channels[chosen];
+		ch->allocTime = sfx->lastTimeUsed;
+	}
+
+	if (origin) {
+		VectorCopy (origin, ch->origin);
+		ch->fixed_origin = true;
+	} else {
+		ch->fixed_origin = false;
+	}
+
+	ch->master_vol = 127;
+	ch->entnum = entityNum;
+	ch->thesfx = sfx;
+	ch->startSample = START_SAMPLE_IMMEDIATE;
+	ch->entchannel = entchannel;
+	ch->leftvol = ch->master_vol;		// these will get calced at next spatialize
+	ch->rightvol = ch->master_vol;		// unless the game isn't running
+	ch->doppler = false;
+	ch->fullVolume = fullVolume;
+}
+
+/*
+====================
+S_StartSound
+
+if origin is NULL, the sound will be dynamically sourced from the entity
+====================
+*/
+void S_Base_StartSound( vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfxHandle ) {
+	S_Base_StartSoundEx( origin, entityNum, entchannel, sfxHandle, false );
+}
+
+/*
+==================
+S_StartLocalSound
+==================
+*/
+void S_Base_StartLocalSound( sfxHandle_t sfxHandle, int channelNum ) {
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Printf( S_COLOR_YELLOW "S_StartLocalSound: handle %i out of range\n", sfxHandle );
+		return;
+	}
+
+	S_Base_StartSoundEx( NULL, listener_number, channelNum, sfxHandle, true );
+}
+
+
+/*
+==================
+S_ClearSoundBuffer
+
+If we are about to perform file access, clear the buffer
+so sound doesn't stutter.
+==================
+*/
+void S_Base_ClearSoundBuffer( void ) {
+	int		clear;
+		
+	if (!s_soundStarted)
+		return;
+
+	// stop looping sounds
+	::memset(loopSounds, 0, MAX_GENTITIES*sizeof(loopSound_t));
+	::memset(loop_channels, 0, MAX_CHANNELS*sizeof(channel_t));
+	numLoopChannels = 0;
+
+	S_ChannelSetup();
+
+	::memset(s_rawend, '\0', sizeof (s_rawend));
+
+	if (dma.samplebits == 8)
+		clear = 0x80;
+	else
+		clear = 0;
+
+	SNDDMA_BeginPainting ();
+	if (dma.buffer)
+		::memset(dma.buffer, clear, dma.samples * dma.samplebits/8);
+	SNDDMA_Submit ();
+}
+
+/*
+==================
+S_StopAllSounds
+==================
+*/
+void S_Base_StopAllSounds(void) {
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	// stop the background music
+	S_Base_StopBackgroundTrack();
+
+	S_Base_ClearSoundBuffer ();
+}
+
+/*
+==============================================================
+
+continuous looping sounds are added each frame
+
+==============================================================
+*/
+
+void S_Base_StopLoopingSound(int entityNum) {
+	loopSounds[entityNum].active = false;
+//	loopSounds[entityNum].sfx = 0;
+	loopSounds[entityNum].kill = false;
+}
+
+/*
+==================
+S_ClearLoopingSounds
+
+==================
+*/
+void S_Base_ClearLoopingSounds( bool killall )
+{
+	int i;
+	for ( i = 0 ; i < MAX_GENTITIES ; i++) {
+		if (killall || loopSounds[i].kill == true || (loopSounds[i].sfx && loopSounds[i].sfx->soundLength == 0)) {
+			S_Base_StopLoopingSound(i);
+		}
+	}
+	numLoopChannels = 0;
+}
+
+/*
+==================
+S_AddLoopingSound
+
+Called during entity generation for a frame
+Include velocity in case I get around to doing doppler...
+==================
+*/
+void S_Base_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfxHandle ) {
+	sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Printf( S_COLOR_YELLOW "S_AddLoopingSound: handle %i out of range\n", sfxHandle );
+		return;
+	}
+
+	sfx = &s_knownSfx[ sfxHandle ];
+
+	if (sfx->inMemory == false) {
+		S_memoryLoad(sfx);
+	}
+
+	if ( !sfx->soundLength ) {
+		Com_Error( ERR_DROP, "%s has length 0", sfx->soundName );
+	}
+
+	VectorCopy( origin, loopSounds[entityNum].origin );
+	VectorCopy( velocity, loopSounds[entityNum].velocity );
+	loopSounds[entityNum].active = true;
+	loopSounds[entityNum].kill = true;
+	loopSounds[entityNum].doppler = false;
+	loopSounds[entityNum].oldDopplerScale = 1.0;
+	loopSounds[entityNum].dopplerScale = 1.0;
+	loopSounds[entityNum].sfx = sfx;
+
+	if (s_doppler->integer && VectorLengthSquared(velocity)>0.0) {
+		vec3_t	out;
+		float	lena, lenb;
+
+		loopSounds[entityNum].doppler = true;
+		lena = DistanceSquared(loopSounds[listener_number].origin, loopSounds[entityNum].origin);
+		VectorAdd(loopSounds[entityNum].origin, loopSounds[entityNum].velocity, out);
+		lenb = DistanceSquared(loopSounds[listener_number].origin, out);
+		if ((loopSounds[entityNum].framenum+1) != cls.framecount) {
+			loopSounds[entityNum].oldDopplerScale = 1.0;
+		} else {
+			loopSounds[entityNum].oldDopplerScale = loopSounds[entityNum].dopplerScale;
+		}
+		loopSounds[entityNum].dopplerScale = lenb/(lena*100);
+		if (loopSounds[entityNum].dopplerScale<=1.0) {
+			loopSounds[entityNum].doppler = false;			// don't bother doing the math
+		} else if (loopSounds[entityNum].dopplerScale>MAX_DOPPLER_SCALE) {
+			loopSounds[entityNum].dopplerScale = MAX_DOPPLER_SCALE;
+		}
+	}
+
+	loopSounds[entityNum].framenum = cls.framecount;
+}
+
+/*
+==================
+S_AddLoopingSound
+
+Called during entity generation for a frame
+Include velocity in case I get around to doing doppler...
+==================
+*/
+void S_Base_AddRealLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfxHandle ) {
+	sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Printf( S_COLOR_YELLOW "S_AddRealLoopingSound: handle %i out of range\n", sfxHandle );
+		return;
+	}
+
+	sfx = &s_knownSfx[ sfxHandle ];
+
+	if (sfx->inMemory == false) {
+		S_memoryLoad(sfx);
+	}
+
+	if ( !sfx->soundLength ) {
+		Com_Error( ERR_DROP, "%s has length 0", sfx->soundName );
+	}
+	VectorCopy( origin, loopSounds[entityNum].origin );
+	VectorCopy( velocity, loopSounds[entityNum].velocity );
+	loopSounds[entityNum].sfx = sfx;
+	loopSounds[entityNum].active = true;
+	loopSounds[entityNum].kill = false;
+	loopSounds[entityNum].doppler = false;
+}
+
+
+
+/*
+==================
+S_AddLoopSounds
+
+Spatialize all of the looping sounds.
+All sounds are on the same cycle, so any duplicates can just
+sum up the channel multipliers.
+==================
+*/
+void S_AddLoopSounds (void) {
+	int			i, j, time;
+	int			left_total, right_total, left, right;
+	channel_t	*ch;
+	loopSound_t	*loop, *loop2;
+	static int	loopFrame;
+
+
+	numLoopChannels = 0;
+
+	time = Com_Milliseconds();
+
+	loopFrame++;
+	for ( i = 0 ; i < MAX_GENTITIES ; i++) {
+		loop = &loopSounds[i];
+		if ( !loop->active || loop->mergeFrame == loopFrame ) {
+			continue;	// already merged into an earlier sound
+		}
+
+		if (loop->kill) {
+			S_SpatializeOrigin( loop->origin, 127, &left_total, &right_total);			// 3d
+		} else {
+			S_SpatializeOrigin( loop->origin, 90,  &left_total, &right_total);			// sphere
+		}
+
+		loop->sfx->lastTimeUsed = time;
+
+		for (j=(i+1); j< MAX_GENTITIES ; j++) {
+			loop2 = &loopSounds[j];
+			if ( !loop2->active || loop2->doppler || loop2->sfx != loop->sfx) {
+				continue;
+			}
+			loop2->mergeFrame = loopFrame;
+
+			if (loop2->kill) {
+				S_SpatializeOrigin( loop2->origin, 127, &left, &right);				// 3d
+			} else {
+				S_SpatializeOrigin( loop2->origin, 90,  &left, &right);				// sphere
+			}
+
+			loop2->sfx->lastTimeUsed = time;
+			left_total += left;
+			right_total += right;
+		}
+		if (left_total == 0 && right_total == 0) {
+			continue;		// not audible
+		}
+
+		// allocate a channel
+		ch = &loop_channels[numLoopChannels];
+		
+		if (left_total > 255) {
+			left_total = 255;
+		}
+		if (right_total > 255) {
+			right_total = 255;
+		}
+		
+		ch->master_vol = 127;
+		ch->leftvol = left_total;
+		ch->rightvol = right_total;
+		ch->thesfx = loop->sfx;
+		ch->doppler = loop->doppler;
+		ch->dopplerScale = loop->dopplerScale;
+		ch->oldDopplerScale = loop->oldDopplerScale;
+		ch->fullVolume = false;
+		numLoopChannels++;
+		if (numLoopChannels == MAX_CHANNELS) {
+			return;
+		}
+	}
+}
+
+//=============================================================================
+
+/*
+=================
+S_ByteSwapRawSamples
+
+If raw data has been loaded in little endien binary form, this must be done.
+If raw data was calculated, as with ADPCM, this should not be called.
+=================
+*/
+void S_ByteSwapRawSamples( int samples, int width, int s_channels, const byte *data ) {
+	int		i;
+
+	if ( width != 2 ) {
+		return;
+	}
+	if ( LittleShort( 256 ) == 256 ) {
+		return;
+	}
+
+	if ( s_channels == 2 ) {
+		samples <<= 1;
+	}
+	for ( i = 0 ; i < samples ; i++ ) {
+		((short *)data)[i] = LittleShort( ((short *)data)[i] );
+	}
+}
+
+/*
+============
+S_Base_RawSamples
+
+Music streaming
+============
+*/
+void S_Base_RawSamples( int stream, int samples, int rate, int width, int s_channels, const byte *data, float volume, int entityNum)
+{
+	int		i;
+	int		src, dst;
+	float	scale;
+	int		intVolumeLeft, intVolumeRight;
+	portable_samplepair_t *rawsamples;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( (stream < 0) || (stream >= MAX_RAW_STREAMS) ) {
+		return;
+	}
+
+	rawsamples = s_rawsamples[stream];
+
+	if ( s_muted->integer ) {
+		intVolumeLeft = intVolumeRight = 0;
+	} else {
+		int leftvol, rightvol;
+
+		if ( entityNum >= 0 && entityNum < MAX_GENTITIES ) {
+			// support spatialized raw streams, e.g. for VoIP
+			S_SpatializeOrigin( loopSounds[ entityNum ].origin, 256, &leftvol, &rightvol );
+		} else {
+			leftvol = rightvol = 256;
+		}
+
+		intVolumeLeft = leftvol * volume * s_volume->value;
+		intVolumeRight = rightvol * volume * s_volume->value;
+	}
+
+	if ( s_rawend[stream] < s_soundtime ) {
+		Com_DPrintf( "S_Base_RawSamples: resetting minimum: %i < %i\n", s_rawend[stream], s_soundtime );
+		s_rawend[stream] = s_soundtime;
+	}
+
+	scale = (float)rate / dma.speed;
+
+//Com_Printf ("%i < %i < %i\n", s_soundtime, s_paintedtime, s_rawend[stream]);
+	if (s_channels == 2 && width == 2)
+	{
+		if (scale == 1.0)
+		{	// optimized case
+			for (i=0 ; i<samples ; i++)
+			{
+				dst = s_rawend[stream]&(MAX_RAW_SAMPLES-1);
+				s_rawend[stream]++;
+				rawsamples[dst].left = ((short *)data)[i*2] * intVolumeLeft;
+				rawsamples[dst].right = ((short *)data)[i*2+1] * intVolumeRight;
+			}
+		}
+		else
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend[stream]&(MAX_RAW_SAMPLES-1);
+				s_rawend[stream]++;
+				rawsamples[dst].left = ((short *)data)[src*2] * intVolumeLeft;
+				rawsamples[dst].right = ((short *)data)[src*2+1] * intVolumeRight;
+			}
+		}
+	}
+	else if (s_channels == 1 && width == 2)
+	{
+		for (i=0 ; ; i++)
+		{
+			src = i*scale;
+			if (src >= samples)
+				break;
+			dst = s_rawend[stream]&(MAX_RAW_SAMPLES-1);
+			s_rawend[stream]++;
+			rawsamples[dst].left = ((short *)data)[src] * intVolumeLeft;
+			rawsamples[dst].right = ((short *)data)[src] * intVolumeRight;
+		}
+	}
+	else if (s_channels == 2 && width == 1)
+	{
+		intVolumeLeft *= 256;
+		intVolumeRight *= 256;
+
+		for (i=0 ; ; i++)
+		{
+			src = i*scale;
+			if (src >= samples)
+				break;
+			dst = s_rawend[stream]&(MAX_RAW_SAMPLES-1);
+			s_rawend[stream]++;
+			rawsamples[dst].left = ((char *)data)[src*2] * intVolumeLeft;
+			rawsamples[dst].right = ((char *)data)[src*2+1] * intVolumeRight;
+		}
+	}
+	else if (s_channels == 1 && width == 1)
+	{
+		intVolumeLeft *= 256;
+		intVolumeRight *= 256;
+
+		for (i=0 ; ; i++)
+		{
+			src = i*scale;
+			if (src >= samples)
+				break;
+			dst = s_rawend[stream]&(MAX_RAW_SAMPLES-1);
+			s_rawend[stream]++;
+			rawsamples[dst].left = (((byte *)data)[src]-128) * intVolumeLeft;
+			rawsamples[dst].right = (((byte *)data)[src]-128) * intVolumeRight;
+		}
+	}
+
+	if ( s_rawend[stream] > s_soundtime + MAX_RAW_SAMPLES ) {
+		Com_DPrintf( "S_Base_RawSamples: overflowed %i > %i\n", s_rawend[stream], s_soundtime );
+	}
+}
+
+//=============================================================================
+
+/*
+=====================
+S_UpdateEntityPosition
+
+let the sound system know where an entity currently is
+======================
+*/
+void S_Base_UpdateEntityPosition( int entityNum, const vec3_t origin ) {
+	if ( entityNum < 0 || entityNum >= MAX_GENTITIES ) {
+		Com_Error( ERR_DROP, "S_UpdateEntityPosition: bad entitynum %i", entityNum );
+	}
+	VectorCopy( origin, loopSounds[entityNum].origin );
+}
+
+
+/*
+============
+S_Respatialize
+
+Change the volumes of all the playing sounds for changes in their positions
+============
+*/
+void S_Base_Respatialize( int entityNum, const vec3_t head, vec3_t axis[3], int inwater ) {
+	int			i;
+	channel_t	*ch;
+	vec3_t		origin;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	listener_number = entityNum;
+	VectorCopy(head, listener_origin);
+	VectorCopy(axis[0], listener_axis[0]);
+	VectorCopy(axis[1], listener_axis[1]);
+	VectorCopy(axis[2], listener_axis[2]);
+
+	// update spatialization for dynamic sounds	
+	ch = s_channels;
+	for ( i = 0 ; i < MAX_CHANNELS ; i++, ch++ ) {
+		if ( !ch->thesfx ) {
+			continue;
+		}
+		// local and first person sounds will always be full volume
+		if (ch->fullVolume) {
+			ch->leftvol = ch->master_vol;
+			ch->rightvol = ch->master_vol;
+		} else {
+			if (ch->fixed_origin) {
+				VectorCopy( ch->origin, origin );
+			} else {
+				VectorCopy( loopSounds[ ch->entnum ].origin, origin );
+			}
+
+			S_SpatializeOrigin (origin, ch->master_vol, &ch->leftvol, &ch->rightvol);
+		}
+	}
+
+	// add loopsounds
+	S_AddLoopSounds ();
+}
+
+
+/*
+========================
+S_ScanChannelStarts
+
+Returns true if any new sounds were started since the last mix
+========================
+*/
+bool S_ScanChannelStarts( void ) {
+	channel_t		*ch;
+	int				i;
+	bool		newSamples;
+
+	newSamples = false;
+	ch = s_channels;
+
+	for (i=0; i<MAX_CHANNELS ; i++, ch++) {
+		if ( !ch->thesfx ) {
+			continue;
+		}
+		// if this channel was just started this frame,
+		// set the sample count to it begins mixing
+		// into the very first sample
+		if ( ch->startSample == START_SAMPLE_IMMEDIATE ) {
+			ch->startSample = s_paintedtime;
+			newSamples = true;
+			continue;
+		}
+
+		// if it is completely finished by now, clear it
+		if ( ch->startSample + (ch->thesfx->soundLength) <= s_paintedtime ) {
+			S_ChannelFree(ch);
+		}
+	}
+
+	return newSamples;
+}
+
+/*
+============
+S_Update
+
+Called once each time through the main loop
+============
+*/
+void S_Base_Update( void ) {
+	int			i;
+	int			total;
+	channel_t	*ch;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+//		Com_DPrintf ("not started or muted\n");
+		return;
+	}
+
+	//
+	// debugging output
+	//
+	if ( s_show->integer == 2 ) {
+		total = 0;
+		ch = s_channels;
+		for (i=0 ; i<MAX_CHANNELS; i++, ch++) {
+			if (ch->thesfx && (ch->leftvol || ch->rightvol) ) {
+				Com_Printf ("%d %d %s\n", ch->leftvol, ch->rightvol, ch->thesfx->soundName);
+				total++;
+			}
+		}
+		
+		Com_Printf ("----(%i)---- painted: %i\n", total, s_paintedtime);
+	}
+
+	// add raw data from streamed samples
+	S_UpdateBackgroundTrack();
+
+	// mix some sound
+	S_Update_();
+}
+
+void S_GetSoundtime(void)
+{
+	int		samplepos;
+	static	int		buffers;
+	static	int		oldsamplepos;
+	int		fullsamples;
+	
+	fullsamples = dma.samples / dma.channels;
+
+	if( CL_VideoRecording( ) )
+	{
+		float fps = MIN(cl_aviFrameRate->value, 1000.0f);
+		float frameDuration = MAX(dma.speed / fps, 1.0f) + clc.aviSoundFrameRemainder;
+
+		int msec = (int)frameDuration;
+		s_soundtime += msec;
+		clc.aviSoundFrameRemainder = frameDuration - msec;
+
+		return;
+	}
+
+	// it is possible to miscount buffers if it has wrapped twice between
+	// calls to S_Update.  Oh well.
+	samplepos = SNDDMA_GetDMAPos();
+	if (samplepos < oldsamplepos)
+	{
+		buffers++;					// buffer wrapped
+		
+		if (s_paintedtime > 0x40000000)
+		{	// time to chop things off to avoid 32 bit limits
+			buffers = 0;
+			s_paintedtime = fullsamples;
+			S_Base_StopAllSounds ();
+		}
+	}
+	oldsamplepos = samplepos;
+
+	s_soundtime = buffers*fullsamples + samplepos/dma.channels;
+
+#if 0
+// check to make sure that we haven't overshot
+	if (s_paintedtime < s_soundtime)
+	{
+		Com_DPrintf ("S_Update_ : overflow\n");
+		s_paintedtime = s_soundtime;
+	}
+#endif
+
+	if ( dma.submission_chunk < 256 ) {
+		s_paintedtime = s_soundtime + s_mixPreStep->value * dma.speed;
+	} else {
+		s_paintedtime = s_soundtime + dma.submission_chunk;
+	}
+}
+
+
+void S_Update_(void) {
+	unsigned        endtime;
+	int				samps;
+	static			float	lastTime = 0.0f;
+	float			ma, op;
+	float			thisTime, sane;
+	static			int ot = -1;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	thisTime = Com_Milliseconds();
+
+	// Updates s_soundtime
+	S_GetSoundtime();
+
+	if (s_soundtime == ot) {
+		return;
+	}
+	ot = s_soundtime;
+
+	// clear any sound effects that end before the current time,
+	// and start any new sounds
+	S_ScanChannelStarts();
+
+	sane = thisTime - lastTime;
+	if (sane<11) {
+		sane = 11;			// 85hz
+	}
+
+	ma = s_mixahead->value * dma.speed;
+	op = s_mixPreStep->value + sane*dma.speed*0.01;
+
+	if (op < ma) {
+		ma = op;
+	}
+
+	// mix ahead of current position
+	endtime = s_soundtime + ma;
+
+	// mix to an even submission block size
+	endtime = (endtime + dma.submission_chunk-1)
+		& ~(dma.submission_chunk-1);
+
+	// never mix more than the complete buffer
+	samps = dma.samples >> (dma.channels-1);
+	if (endtime - s_soundtime > samps)
+		endtime = s_soundtime + samps;
+
+
+
+	SNDDMA_BeginPainting ();
+
+	S_PaintChannels (endtime);
+
+	SNDDMA_Submit ();
+
+	lastTime = thisTime;
+}
+
+
+
+/*
+===============================================================================
+
+background music functions
+
+===============================================================================
+*/
+
+/*
+======================
+S_StopBackgroundTrack
+======================
+*/
+void S_Base_StopBackgroundTrack( void ) {
+	if(!s_backgroundStream)
+		return;
+	S_CodecCloseStream(s_backgroundStream);
+	s_backgroundStream = NULL;
+	s_rawend[0] = 0;
+}
+
+/*
+======================
+S_OpenBackgroundStream
+======================
+*/
+static void S_OpenBackgroundStream( const char *filename ) {
+	// close the background track, but DON'T reset s_rawend
+	// if restarting the same back ground track
+	if(s_backgroundStream)
+	{
+		S_CodecCloseStream(s_backgroundStream);
+		s_backgroundStream = NULL;
+	}
+
+	// Open stream
+	s_backgroundStream = S_CodecOpenStream(filename);
+	if(!s_backgroundStream) {
+		Com_Printf( S_COLOR_YELLOW "WARNING: couldn't open music file %s\n", filename );
+		return;
+	}
+
+	if(s_backgroundStream->info.channels != 2 || s_backgroundStream->info.rate != 22050) {
+		Com_Printf(S_COLOR_YELLOW "WARNING: music file %s is not 22k stereo\n", filename );
+	}
+}
+
+/*
+======================
+S_StartBackgroundTrack
+======================
+*/
+void S_Base_StartBackgroundTrack( const char *intro, const char *loop ){
+	if ( !intro ) {
+		intro = "";
+	}
+	if ( !loop || !loop[0] ) {
+		loop = intro;
+	}
+	Com_DPrintf( "S_StartBackgroundTrack( %s, %s )\n", intro, loop );
+
+	if(!*intro)
+	{
+		S_Base_StopBackgroundTrack();
+		return;
+	}
+
+	Q_strncpyz( s_backgroundLoop, loop, sizeof( s_backgroundLoop ) );
+
+	S_OpenBackgroundStream( intro );
+}
+
+/*
+======================
+S_UpdateBackgroundTrack
+======================
+*/
+void S_UpdateBackgroundTrack( void ) {
+	int		bufferSamples;
+	int		fileSamples;
+	byte	raw[30000];		// just enough to fit in a mac stack frame
+	int		fileBytes;
+	int		r;
+
+	if(!s_backgroundStream) {
+		return;
+	}
+
+	// don't bother playing anything if musicvolume is 0
+	if ( s_musicVolume->value <= 0 ) {
+		return;
+	}
+
+	// see how many samples should be copied into the raw buffer
+	if ( s_rawend[0] < s_soundtime ) {
+		s_rawend[0] = s_soundtime;
+	}
+
+	while ( s_rawend[0] < s_soundtime + MAX_RAW_SAMPLES ) {
+		bufferSamples = MAX_RAW_SAMPLES - (s_rawend[0] - s_soundtime);
+
+		// decide how much data needs to be read from the file
+		fileSamples = bufferSamples * s_backgroundStream->info.rate / dma.speed;
+
+		if (!fileSamples)
+			return;
+
+		// our max buffer size
+		fileBytes = fileSamples * (s_backgroundStream->info.width * s_backgroundStream->info.channels);
+		if ( fileBytes > sizeof(raw) ) {
+			fileBytes = sizeof(raw);
+			fileSamples = fileBytes / (s_backgroundStream->info.width * s_backgroundStream->info.channels);
+		}
+
+		// Read
+		r = S_CodecReadStream(s_backgroundStream, fileBytes, raw);
+		if(r < fileBytes)
+		{
+			fileSamples = r / (s_backgroundStream->info.width * s_backgroundStream->info.channels);
+		}
+
+		if(r > 0)
+		{
+			// add to raw buffer
+			S_Base_RawSamples(0, fileSamples, s_backgroundStream->info.rate,
+				s_backgroundStream->info.width, s_backgroundStream->info.channels, raw, s_musicVolume->value, -1);
+		}
+		else
+		{
+			// loop
+			if(s_backgroundLoop[0])
+			{
+				S_OpenBackgroundStream( s_backgroundLoop );
+				if(!s_backgroundStream)
+					return;
+			}
+			else
+			{
+				S_Base_StopBackgroundTrack();
+				return;
+			}
+		}
+
+	}
+}
+
+
+/*
+======================
+S_FreeOldestSound
+======================
+*/
+
+void S_FreeOldestSound( void ) {
+	int	i, oldest, used;
+	sfx_t	*sfx;
+	sndBuffer	*buffer, *nbuffer;
+
+	oldest = Com_Milliseconds();
+	used = 0;
+
+	for (i=1 ; i < s_numSfx ; i++) {
+		sfx = &s_knownSfx[i];
+		if (sfx->inMemory && sfx->lastTimeUsed<oldest) {
+			used = i;
+			oldest = sfx->lastTimeUsed;
+		}
+	}
+
+	sfx = &s_knownSfx[used];
+
+	Com_DPrintf("S_FreeOldestSound: freeing sound %s\n", sfx->soundName);
+
+	buffer = sfx->soundData;
+	while(buffer != NULL) {
+		nbuffer = buffer->next;
+		SND_free(buffer);
+		buffer = nbuffer;
+	}
+	sfx->inMemory = false;
+	sfx->soundData = NULL;
+}
+
+// =======================================================================
+// Shutdown sound engine
+// =======================================================================
+
+void S_Base_Shutdown( void ) {
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	SNDDMA_Shutdown();
+	SND_shutdown();
+
+	s_soundStarted = false;
+	s_numSfx = 0;
+
+	Cmd_RemoveCommand("s_info");
+}
+
+/*
+================
+S_Init
+================
+*/
+bool S_Base_Init( soundInterface_t *si )
+{
+
+	if( !si ) {
+		return false;
+	}
+
+	s_mixahead = Cvar_Get ("s_mixahead", "0.2", CVAR_ARCHIVE);
+	s_mixPreStep = Cvar_Get ("s_mixPreStep", "0.05", CVAR_ARCHIVE);
+	s_show = Cvar_Get ("s_show", "0", CVAR_CHEAT);
+	s_testsound = Cvar_Get ("s_testsound", "0", CVAR_CHEAT);
+
+	bool r = SNDDMA_Init();
+	if ( r )
+    {
+		s_soundStarted = true;
+		s_soundMuted = true;
+//		s_numSfx = 0;
+
+		::memset(sfxHash, 0, sizeof(sfx_t *)*LOOP_HASH);
+
+		s_soundtime = 0;
+		s_paintedtime = 0;
+
+		S_Base_StopAllSounds( );
+	} else {
+		return false;
+	}
+
+	si->Shutdown = S_Base_Shutdown;
+	si->StartSound = S_Base_StartSound;
+	si->StartLocalSound = S_Base_StartLocalSound;
+	si->StartBackgroundTrack = S_Base_StartBackgroundTrack;
+	si->StopBackgroundTrack = S_Base_StopBackgroundTrack;
+	si->RawSamples = S_Base_RawSamples;
+	si->StopAllSounds = S_Base_StopAllSounds;
+	si->ClearLoopingSounds = S_Base_ClearLoopingSounds;
+	si->AddLoopingSound = S_Base_AddLoopingSound;
+	si->AddRealLoopingSound = S_Base_AddRealLoopingSound;
+	si->StopLoopingSound = S_Base_StopLoopingSound;
+	si->Respatialize = S_Base_Respatialize;
+	si->UpdateEntityPosition = S_Base_UpdateEntityPosition;
+	si->Update = S_Base_Update;
+	si->DisableSounds = S_Base_DisableSounds;
+	si->BeginRegistration = S_Base_BeginRegistration;
+	si->RegisterSound = S_Base_RegisterSound;
+	si->SoundDuration = S_Base_SoundDuration;
+	si->ClearSoundBuffer = S_Base_ClearSoundBuffer;
+	si->SoundInfo = S_Base_SoundInfo;
+	si->SoundList = S_Base_SoundList;
+
+#ifdef USE_VOIP
+	si->StartCapture = S_Base_StartCapture;
+	si->AvailableCaptureSamples = S_Base_AvailableCaptureSamples;
+	si->Capture = S_Base_Capture;
+	si->StopCapture = S_Base_StopCapture;
+	si->MasterGain = S_Base_MasterGain;
+#endif
+
+	return true;
+}
diff --git a/src/client/snd_local.h b/src/client/snd_local.h
new file mode 100644
index 0000000..38f26c4
--- /dev/null
+++ b/src/client/snd_local.h
@@ -0,0 +1,267 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+// snd_local.h -- private sound definations
+
+#ifndef _SND_LOCAL_H
+#define _SND_LOCAL_H
+
+#include "qcommon/q_shared.h"
+#include "qcommon/qcommon.h"
+
+#include "snd_public.h"
+
+typedef struct cvar_s cvar_t;
+
+#define	PAINTBUFFER_SIZE		4096					// this is in samples
+
+#define SND_CHUNK_SIZE			1024					// samples
+#define SND_CHUNK_SIZE_FLOAT	(SND_CHUNK_SIZE/2)		// floats
+#define SND_CHUNK_SIZE_BYTE		(SND_CHUNK_SIZE*2)		// floats
+
+typedef struct {
+	int			left;	// the final values will be clamped to +/- 0x00ffff00 and shifted down
+	int			right;
+} portable_samplepair_t;
+
+typedef struct adpcm_state {
+    short	sample;		/* Previous output value */
+    char	index;		/* Index into stepsize table */
+} adpcm_state_t;
+
+typedef	struct sndBuffer_s {
+	short					sndChunk[SND_CHUNK_SIZE];
+	struct sndBuffer_s		*next;
+    int						size;
+	adpcm_state_t			adpcm;
+} sndBuffer;
+
+typedef struct sfx_s {
+	sndBuffer		*soundData;
+	bool		    defaultSound;			// couldn't be loaded, so use buzz
+	bool		    inMemory;				// not in Memory
+	bool		    soundCompressed;		// not in Memory
+	int				soundCompressionMethod;	
+	int 			soundLength;
+	int			    soundChannels;
+	char 			soundName[MAX_QPATH];
+	int				lastTimeUsed;
+	int				duration;
+	struct sfx_s	*next;
+} sfx_t;
+
+typedef struct {
+	int			channels;
+	int			samples;				// mono samples in buffer
+	int			submission_chunk;		// don't mix less than this #
+	int			samplebits;
+	int			speed;
+	byte		*buffer;
+} dma_t;
+
+#define START_SAMPLE_IMMEDIATE	0x7fffffff
+
+#define MAX_DOPPLER_SCALE 50.0f //arbitrary
+
+#define THIRD_PERSON_THRESHOLD_SQ (48.0f*48.0f)
+
+typedef struct loopSound_s {
+	vec3_t		origin;
+	vec3_t		velocity;
+	sfx_t		*sfx;
+	int			mergeFrame;
+	bool	    active;
+	bool	kill;
+	bool	doppler;
+	float		dopplerScale;
+	float		oldDopplerScale;
+	int			framenum;
+} loopSound_t;
+
+typedef struct
+{
+	sfx_t *thesfx;		// sfx structure
+	int allocTime;
+	int startSample;	// START_SAMPLE_IMMEDIATE = set immediately on next mix
+	int entnum;			// to allow overriding a specific sound
+	int entchannel;		// to allow overriding a specific sound
+	int leftvol;		// 0-255 volume after spatialization
+	int rightvol;		// 0-255 volume after spatialization
+	int master_vol;		// 0-255 volume before spatialization
+	float dopplerScale;
+	float oldDopplerScale;
+	vec3_t origin;		// only use if fixed_origin is set
+	bool fixed_origin;	// use origin instead of fetching entnum's origin
+	bool doppler;
+	bool fullVolume;
+} channel_t;
+
+
+#define	WAV_FORMAT_PCM		1
+
+
+typedef struct {
+	int			format;
+	int			rate;
+	int			width;
+	int			channels;
+	int			samples;
+	int			dataofs;		// chunk starts this many bytes from file start
+} wavinfo_t;
+
+// Interface between Q3 sound "api" and the sound backend
+typedef struct
+{
+	void (*Shutdown)(void);
+	void (*StartSound)( vec3_t origin, int entnum, int entchannel, sfxHandle_t sfx );
+	void (*StartLocalSound)( sfxHandle_t sfx, int channelNum );
+	void (*StartBackgroundTrack)( const char *intro, const char *loop );
+	void (*StopBackgroundTrack)( void );
+	void (*RawSamples)(int stream, int samples, int rate, int width, int channels, const byte *data, float volume, int entityNum);
+	void (*StopAllSounds)( void );
+	void (*ClearLoopingSounds)( bool killall );
+	void (*AddLoopingSound)( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx );
+	void (*AddRealLoopingSound)( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx );
+	void (*StopLoopingSound)(int entityNum );
+	void (*Respatialize)( int entityNum, const vec3_t origin, vec3_t axis[3], int inwater );
+	void (*UpdateEntityPosition)( int entityNum, const vec3_t origin );
+	void (*Update)( void );
+	void (*DisableSounds)( void );
+	void (*BeginRegistration)( void );
+	sfxHandle_t (*RegisterSound)( const char *sample, bool compressed );
+	int  (*SoundDuration)( sfxHandle_t handle );
+	void (*ClearSoundBuffer)( void );
+	void (*SoundInfo)( void );
+	void (*SoundList)( void );
+#ifdef USE_VOIP
+	void (*StartCapture)( void );
+	int (*AvailableCaptureSamples)( void );
+	void (*Capture)( int samples, byte *data );
+	void (*StopCapture)( void );
+	void (*MasterGain)( float gain );
+#endif
+} soundInterface_t;
+
+
+/*
+====================================================================
+
+  SYSTEM SPECIFIC FUNCTIONS
+
+====================================================================
+*/
+
+// initializes cycling through a DMA buffer and returns information on it
+bool SNDDMA_Init(void);
+
+// gets the current DMA position
+int		SNDDMA_GetDMAPos(void);
+
+// shutdown the DMA xfer.
+void	SNDDMA_Shutdown(void);
+
+void	SNDDMA_BeginPainting (void);
+
+void	SNDDMA_Submit(void);
+
+//====================================================================
+
+#define	MAX_CHANNELS			96
+
+extern	channel_t   s_channels[MAX_CHANNELS];
+extern	channel_t   loop_channels[MAX_CHANNELS];
+extern	int		numLoopChannels;
+
+extern	int		s_paintedtime;
+extern	vec3_t	listener_forward;
+extern	vec3_t	listener_right;
+extern	vec3_t	listener_up;
+extern	dma_t	dma;
+
+#define	MAX_RAW_SAMPLES	16384
+#define MAX_RAW_STREAMS (MAX_CLIENTS * 2 + 1)
+extern	portable_samplepair_t s_rawsamples[MAX_RAW_STREAMS][MAX_RAW_SAMPLES];
+extern	int		s_rawend[MAX_RAW_STREAMS];
+
+extern cvar_t *s_volume;
+extern cvar_t *s_musicVolume;
+extern cvar_t *s_muted;
+extern cvar_t *s_doppler;
+
+extern cvar_t *s_testsound;
+
+bool S_LoadSound( sfx_t *sfx );
+
+void		SND_free(sndBuffer *v);
+sndBuffer*	SND_malloc( void );
+void		SND_setup( void );
+void		SND_shutdown(void);
+
+void S_PaintChannels(int endtime);
+
+void S_memoryLoad(sfx_t *sfx);
+
+// spatializes a channel
+void S_Spatialize(channel_t *ch);
+
+// adpcm functions
+int  S_AdpcmMemoryNeeded( const wavinfo_t *info );
+void S_AdpcmEncodeSound( sfx_t *sfx, short *samples );
+void S_AdpcmGetSamples(sndBuffer *chunk, short *to);
+
+// wavelet function
+
+#define SENTINEL_MULAW_ZERO_RUN 127
+#define SENTINEL_MULAW_FOUR_BIT_RUN 126
+
+void S_FreeOldestSound( void );
+
+#define	NXStream byte
+
+void encodeWavelet(sfx_t *sfx, short *packets);
+void decodeWavelet( sndBuffer *stream, short *packets);
+
+void encodeMuLaw( sfx_t *sfx, short *packets);
+extern short mulawToShort[256];
+
+extern short *sfxScratchBuffer;
+extern sfx_t *sfxScratchPointer;
+extern int	   sfxScratchIndex;
+
+bool S_Base_Init( soundInterface_t *si );
+
+// OpenAL stuff
+typedef enum
+{
+	SRCPRI_AMBIENT = 0,	// Ambient sound effects
+	SRCPRI_ENTITY,			// Entity sound effects
+	SRCPRI_ONESHOT,			// One-shot sounds
+	SRCPRI_LOCAL,				// Local sounds
+	SRCPRI_STREAM				// Streams (music, cutscenes)
+} alSrcPriority_t;
+
+typedef int srcHandle_t;
+
+bool S_AL_Init( soundInterface_t *si );
+
+#endif
diff --git a/src/client/snd_main.cpp b/src/client/snd_main.cpp
new file mode 100644
index 0000000..a6873f1
--- /dev/null
+++ b/src/client/snd_main.cpp
@@ -0,0 +1,566 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2005 Stuart Dalton (badcdev@gmail.com)
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include "client.h"
+#include "snd_codec.h"
+#include "snd_local.h"
+#include "snd_public.h"
+
+cvar_t *s_volume;
+cvar_t *s_muted;
+cvar_t *s_musicVolume;
+cvar_t *s_doppler;
+cvar_t *s_backend;
+cvar_t *s_muteWhenMinimized;
+cvar_t *s_muteWhenUnfocused;
+
+static soundInterface_t si;
+
+/*
+=================
+S_ValidateInterface
+=================
+*/
+static bool S_ValidSoundInterface( soundInterface_t *si )
+{
+	if( !si->Shutdown ) return false;
+	if( !si->StartSound ) return false;
+	if( !si->StartLocalSound ) return false;
+	if( !si->StartBackgroundTrack ) return false;
+	if( !si->StopBackgroundTrack ) return false;
+	if( !si->RawSamples ) return false;
+	if( !si->StopAllSounds ) return false;
+	if( !si->ClearLoopingSounds ) return false;
+	if( !si->AddLoopingSound ) return false;
+	if( !si->AddRealLoopingSound ) return false;
+	if( !si->StopLoopingSound ) return false;
+	if( !si->Respatialize ) return false;
+	if( !si->UpdateEntityPosition ) return false;
+	if( !si->Update ) return false;
+	if( !si->DisableSounds ) return false;
+	if( !si->BeginRegistration ) return false;
+	if( !si->RegisterSound ) return false;
+	if( !si->SoundDuration ) return false;
+	if( !si->ClearSoundBuffer ) return false;
+	if( !si->SoundInfo ) return false;
+	if( !si->SoundList ) return false;
+
+#ifdef USE_VOIP
+	if( !si->StartCapture ) return false;
+	if( !si->AvailableCaptureSamples ) return false;
+	if( !si->Capture ) return false;
+	if( !si->StopCapture ) return false;
+	if( !si->MasterGain ) return false;
+#endif
+
+	return true;
+}
+
+/*
+=================
+S_StartSound
+=================
+*/
+void S_StartSound( vec3_t origin, int entnum, int entchannel, sfxHandle_t sfx )
+{
+	if( si.StartSound ) {
+		si.StartSound( origin, entnum, entchannel, sfx );
+	}
+}
+
+/*
+=================
+S_StartLocalSound
+=================
+*/
+void S_StartLocalSound( sfxHandle_t sfx, int channelNum )
+{
+	if( si.StartLocalSound ) {
+		si.StartLocalSound( sfx, channelNum );
+	}
+}
+
+/*
+=================
+S_StartBackgroundTrack
+=================
+*/
+void S_StartBackgroundTrack( const char *intro, const char *loop )
+{
+	if( si.StartBackgroundTrack ) {
+		si.StartBackgroundTrack( intro, loop );
+	}
+}
+
+/*
+=================
+S_StopBackgroundTrack
+=================
+*/
+void S_StopBackgroundTrack( void )
+{
+	if( si.StopBackgroundTrack ) {
+		si.StopBackgroundTrack( );
+	}
+}
+
+/*
+=================
+S_RawSamples
+=================
+*/
+void S_RawSamples (int stream, int samples, int rate, int width, int channels,
+		   const byte *data, float volume, int entityNum)
+{
+	if(si.RawSamples)
+		si.RawSamples(stream, samples, rate, width, channels, data, volume, entityNum);
+}
+
+/*
+=================
+S_StopAllSounds
+=================
+*/
+void S_StopAllSounds( void )
+{
+	if( si.StopAllSounds ) {
+		si.StopAllSounds( );
+	}
+}
+
+/*
+=================
+S_ClearLoopingSounds
+=================
+*/
+void S_ClearLoopingSounds( bool killall )
+{
+	if( si.ClearLoopingSounds ) {
+		si.ClearLoopingSounds( killall );
+	}
+}
+
+/*
+=================
+S_AddLoopingSound
+=================
+*/
+void S_AddLoopingSound( int entityNum, const vec3_t origin,
+		const vec3_t velocity, sfxHandle_t sfx )
+{
+	if( si.AddLoopingSound ) {
+		si.AddLoopingSound( entityNum, origin, velocity, sfx );
+	}
+}
+
+/*
+=================
+S_AddRealLoopingSound
+=================
+*/
+void S_AddRealLoopingSound( int entityNum, const vec3_t origin,
+		const vec3_t velocity, sfxHandle_t sfx )
+{
+	if( si.AddRealLoopingSound ) {
+		si.AddRealLoopingSound( entityNum, origin, velocity, sfx );
+	}
+}
+
+/*
+=================
+S_StopLoopingSound
+=================
+*/
+void S_StopLoopingSound( int entityNum )
+{
+	if( si.StopLoopingSound ) {
+		si.StopLoopingSound( entityNum );
+	}
+}
+
+/*
+=================
+S_Respatialize
+=================
+*/
+void S_Respatialize( int entityNum, const vec3_t origin,
+		vec3_t axis[3], int inwater )
+{
+	if( si.Respatialize ) {
+		si.Respatialize( entityNum, origin, axis, inwater );
+	}
+}
+
+/*
+=================
+S_UpdateEntityPosition
+=================
+*/
+void S_UpdateEntityPosition( int entityNum, const vec3_t origin )
+{
+	if( si.UpdateEntityPosition ) {
+		si.UpdateEntityPosition( entityNum, origin );
+	}
+}
+
+/*
+=================
+S_Update
+=================
+*/
+void S_Update( void )
+{
+	if(s_muted->integer)
+	{
+		if(!(s_muteWhenMinimized->integer && com_minimized->integer) &&
+		   !(s_muteWhenUnfocused->integer && com_unfocused->integer))
+		{
+			s_muted->integer = false;
+			s_muted->modified = true;
+		}
+	}
+	else
+	{
+		if((s_muteWhenMinimized->integer && com_minimized->integer) ||
+		   (s_muteWhenUnfocused->integer && com_unfocused->integer))
+		{
+			s_muted->integer = true;
+			s_muted->modified = true;
+		}
+	}
+	
+	if( si.Update ) {
+		si.Update( );
+	}
+}
+
+/*
+=================
+S_DisableSounds
+=================
+*/
+void S_DisableSounds( void )
+{
+	if( si.DisableSounds ) {
+		si.DisableSounds( );
+	}
+}
+
+/*
+=================
+S_BeginRegistration
+=================
+*/
+void S_BeginRegistration( void )
+{
+	if( si.BeginRegistration ) {
+		si.BeginRegistration( );
+	}
+}
+
+/*
+=================
+S_RegisterSound
+=================
+*/
+sfxHandle_t	S_RegisterSound( const char *sample, bool compressed )
+{
+	if( si.RegisterSound ) {
+		return si.RegisterSound( sample, compressed );
+	} else {
+		return 0;
+	}
+}
+
+/*
+=================
+S_SoundDuration
+=================
+*/
+int S_SoundDuration( sfxHandle_t handle )
+{
+	if( si.SoundDuration )
+		return si.SoundDuration( handle );
+	else
+		return 0;
+}
+
+/*
+=================
+S_ClearSoundBuffer
+=================
+*/
+void S_ClearSoundBuffer( void )
+{
+	if( si.ClearSoundBuffer ) {
+		si.ClearSoundBuffer( );
+	}
+}
+
+/*
+=================
+S_SoundInfo
+=================
+*/
+void S_SoundInfo( void )
+{
+	if( si.SoundInfo ) {
+		si.SoundInfo( );
+	}
+}
+
+/*
+=================
+S_SoundList
+=================
+*/
+void S_SoundList( void )
+{
+	if( si.SoundList ) {
+		si.SoundList( );
+	}
+}
+
+
+#ifdef USE_VOIP
+/*
+=================
+S_StartCapture
+=================
+*/
+void S_StartCapture( void )
+{
+	if( si.StartCapture ) {
+		si.StartCapture( );
+	}
+}
+
+/*
+=================
+S_AvailableCaptureSamples
+=================
+*/
+int S_AvailableCaptureSamples( void )
+{
+	if( si.AvailableCaptureSamples ) {
+		return si.AvailableCaptureSamples( );
+	}
+	return 0;
+}
+
+/*
+=================
+S_Capture
+=================
+*/
+void S_Capture( int samples, byte *data )
+{
+	if( si.Capture ) {
+		si.Capture( samples, data );
+	}
+}
+
+/*
+=================
+S_StopCapture
+=================
+*/
+void S_StopCapture( void )
+{
+	if( si.StopCapture ) {
+		si.StopCapture( );
+	}
+}
+
+/*
+=================
+S_MasterGain
+=================
+*/
+void S_MasterGain( float gain )
+{
+	if( si.MasterGain ) {
+		si.MasterGain( gain );
+	}
+}
+#endif
+
+//=============================================================================
+
+/*
+=================
+S_Play_f
+=================
+*/
+void S_Play_f( void ) {
+	int 		i;
+	int			c;
+	sfxHandle_t	h;
+
+	if( !si.RegisterSound || !si.StartLocalSound ) {
+		return;
+	}
+
+	c = Cmd_Argc();
+
+	if( c < 2 ) {
+		Com_Printf ("Usage: play <sound filename> [sound filename] [sound filename] ...\n");
+		return;
+	}
+
+	for( i = 1; i < c; i++ ) {
+		h = si.RegisterSound( Cmd_Argv(i), false );
+
+		if( h ) {
+			si.StartLocalSound( h, CHAN_LOCAL_SOUND );
+		}
+	}
+}
+
+/*
+=================
+S_Music_f
+=================
+*/
+void S_Music_f( void ) {
+	int		c;
+
+	if( !si.StartBackgroundTrack ) {
+		return;
+	}
+
+	c = Cmd_Argc();
+
+	if ( c == 2 ) {
+		si.StartBackgroundTrack( Cmd_Argv(1), NULL );
+	} else if ( c == 3 ) {
+		si.StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(2) );
+	} else {
+		Com_Printf ("Usage: music <musicfile> [loopfile]\n");
+		return;
+	}
+
+}
+
+/*
+=================
+S_Music_f
+=================
+*/
+void S_StopMusic_f( void )
+{
+	if(!si.StopBackgroundTrack)
+		return;
+
+	si.StopBackgroundTrack();
+}
+
+
+//=============================================================================
+
+/*
+=================
+S_Init
+=================
+*/
+void S_Init( void )
+{
+	cvar_t		*cv;
+	bool	started = false;
+
+	Com_Printf( "------ Initializing Sound ------\n" );
+
+	s_volume = Cvar_Get( "s_volume", "0.8", CVAR_ARCHIVE );
+	s_musicVolume = Cvar_Get( "s_musicvolume", "0.25", CVAR_ARCHIVE );
+	s_muted = Cvar_Get("s_muted", "0", CVAR_ROM);
+	s_doppler = Cvar_Get( "s_doppler", "1", CVAR_ARCHIVE );
+	s_backend = Cvar_Get( "s_backend", "", CVAR_ROM );
+	s_muteWhenMinimized = Cvar_Get( "s_muteWhenMinimized", "0", CVAR_ARCHIVE );
+	s_muteWhenUnfocused = Cvar_Get( "s_muteWhenUnfocused", "0", CVAR_ARCHIVE );
+
+	cv = Cvar_Get( "s_initsound", "1", 0 );
+	if( !cv->integer ) {
+		Com_Printf( "Sound disabled.\n" );
+	} else {
+
+		S_CodecInit( );
+
+		Cmd_AddCommand( "play", S_Play_f );
+		Cmd_AddCommand( "music", S_Music_f );
+		Cmd_AddCommand( "stopmusic", S_StopMusic_f );
+		Cmd_AddCommand( "s_list", S_SoundList );
+		Cmd_AddCommand( "s_stop", S_StopAllSounds );
+		Cmd_AddCommand( "s_info", S_SoundInfo );
+
+		cv = Cvar_Get( "s_useOpenAL", "0", CVAR_ARCHIVE );
+		if( cv->integer ) {
+			//OpenAL
+			started = S_AL_Init( &si );
+			Cvar_Set( "s_backend", "OpenAL" );
+		}
+
+		if( !started ) {
+			started = S_Base_Init( &si );
+			Cvar_Set( "s_backend", "base" );
+		}
+
+		if( started ) {
+			if( !S_ValidSoundInterface( &si ) ) {
+				Com_Error( ERR_FATAL, "Sound interface invalid" );
+			}
+
+			S_SoundInfo( );
+			Com_Printf( "Sound initialization successful.\n" );
+		} else {
+			Com_Printf( "Sound initialization failed.\n" );
+		}
+	}
+
+	Com_Printf( "--------------------------------\n");
+}
+
+/*
+=================
+S_Shutdown
+=================
+*/
+void S_Shutdown( void )
+{
+	if( si.Shutdown )
+    {
+		si.Shutdown( );
+	}
+
+	::memset( &si, 0, sizeof( soundInterface_t ) );
+
+	Cmd_RemoveCommand( "play" );
+	Cmd_RemoveCommand( "music");
+	Cmd_RemoveCommand( "stopmusic");
+	Cmd_RemoveCommand( "s_list" );
+	Cmd_RemoveCommand( "s_stop" );
+	Cmd_RemoveCommand( "s_info" );
+
+	S_CodecShutdown( );
+}
diff --git a/src/client/snd_mem.cpp b/src/client/snd_mem.cpp
new file mode 100644
index 0000000..128a471
--- /dev/null
+++ b/src/client/snd_mem.cpp
@@ -0,0 +1,297 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+/*****************************************************************************
+ * name:		snd_mem.c
+ *
+ * desc:		sound caching
+ *****************************************************************************/
+
+#include "snd_codec.h"
+#include "snd_local.h"
+
+#include "qcommon/cvar.h"
+
+#define DEF_COMSOUNDMEGS "8"
+
+/*
+===============================================================================
+
+memory management
+
+===============================================================================
+*/
+
+static sndBuffer *buffer = NULL;
+static sndBuffer *freelist = NULL;
+static int inUse = 0;
+static int totalInUse = 0;
+
+short *sfxScratchBuffer = NULL;
+sfx_t *sfxScratchPointer = NULL;
+int sfxScratchIndex = 0;
+
+void SND_free(sndBuffer *v)
+{
+    *(sndBuffer **)v = freelist;
+    freelist = (sndBuffer *)v;
+    inUse += sizeof(sndBuffer);
+}
+
+sndBuffer *SND_malloc(void)
+{
+    sndBuffer *v;
+redo:
+    if (freelist == NULL)
+    {
+        S_FreeOldestSound();
+        goto redo;
+    }
+
+    inUse -= sizeof(sndBuffer);
+    totalInUse += sizeof(sndBuffer);
+
+    v = freelist;
+    freelist = *(sndBuffer **)freelist;
+    v->next = NULL;
+
+    return v;
+}
+
+void SND_setup(void)
+{
+    cvar_t* cv = Cvar_Get("com_soundMegs", 
+            DEF_COMSOUNDMEGS, CVAR_LATCH | CVAR_ARCHIVE);
+    int scs = cv->integer * 1536;
+
+    buffer = (sndBuffer*)malloc(scs * sizeof(sndBuffer));
+
+    // allocate the stack based hunk allocator
+    sfxScratchBuffer = (short*)malloc(SND_CHUNK_SIZE * sizeof(short) * 4);
+    sfxScratchPointer = NULL;
+
+    inUse = scs * sizeof(sndBuffer);
+    sndBuffer* p = buffer;
+    sndBuffer* q = p + scs;
+    while (--q > p)
+    {
+        *(sndBuffer **)q = q - 1;
+    }
+
+    *(sndBuffer **)q = NULL;
+    freelist = p + scs - 1;
+
+    Com_Printf("Sound memory manager started\n");
+}
+
+void SND_shutdown(void)
+{
+    free(sfxScratchBuffer);
+    free(buffer);
+}
+
+/*
+================
+ResampleSfx
+
+resample / decimate to the current source rate
+================
+*/
+static int ResampleSfx(sfx_t *sfx, int channels, int inrate, int inwidth, int samples, byte *data, bool compressed)
+{
+    float stepscale = (float)inrate / dma.speed;  // this is usually 0.5, 1, or 2
+    int outcount = samples / stepscale;
+    int fracstep = stepscale * 256 * channels;
+    sndBuffer* chunk = sfx->soundData;
+
+    int samplefrac = 0;
+    int srcsample = 0;
+
+    for (int i = 0; i < outcount; i++)
+    {
+        srcsample += samplefrac >> 8;
+        samplefrac &= 255;
+        samplefrac += fracstep;
+
+        for (int j = 0; j < channels; j++)
+        {
+            int sample;
+
+            if (inwidth == 2)
+            {
+                sample = ((short *)data)[srcsample + j];
+            }
+            else
+            {
+                sample = (int)((unsigned char)(data[srcsample + j]) - 128) << 8;
+            }
+
+            int part = (i * channels + j) & (SND_CHUNK_SIZE - 1);
+            if (part == 0)
+            {
+                sndBuffer *newchunk = SND_malloc();
+
+                if (chunk == NULL)
+                {
+                    sfx->soundData = newchunk;
+                }
+                else
+                {
+                    chunk->next = newchunk;
+                }
+                chunk = newchunk;
+            }
+
+            chunk->sndChunk[part] = sample;
+        }
+    }
+
+    return outcount;
+}
+
+/*
+================
+ResampleSfxRaw
+
+resample / decimate to the current source rate
+================
+*/
+static int ResampleSfxRaw(short *sfx, int channels, int inrate, int inwidth, int samples, byte *data)
+{
+    float stepscale = (float)inrate / dma.speed;  // this is usually 0.5, 1, or 2
+    int outcount = samples / stepscale;
+    int fracstep = stepscale * 256 * channels;
+
+    int samplefrac = 0;
+    int srcsample = 0;
+
+    for (int i = 0; i < outcount; i++)
+    {
+        srcsample += samplefrac >> 8;
+        srcsample &= 255;
+        samplefrac += fracstep;
+
+        for (int j = 0; j < channels; j++)
+        {
+            int sample;
+            if (inwidth == 2)
+            {
+                sample = LittleShort(((short *)data)[srcsample + j]);
+            }
+            else
+            {
+                sample = (int)((unsigned char)(data[srcsample + j]) - 128) << 8;
+            }
+            sfx[i * channels + j] = sample;
+        }
+    }
+    return outcount;
+}
+
+//=============================================================================
+
+/*
+==============
+S_LoadSound
+
+The filename may be different than sfx->name in the case
+of a forced fallback of a player specific sound
+==============
+*/
+bool S_LoadSound(sfx_t *sfx)
+{
+    snd_info_t info;
+    byte *data = (byte*)S_CodecLoad(sfx->soundName, &info);
+    if (!data)
+    {
+        return false;
+    }
+
+    int size_per_sec = info.rate * info.channels * info.width;
+    if (size_per_sec > 0)
+    {
+        sfx->duration = (int)(1000.0f * ((double)info.size / size_per_sec));
+    }
+
+    if (info.width == 1)
+    {
+        Com_DPrintf(S_COLOR_YELLOW "WARNING: %s is a 8 bit audio file\n",
+                sfx->soundName);
+    }
+
+    if (info.rate != 22050)
+    {
+        Com_DPrintf(S_COLOR_YELLOW "WARNING: %s is not a 22kHz audio file\n",
+                sfx->soundName);
+    }
+
+    short* samples = (short*)Hunk_AllocateTempMemory(info.channels * info.samples * sizeof(short) * 2);
+
+    sfx->lastTimeUsed = Com_Milliseconds() + 1;
+
+    // each of these compression schemes works just fine
+    // but the 16bit quality is much nicer and with a local
+    // install assured we can rely upon the sound memory
+    // manager to do the right thing for us and page
+    // sound in as needed
+
+    if (info.channels == 1 && sfx->soundCompressed == true)
+    {
+        sfx->soundCompressionMethod = 1;
+        sfx->soundData = NULL;
+        sfx->soundLength = ResampleSfxRaw(
+                    samples,
+                    info.channels,
+                    info.rate,
+                    info.width,
+                    info.samples,
+                    data + info.dataofs);
+        S_AdpcmEncodeSound(sfx, samples);
+    }
+    else
+    {
+        sfx->soundCompressionMethod = 0;
+        sfx->soundData = NULL;
+        sfx->soundLength = ResampleSfx(
+                    sfx,
+                    info.channels,
+                    info.rate,
+                    info.width,
+                    info.samples,
+                    data + info.dataofs,
+                    false);
+    }
+
+    sfx->soundChannels = info.channels;
+
+    Hunk_FreeTempMemory(samples);
+    Hunk_FreeTempMemory(data);
+
+    return true;
+}
+
+void S_DisplayFreeMemory(void)
+{ 
+    Com_Printf("%d bytes free sound buffer memory, %d total used\n", inUse, totalInUse);
+}
diff --git a/src/client/snd_mix.cpp b/src/client/snd_mix.cpp
new file mode 100644
index 0000000..4030bc6
--- /dev/null
+++ b/src/client/snd_mix.cpp
@@ -0,0 +1,792 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+// snd_mix.c -- portable code to mix sounds for snd_dma.c
+
+#include "snd_local.h"
+#if idppc_altivec && !defined(__APPLE__)
+#include <altivec.h>
+#endif
+#include "client.h"
+
+static portable_samplepair_t paintbuffer[PAINTBUFFER_SIZE];
+static int snd_vol;
+
+int*     snd_p;  
+int      snd_linear_count;
+short*   snd_out;
+
+#undef id386
+
+#if	!id386                                        // if configured not to use asm
+
+void S_WriteLinearBlastStereo16 (void)
+{
+	int		i;
+	int		val;
+
+	for (i=0 ; i<snd_linear_count ; i+=2)
+	{
+		val = snd_p[i]>>8;
+		if (val > 0x7fff)
+			snd_out[i] = 0x7fff;
+		else if (val < -32768)
+			snd_out[i] = -32768;
+		else
+			snd_out[i] = val;
+
+		val = snd_p[i+1]>>8;
+		if (val > 0x7fff)
+			snd_out[i+1] = 0x7fff;
+		else if (val < -32768)
+			snd_out[i+1] = -32768;
+		else
+			snd_out[i+1] = val;
+	}
+}
+#elif defined(__GNUC__)
+// uses snd_mixa.s
+void S_WriteLinearBlastStereo16 (void);
+#else
+
+__declspec( naked ) void S_WriteLinearBlastStereo16 (void)
+{
+	__asm {
+
+ push edi
+ push ebx
+ mov ecx,ds:dword ptr[snd_linear_count]
+ mov ebx,ds:dword ptr[snd_p]
+ mov edi,ds:dword ptr[snd_out]
+LWLBLoopTop:
+ mov eax,ds:dword ptr[-8+ebx+ecx*4]
+ sar eax,8
+ cmp eax,07FFFh
+ jg LClampHigh
+ cmp eax,0FFFF8000h
+ jnl LClampDone
+ mov eax,0FFFF8000h
+ jmp LClampDone
+LClampHigh:
+ mov eax,07FFFh
+LClampDone:
+ mov edx,ds:dword ptr[-4+ebx+ecx*4]
+ sar edx,8
+ cmp edx,07FFFh
+ jg LClampHigh2
+ cmp edx,0FFFF8000h
+ jnl LClampDone2
+ mov edx,0FFFF8000h
+ jmp LClampDone2
+LClampHigh2:
+ mov edx,07FFFh
+LClampDone2:
+ shl edx,16
+ and eax,0FFFFh
+ or edx,eax
+ mov ds:dword ptr[-4+edi+ecx*2],edx
+ sub ecx,2
+ jnz LWLBLoopTop
+ pop ebx
+ pop edi
+ ret
+	}
+}
+
+#endif
+
+void S_TransferStereo16 (unsigned long *pbuf, int endtime)
+{
+	int		lpos;
+	int		ls_paintedtime;
+	
+	snd_p = (int *) paintbuffer;
+	ls_paintedtime = s_paintedtime;
+
+	while (ls_paintedtime < endtime)
+	{
+	// handle recirculating buffer issues
+		lpos = ls_paintedtime & ((dma.samples>>1)-1);
+
+		snd_out = (short *) pbuf + (lpos<<1);
+
+		snd_linear_count = (dma.samples>>1) - lpos;
+		if (ls_paintedtime + snd_linear_count > endtime)
+			snd_linear_count = endtime - ls_paintedtime;
+
+		snd_linear_count <<= 1;
+
+	// write a linear blast of samples
+		S_WriteLinearBlastStereo16 ();
+
+		snd_p += snd_linear_count;
+		ls_paintedtime += (snd_linear_count>>1);
+
+		if( CL_VideoRecording( ) )
+			CL_WriteAVIAudioFrame( (byte *)snd_out, snd_linear_count << 1 );
+	}
+}
+
+/*
+===================
+S_TransferPaintBuffer
+
+===================
+*/
+void S_TransferPaintBuffer(int endtime)
+{
+	int 	out_idx;
+	int 	count;
+	int 	out_mask;
+	int 	*p;
+	int 	step;
+	int		val;
+	unsigned long *pbuf;
+
+	pbuf = (unsigned long *)dma.buffer;
+
+
+	if ( s_testsound->integer ) {
+		int		i;
+
+		// write a fixed sine wave
+		count = (endtime - s_paintedtime);
+		for (i=0 ; i<count ; i++)
+			paintbuffer[i].left = paintbuffer[i].right = sin((s_paintedtime+i)*0.1)*20000*256;
+	}
+
+
+	if (dma.samplebits == 16 && dma.channels == 2)
+	{	// optimized case
+		S_TransferStereo16 (pbuf, endtime);
+	}
+	else
+	{	// general case
+		p = (int *) paintbuffer;
+		count = (endtime - s_paintedtime) * dma.channels;
+		out_mask = dma.samples - 1; 
+		out_idx = s_paintedtime * dma.channels & out_mask;
+		step = 3 - dma.channels;
+
+		if (dma.samplebits == 16)
+		{
+			short *out = (short *) pbuf;
+			while (count--)
+			{
+				val = *p >> 8;
+				p+= step;
+				if (val > 0x7fff)
+					val = 0x7fff;
+				else if (val < -32768)
+					val = -32768;
+				out[out_idx] = val;
+				out_idx = (out_idx + 1) & out_mask;
+			}
+		}
+		else if (dma.samplebits == 8)
+		{
+			unsigned char *out = (unsigned char *) pbuf;
+			while (count--)
+			{
+				val = *p >> 8;
+				p+= step;
+				if (val > 0x7fff)
+					val = 0x7fff;
+				else if (val < -32768)
+					val = -32768;
+				out[out_idx] = (val>>8) + 128;
+				out_idx = (out_idx + 1) & out_mask;
+			}
+		}
+	}
+}
+
+
+/*
+===============================================================================
+
+CHANNEL MIXING
+
+===============================================================================
+*/
+
+#if idppc_altivec
+static void S_PaintChannelFrom16_altivec( channel_t *ch, const sfx_t *sc, int count, int sampleOffset, int bufferOffset ) {
+	int						data, aoff, boff;
+	int						leftvol, rightvol;
+	int						i, j;
+	portable_samplepair_t	*samp;
+	sndBuffer				*chunk;
+	short					*samples;
+	float					ooff, fdata[2], fdiv, fleftvol, frightvol;
+
+	if (sc->soundChannels <= 0) {
+		return;
+	}
+
+	samp = &paintbuffer[ bufferOffset ];
+
+	if (ch->doppler) {
+		sampleOffset = sampleOffset*ch->oldDopplerScale;
+	}
+
+	if ( sc->soundChannels == 2 ) {
+		sampleOffset *= sc->soundChannels;
+
+		if ( sampleOffset & 1 ) {
+			sampleOffset &= ~1;
+		}
+	}
+
+	chunk = sc->soundData;
+	while (sampleOffset>=SND_CHUNK_SIZE) {
+		chunk = chunk->next;
+		sampleOffset -= SND_CHUNK_SIZE;
+		if (!chunk) {
+			chunk = sc->soundData;
+		}
+	}
+
+	if (!ch->doppler || ch->dopplerScale==1.0f) {
+		vector signed short volume_vec;
+		vector unsigned int volume_shift;
+		int vectorCount, samplesLeft, chunkSamplesLeft;
+		leftvol = ch->leftvol*snd_vol;
+		rightvol = ch->rightvol*snd_vol;
+		samples = chunk->sndChunk;
+		((short *)&volume_vec)[0] = leftvol;
+		((short *)&volume_vec)[1] = leftvol;
+		((short *)&volume_vec)[4] = leftvol;
+		((short *)&volume_vec)[5] = leftvol;
+		((short *)&volume_vec)[2] = rightvol;
+		((short *)&volume_vec)[3] = rightvol;
+		((short *)&volume_vec)[6] = rightvol;
+		((short *)&volume_vec)[7] = rightvol;
+		volume_shift = vec_splat_u32(8);
+		i = 0;
+
+		while(i < count) {
+			/* Try to align destination to 16-byte boundary */
+			while(i < count && (((unsigned long)&samp[i] & 0x1f) || ((count-i) < 8) || ((SND_CHUNK_SIZE - sampleOffset) < 8))) {
+				data  = samples[sampleOffset++];
+				samp[i].left += (data * leftvol)>>8;
+
+				if ( sc->soundChannels == 2 ) {
+					data = samples[sampleOffset++];
+				}
+				samp[i].right += (data * rightvol)>>8;
+	
+				if (sampleOffset == SND_CHUNK_SIZE) {
+					chunk = chunk->next;
+					samples = chunk->sndChunk;
+					sampleOffset = 0;
+				}
+				i++;
+			}
+			/* Destination is now aligned.  Process as many 8-sample 
+			   chunks as we can before we run out of room from the current
+			   sound chunk.  We do 8 per loop to avoid extra source data reads. */
+			samplesLeft = count - i;
+			chunkSamplesLeft = SND_CHUNK_SIZE - sampleOffset;
+			if(samplesLeft > chunkSamplesLeft)
+				samplesLeft = chunkSamplesLeft;
+			
+			vectorCount = samplesLeft / 8;
+			
+			if(vectorCount)
+			{
+				vector unsigned char tmp;
+				vector short s0, s1, sampleData0, sampleData1;
+				vector signed int merge0, merge1;
+				vector signed int d0, d1, d2, d3;				
+				vector unsigned char samplePermute0 =
+					VECCONST_UINT8(0, 1, 4, 5, 0, 1, 4, 5, 2, 3, 6, 7, 2, 3, 6, 7);
+				vector unsigned char samplePermute1 = 
+					VECCONST_UINT8(8, 9, 12, 13, 8, 9, 12, 13, 10, 11, 14, 15, 10, 11, 14, 15);
+				vector unsigned char loadPermute0, loadPermute1;
+				
+				// Rather than permute the vectors after we load them to do the sample
+				// replication and rearrangement, we permute the alignment vector so
+				// we do everything in one step below and avoid data shuffling.
+				tmp = vec_lvsl(0,&samples[sampleOffset]);								
+				loadPermute0 = vec_perm(tmp,tmp,samplePermute0);
+				loadPermute1 = vec_perm(tmp,tmp,samplePermute1);
+				
+				s0 = *(vector short *)&samples[sampleOffset];
+				while(vectorCount)
+				{
+					/* Load up source (16-bit) sample data */
+					s1 = *(vector short *)&samples[sampleOffset+7];
+					
+					/* Load up destination sample data */
+					d0 = *(vector signed int *)&samp[i];
+					d1 = *(vector signed int *)&samp[i+2];
+					d2 = *(vector signed int *)&samp[i+4];
+					d3 = *(vector signed int *)&samp[i+6];
+
+					sampleData0 = vec_perm(s0,s1,loadPermute0);
+					sampleData1 = vec_perm(s0,s1,loadPermute1);
+					
+					merge0 = vec_mule(sampleData0,volume_vec);
+					merge0 = vec_sra(merge0,volume_shift);	/* Shift down to proper range */
+					
+					merge1 = vec_mulo(sampleData0,volume_vec);
+					merge1 = vec_sra(merge1,volume_shift);
+					
+					d0 = vec_add(merge0,d0);
+					d1 = vec_add(merge1,d1);
+					
+					merge0 = vec_mule(sampleData1,volume_vec);
+					merge0 = vec_sra(merge0,volume_shift);	/* Shift down to proper range */
+					
+					merge1 = vec_mulo(sampleData1,volume_vec);
+					merge1 = vec_sra(merge1,volume_shift);					
+
+					d2 = vec_add(merge0,d2);
+					d3 = vec_add(merge1,d3);
+
+					/* Store destination sample data */
+					*(vector signed int *)&samp[i] = d0;
+					*(vector signed int *)&samp[i+2] = d1;
+					*(vector signed int *)&samp[i+4] = d2;
+					*(vector signed int *)&samp[i+6] = d3;
+
+					i += 8;
+					vectorCount--;
+					s0 = s1;
+					sampleOffset += 8;
+				}
+				if (sampleOffset == SND_CHUNK_SIZE) {
+					chunk = chunk->next;
+					samples = chunk->sndChunk;
+					sampleOffset = 0;
+				}
+			}
+		}
+	} else {
+		fleftvol = ch->leftvol*snd_vol;
+		frightvol = ch->rightvol*snd_vol;
+
+		ooff = sampleOffset;
+		samples = chunk->sndChunk;
+		
+		for ( i=0 ; i<count ; i++ ) {
+
+			aoff = ooff;
+			ooff = ooff + ch->dopplerScale * sc->soundChannels;
+			boff = ooff;
+			fdata[0] = fdata[1] = 0;
+			for (j=aoff; j<boff; j += sc->soundChannels) {
+				if (j == SND_CHUNK_SIZE) {
+					chunk = chunk->next;
+					if (!chunk) {
+						chunk = sc->soundData;
+					}
+					samples = chunk->sndChunk;
+					ooff -= SND_CHUNK_SIZE;
+				}
+				if ( sc->soundChannels == 2 ) {
+					fdata[0] += samples[j&(SND_CHUNK_SIZE-1)];
+					fdata[1] += samples[(j+1)&(SND_CHUNK_SIZE-1)];
+				} else {
+					fdata[0] += samples[j&(SND_CHUNK_SIZE-1)];
+					fdata[1] += samples[j&(SND_CHUNK_SIZE-1)];
+				}
+			}
+			fdiv = 256 * (boff-aoff) / sc->soundChannels;
+			samp[i].left += (fdata[0] * fleftvol)/fdiv;
+			samp[i].right += (fdata[1] * frightvol)/fdiv;
+		}
+	}
+}
+#endif
+
+static void S_PaintChannelFrom16_scalar( channel_t *ch, const sfx_t *sc, int count, int sampleOffset, int bufferOffset ) {
+	int						data, aoff, boff;
+	int						leftvol, rightvol;
+	int						i, j;
+	portable_samplepair_t	*samp;
+	sndBuffer				*chunk;
+	short					*samples;
+	float					ooff, fdata[2], fdiv, fleftvol, frightvol;
+
+	if (sc->soundChannels <= 0) {
+		return;
+	}
+
+	samp = &paintbuffer[ bufferOffset ];
+
+	if (ch->doppler) {
+		sampleOffset = sampleOffset*ch->oldDopplerScale;
+	}
+
+	if ( sc->soundChannels == 2 ) {
+		sampleOffset *= sc->soundChannels;
+
+		if ( sampleOffset & 1 ) {
+			sampleOffset &= ~1;
+		}
+	}
+
+	chunk = sc->soundData;
+	while (sampleOffset>=SND_CHUNK_SIZE) {
+		chunk = chunk->next;
+		sampleOffset -= SND_CHUNK_SIZE;
+		if (!chunk) {
+			chunk = sc->soundData;
+		}
+	}
+
+	if (!ch->doppler || ch->dopplerScale==1.0f) {
+		leftvol = ch->leftvol*snd_vol;
+		rightvol = ch->rightvol*snd_vol;
+		samples = chunk->sndChunk;
+		for ( i=0 ; i<count ; i++ ) {
+			data  = samples[sampleOffset++];
+			samp[i].left += (data * leftvol)>>8;
+
+			if ( sc->soundChannels == 2 ) {
+				data = samples[sampleOffset++];
+			}
+			samp[i].right += (data * rightvol)>>8;
+
+			if (sampleOffset == SND_CHUNK_SIZE) {
+				chunk = chunk->next;
+				samples = chunk->sndChunk;
+				sampleOffset = 0;
+			}
+		}
+	} else {
+		fleftvol = ch->leftvol*snd_vol;
+		frightvol = ch->rightvol*snd_vol;
+
+		ooff = sampleOffset;
+		samples = chunk->sndChunk;
+		
+
+
+
+		for ( i=0 ; i<count ; i++ ) {
+
+			aoff = ooff;
+			ooff = ooff + ch->dopplerScale * sc->soundChannels;
+			boff = ooff;
+			fdata[0] = fdata[1] = 0;
+			for (j=aoff; j<boff; j += sc->soundChannels) {
+				if (j == SND_CHUNK_SIZE) {
+					chunk = chunk->next;
+					if (!chunk) {
+						chunk = sc->soundData;
+					}
+					samples = chunk->sndChunk;
+					ooff -= SND_CHUNK_SIZE;
+				}
+				if ( sc->soundChannels == 2 ) {
+					fdata[0] += samples[j&(SND_CHUNK_SIZE-1)];
+					fdata[1] += samples[(j+1)&(SND_CHUNK_SIZE-1)];
+				} else {
+					fdata[0] += samples[j&(SND_CHUNK_SIZE-1)];
+					fdata[1] += samples[j&(SND_CHUNK_SIZE-1)];
+				}
+			}
+			fdiv = 256 * (boff-aoff) / sc->soundChannels;
+			samp[i].left += (fdata[0] * fleftvol)/fdiv;
+			samp[i].right += (fdata[1] * frightvol)/fdiv;
+		}
+	}
+}
+
+static void S_PaintChannelFrom16( channel_t *ch, const sfx_t *sc, int count, int sampleOffset, int bufferOffset ) {
+#if idppc_altivec
+	if (com_altivec->integer) {
+		// must be in a seperate function or G3 systems will crash.
+		S_PaintChannelFrom16_altivec( ch, sc, count, sampleOffset, bufferOffset );
+		return;
+	}
+#endif
+	S_PaintChannelFrom16_scalar( ch, sc, count, sampleOffset, bufferOffset );
+}
+
+void S_PaintChannelFromWavelet( channel_t *ch, sfx_t *sc, int count, int sampleOffset, int bufferOffset ) {
+	int						data;
+	int						leftvol, rightvol;
+	int						i;
+	portable_samplepair_t	*samp;
+	sndBuffer				*chunk;
+	short					*samples;
+
+	leftvol = ch->leftvol*snd_vol;
+	rightvol = ch->rightvol*snd_vol;
+
+	i = 0;
+	samp = &paintbuffer[ bufferOffset ];
+	chunk = sc->soundData;
+	while (sampleOffset>=(SND_CHUNK_SIZE_FLOAT*4)) {
+		chunk = chunk->next;
+		sampleOffset -= (SND_CHUNK_SIZE_FLOAT*4);
+		i++;
+	}
+
+	if (i!=sfxScratchIndex || sfxScratchPointer != sc) {
+		S_AdpcmGetSamples( chunk, sfxScratchBuffer );
+		sfxScratchIndex = i;
+		sfxScratchPointer = sc;
+	}
+
+	samples = sfxScratchBuffer;
+
+	for ( i=0 ; i<count ; i++ ) {
+		data  = samples[sampleOffset++];
+		samp[i].left += (data * leftvol)>>8;
+		samp[i].right += (data * rightvol)>>8;
+
+		if (sampleOffset == SND_CHUNK_SIZE*2) {
+			chunk = chunk->next;
+			decodeWavelet(chunk, sfxScratchBuffer);
+			sfxScratchIndex++;
+			sampleOffset = 0;
+		}
+	}
+}
+
+void S_PaintChannelFromADPCM( channel_t *ch, sfx_t *sc, int count, int sampleOffset, int bufferOffset ) {
+	int						data;
+	int						leftvol, rightvol;
+	int						i;
+	portable_samplepair_t	*samp;
+	sndBuffer				*chunk;
+	short					*samples;
+
+	leftvol = ch->leftvol*snd_vol;
+	rightvol = ch->rightvol*snd_vol;
+
+	i = 0;
+	samp = &paintbuffer[ bufferOffset ];
+	chunk = sc->soundData;
+
+	if (ch->doppler) {
+		sampleOffset = sampleOffset*ch->oldDopplerScale;
+	}
+
+	while (sampleOffset>=(SND_CHUNK_SIZE*4)) {
+		chunk = chunk->next;
+		sampleOffset -= (SND_CHUNK_SIZE*4);
+		i++;
+	}
+
+	if (i!=sfxScratchIndex || sfxScratchPointer != sc) {
+		S_AdpcmGetSamples( chunk, sfxScratchBuffer );
+		sfxScratchIndex = i;
+		sfxScratchPointer = sc;
+	}
+
+	samples = sfxScratchBuffer;
+
+	for ( i=0 ; i<count ; i++ ) {
+		data  = samples[sampleOffset++];
+		samp[i].left += (data * leftvol)>>8;
+		samp[i].right += (data * rightvol)>>8;
+
+		if (sampleOffset == SND_CHUNK_SIZE*4) {
+			chunk = chunk->next;
+			S_AdpcmGetSamples( chunk, sfxScratchBuffer);
+			sampleOffset = 0;
+			sfxScratchIndex++;
+		}
+	}
+}
+
+void S_PaintChannelFromMuLaw( channel_t *ch, sfx_t *sc, int count, int sampleOffset, int bufferOffset ) {
+	int						data;
+	int						leftvol, rightvol;
+	int						i;
+	portable_samplepair_t	*samp;
+	sndBuffer				*chunk;
+	byte					*samples;
+	float					ooff;
+
+	leftvol = ch->leftvol*snd_vol;
+	rightvol = ch->rightvol*snd_vol;
+
+	samp = &paintbuffer[ bufferOffset ];
+	chunk = sc->soundData;
+	while (sampleOffset>=(SND_CHUNK_SIZE*2)) {
+		chunk = chunk->next;
+		sampleOffset -= (SND_CHUNK_SIZE*2);
+		if (!chunk) {
+			chunk = sc->soundData;
+		}
+	}
+
+	if (!ch->doppler) {
+		samples = (byte *)chunk->sndChunk + sampleOffset;
+		for ( i=0 ; i<count ; i++ ) {
+			data  = mulawToShort[*samples];
+			samp[i].left += (data * leftvol)>>8;
+			samp[i].right += (data * rightvol)>>8;
+			samples++;
+			if (chunk != NULL && samples == (byte *)chunk->sndChunk+(SND_CHUNK_SIZE*2)) {
+				chunk = chunk->next;
+				samples = (byte *)chunk->sndChunk;
+			}
+		}
+	} else {
+		ooff = sampleOffset;
+		samples = (byte *)chunk->sndChunk;
+		for ( i=0 ; i<count ; i++ ) {
+			data  = mulawToShort[samples[(int)(ooff)]];
+			ooff = ooff + ch->dopplerScale;
+			samp[i].left += (data * leftvol)>>8;
+			samp[i].right += (data * rightvol)>>8;
+			if (ooff >= SND_CHUNK_SIZE*2) {
+				chunk = chunk->next;
+				if (!chunk) {
+					chunk = sc->soundData;
+				}
+				samples = (byte *)chunk->sndChunk;
+				ooff = 0.0;
+			}
+		}
+	}
+}
+
+/*
+===================
+S_PaintChannels
+===================
+*/
+void S_PaintChannels( int endtime ) {
+	int 	i;
+	int 	end;
+	int 	stream;
+	channel_t *ch;
+	sfx_t	*sc;
+	int		ltime, count;
+	int		sampleOffset;
+
+	if(s_muted->integer)
+		snd_vol = 0;
+	else
+		snd_vol = s_volume->value*255;
+
+//Com_Printf ("%i to %i\n", s_paintedtime, endtime);
+	while ( s_paintedtime < endtime ) {
+		// if paintbuffer is smaller than DMA buffer
+		// we may need to fill it multiple times
+		end = endtime;
+		if ( endtime - s_paintedtime > PAINTBUFFER_SIZE ) {
+			end = s_paintedtime + PAINTBUFFER_SIZE;
+		}
+
+		// clear the paint buffer and mix any raw samples...
+		::memset(paintbuffer, 0, sizeof (paintbuffer));
+		for (stream = 0; stream < MAX_RAW_STREAMS; stream++) {
+			if ( s_rawend[stream] >= s_paintedtime ) {
+				// copy from the streaming sound source
+				const portable_samplepair_t *rawsamples = s_rawsamples[stream];
+				const int stop = (end < s_rawend[stream]) ? end : s_rawend[stream];
+				for ( i = s_paintedtime ; i < stop ; i++ ) {
+					const int s = i&(MAX_RAW_SAMPLES-1);
+					paintbuffer[i-s_paintedtime].left += rawsamples[s].left;
+					paintbuffer[i-s_paintedtime].right += rawsamples[s].right;
+				}
+			}
+		}
+
+		// paint in the channels.
+		ch = s_channels;
+		for ( i = 0; i < MAX_CHANNELS ; i++, ch++ ) {		
+			if ( !ch->thesfx || (ch->leftvol<0.25 && ch->rightvol<0.25 )) {
+				continue;
+			}
+
+			ltime = s_paintedtime;
+			sc = ch->thesfx;
+
+			if (sc->soundData==NULL || sc->soundLength==0) {
+				continue;
+			}
+
+			sampleOffset = ltime - ch->startSample;
+			count = end - ltime;
+			if ( sampleOffset + count > sc->soundLength ) {
+				count = sc->soundLength - sampleOffset;
+			}
+
+			if ( count > 0 ) {	
+				if( sc->soundCompressionMethod == 1) {
+					S_PaintChannelFromADPCM		(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+				} else if( sc->soundCompressionMethod == 2) {
+					S_PaintChannelFromWavelet	(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+				} else if( sc->soundCompressionMethod == 3) {
+					S_PaintChannelFromMuLaw	(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+				} else {
+					S_PaintChannelFrom16		(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+				}
+			}
+		}
+
+		// paint in the looped channels.
+		ch = loop_channels;
+		for ( i = 0; i < numLoopChannels ; i++, ch++ ) {		
+			if ( !ch->thesfx || (!ch->leftvol && !ch->rightvol )) {
+				continue;
+			}
+
+			ltime = s_paintedtime;
+			sc = ch->thesfx;
+
+			if (sc->soundData==NULL || sc->soundLength==0) {
+				continue;
+			}
+			// we might have to make two passes if it
+			// is a looping sound effect and the end of
+			// the sample is hit
+			do {
+				sampleOffset = (ltime % sc->soundLength);
+
+				count = end - ltime;
+				if ( sampleOffset + count > sc->soundLength ) {
+					count = sc->soundLength - sampleOffset;
+				}
+
+				if ( count > 0 ) {	
+					if( sc->soundCompressionMethod == 1) {
+						S_PaintChannelFromADPCM		(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+					} else if( sc->soundCompressionMethod == 2) {
+						S_PaintChannelFromWavelet	(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+					} else if( sc->soundCompressionMethod == 3) {
+						S_PaintChannelFromMuLaw		(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+					} else {
+						S_PaintChannelFrom16		(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+					}
+					ltime += count;
+				}
+			} while ( ltime < end);
+		}
+
+		// transfer out according to DMA format
+		S_TransferPaintBuffer( end );
+		s_paintedtime = end;
+	}
+}
diff --git a/src/client/snd_openal.cpp b/src/client/snd_openal.cpp
new file mode 100644
index 0000000..7ee53e2
--- /dev/null
+++ b/src/client/snd_openal.cpp
@@ -0,0 +1,2737 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2005 Stuart Dalton (badcdev@gmail.com)
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include "snd_local.h"
+#include "snd_codec.h"
+#include "client.h"
+
+#ifdef USE_OPENAL
+
+#include "qal.h"
+
+// Console variables specific to OpenAL
+cvar_t *s_alPrecache;
+cvar_t *s_alGain;
+cvar_t *s_alSources;
+cvar_t *s_alDopplerFactor;
+cvar_t *s_alDopplerSpeed;
+cvar_t *s_alMinDistance;
+cvar_t *s_alMaxDistance;
+cvar_t *s_alRolloff;
+cvar_t *s_alGraceDistance;
+cvar_t *s_alDriver;
+cvar_t *s_alDevice;
+cvar_t *s_alInputDevice;
+cvar_t *s_alAvailableDevices;
+cvar_t *s_alAvailableInputDevices;
+
+static bool enumeration_ext = false;
+static bool enumeration_all_ext = false;
+#ifdef USE_VOIP
+static bool capture_ext = false;
+#endif
+
+/*
+=================
+S_AL_Format
+=================
+*/
+static
+ALuint S_AL_Format(int width, int channels)
+{
+	ALuint format = AL_FORMAT_MONO16;
+
+	// Work out format
+	if(width == 1)
+	{
+		if(channels == 1)
+			format = AL_FORMAT_MONO8;
+		else if(channels == 2)
+			format = AL_FORMAT_STEREO8;
+	}
+	else if(width == 2)
+	{
+		if(channels == 1)
+			format = AL_FORMAT_MONO16;
+		else if(channels == 2)
+			format = AL_FORMAT_STEREO16;
+	}
+
+	return format;
+}
+
+/*
+=================
+S_AL_ErrorMsg
+=================
+*/
+static const char *S_AL_ErrorMsg(ALenum error)
+{
+	switch(error)
+	{
+		case AL_NO_ERROR:
+			return "No error";
+		case AL_INVALID_NAME:
+			return "Invalid name";
+		case AL_INVALID_ENUM:
+			return "Invalid enumerator";
+		case AL_INVALID_VALUE:
+			return "Invalid value";
+		case AL_INVALID_OPERATION:
+			return "Invalid operation";
+		case AL_OUT_OF_MEMORY:
+			return "Out of memory";
+		default:
+			return "Unknown error";
+	}
+}
+
+/*
+=================
+S_AL_ClearError
+=================
+*/
+static void S_AL_ClearError( bool quiet )
+{
+	int error = qalGetError();
+
+	if( quiet )
+		return;
+	if(error != AL_NO_ERROR)
+	{
+		Com_Printf(S_COLOR_YELLOW "WARNING: unhandled AL error: %s\n",
+			S_AL_ErrorMsg(error));
+	}
+}
+
+
+//===========================================================================
+
+
+typedef struct alSfx_s
+{
+	char		filename[MAX_QPATH];
+	ALuint		buffer;					// OpenAL buffer
+	snd_info_t	info;					// information for this sound like rate, sample count..
+
+    bool		isDefault;				// Couldn't be loaded - use default FX
+    bool		isDefaultChecked;		// Sound has been check if it isDefault
+    bool		inMemory;				// Sound is stored in memory
+    bool		isLocked;				// Sound is locked (can not be unloaded)
+	int			lastUsedTime;		// Time last used
+
+	int			duration;				// Milliseconds
+
+	int			loopCnt;		// number of loops using this sfx
+	int			loopActiveCnt;		// number of playing loops using this sfx
+	int			masterLoopSrc;		// All other sources looping this buffer are synced to this master src
+} alSfx_t;
+
+static bool alBuffersInitialised = false;
+
+// Sound effect storage, data structures
+#define MAX_SFX 4096
+static alSfx_t knownSfx[MAX_SFX];
+static sfxHandle_t numSfx = 0;
+
+static sfxHandle_t default_sfx;
+
+/*
+=================
+S_AL_BufferFindFree
+
+Find a free handle
+=================
+*/
+static sfxHandle_t S_AL_BufferFindFree( void )
+{
+	int i;
+
+	for(i = 0; i < MAX_SFX; i++)
+	{
+		// Got one
+		if(knownSfx[i].filename[0] == '\0')
+		{
+			if(i >= numSfx)
+				numSfx = i + 1;
+			return i;
+		}
+	}
+
+	// Shit...
+	Com_Error(ERR_FATAL, "S_AL_BufferFindFree: No free sound handles");
+	return -1;
+}
+
+/*
+=================
+S_AL_BufferFind
+
+Find a sound effect if loaded, set up a handle otherwise
+=================
+*/
+static sfxHandle_t S_AL_BufferFind(const char *filename)
+{
+	// Look it up in the table
+	sfxHandle_t sfx = -1;
+	int i;
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "Sound name is NULL" );
+	}
+
+	if ( !filename[0] ) {
+		Com_Printf( S_COLOR_YELLOW "WARNING: Sound name is empty\n" );
+		return 0;
+	}
+
+	if ( strlen( filename ) >= MAX_QPATH ) {
+		Com_Printf( S_COLOR_YELLOW "WARNING: Sound name is too long: %s\n", filename );
+		return 0;
+	}
+
+	if ( filename[0] == '*' ) {
+		Com_Printf( S_COLOR_YELLOW "WARNING: Tried to load player sound directly: %s\n", filename );
+		return 0;
+	}
+
+	for(i = 0; i < numSfx; i++)
+	{
+		if(!Q_stricmp(knownSfx[i].filename, filename))
+		{
+			sfx = i;
+			break;
+		}
+	}
+
+	// Not found in table?
+	if(sfx == -1)
+	{
+		alSfx_t *ptr;
+
+		sfx = S_AL_BufferFindFree();
+
+		// Clear and copy the filename over
+		ptr = &knownSfx[sfx];
+		memset(ptr, 0, sizeof(*ptr));
+		ptr->masterLoopSrc = -1;
+		strcpy(ptr->filename, filename);
+	}
+
+	// Return the handle
+	return sfx;
+}
+
+/*
+=================
+S_AL_BufferUseDefault
+=================
+*/
+static void S_AL_BufferUseDefault(sfxHandle_t sfx)
+{
+	if(sfx == default_sfx)
+		Com_Error(ERR_FATAL, "Can't load default sound effect %s", knownSfx[sfx].filename);
+
+	Com_Printf( S_COLOR_YELLOW "WARNING: Using default sound for %s\n", knownSfx[sfx].filename);
+	knownSfx[sfx].isDefault = true;
+	knownSfx[sfx].buffer = knownSfx[default_sfx].buffer;
+}
+
+/*
+=================
+S_AL_BufferUnload
+=================
+*/
+static void S_AL_BufferUnload(sfxHandle_t sfx)
+{
+	if(knownSfx[sfx].filename[0] == '\0')
+		return;
+
+	if(!knownSfx[sfx].inMemory)
+		return;
+
+	// Delete it 
+	S_AL_ClearError( false );
+	qalDeleteBuffers(1, &knownSfx[sfx].buffer);
+	if(qalGetError() != AL_NO_ERROR)
+		Com_Printf( S_COLOR_RED "ERROR: Can't delete sound buffer for %s\n",
+				knownSfx[sfx].filename);
+
+	knownSfx[sfx].inMemory = false;
+}
+
+/*
+=================
+S_AL_BufferEvict
+=================
+*/
+static bool S_AL_BufferEvict( void )
+{
+	int	i, oldestBuffer = -1;
+	int	oldestTime = Sys_Milliseconds( );
+
+	for( i = 0; i < numSfx; i++ )
+	{
+		if( !knownSfx[ i ].filename[ 0 ] )
+			continue;
+
+		if( !knownSfx[ i ].inMemory )
+			continue;
+
+		if( knownSfx[ i ].lastUsedTime < oldestTime )
+		{
+			oldestTime = knownSfx[ i ].lastUsedTime;
+			oldestBuffer = i;
+		}
+	}
+
+	if( oldestBuffer >= 0 )
+	{
+		S_AL_BufferUnload( oldestBuffer );
+		return true;
+	}
+	else
+		return false;
+}
+
+/*
+=================
+S_AL_GenBuffers
+=================
+*/
+static bool S_AL_GenBuffers(ALsizei numBuffers, ALuint *buffers, const char *name)
+{
+	S_AL_ClearError( false );
+	qalGenBuffers( numBuffers, buffers );
+	ALenum error = qalGetError();
+
+	// If we ran out of buffers, start evicting the least recently used sounds
+	while( error == AL_INVALID_VALUE )
+	{
+		if( !S_AL_BufferEvict( ) )
+		{
+			Com_Printf( S_COLOR_RED "ERROR: Out of audio buffers\n");
+			return false;
+		}
+
+		// Try again
+		S_AL_ClearError( false );
+		qalGenBuffers( numBuffers, buffers );
+		error = qalGetError();
+	}
+
+	if( error != AL_NO_ERROR )
+	{
+		Com_Printf( S_COLOR_RED "ERROR: Can't create a sound buffer for %s - %s\n",
+				    name, S_AL_ErrorMsg(error));
+		return false;
+	}
+
+	return true;
+}
+
+/*
+=================
+S_AL_BufferLoad
+=================
+*/
+static void S_AL_BufferLoad(sfxHandle_t sfx, bool cache)
+{
+	ALenum error;
+	ALuint format;
+
+	void *data;
+	snd_info_t info;
+	alSfx_t *curSfx = &knownSfx[sfx];
+
+	// Nothing?
+	if(curSfx->filename[0] == '\0')
+		return;
+
+	// Already done?
+	if((curSfx->inMemory) || (curSfx->isDefault) || (!cache && curSfx->isDefaultChecked))
+		return;
+
+	// Try to load
+	data = S_CodecLoad(curSfx->filename, &info);
+	if(!data)
+	{
+		S_AL_BufferUseDefault(sfx);
+		return;
+	}
+
+	curSfx->isDefaultChecked = true;
+
+	if (!cache)
+	{
+		// Don't create AL cache
+		Hunk_FreeTempMemory(data);
+		return;
+	}
+
+	format = S_AL_Format(info.width, info.channels);
+
+	// Create a buffer
+	if (!S_AL_GenBuffers(1, &curSfx->buffer, curSfx->filename))
+	{
+		S_AL_BufferUseDefault(sfx);
+		Hunk_FreeTempMemory(data);
+		return;
+	}
+
+	// Fill the buffer
+	if( info.size == 0 )
+	{
+		// We have no data to buffer, so buffer silence
+		byte dummyData[ 2 ] = { 0 };
+
+		qalBufferData(curSfx->buffer, AL_FORMAT_MONO16, (void *)dummyData, 2, 22050);
+	}
+	else
+		qalBufferData(curSfx->buffer, format, data, info.size, info.rate);
+
+	error = qalGetError();
+
+	// If we ran out of memory, start evicting the least recently used sounds
+	while(error == AL_OUT_OF_MEMORY)
+	{
+		if( !S_AL_BufferEvict( ) )
+		{
+			qalDeleteBuffers(1, &curSfx->buffer);
+			S_AL_BufferUseDefault(sfx);
+			Hunk_FreeTempMemory(data);
+			Com_Printf( S_COLOR_RED "ERROR: Out of memory loading %s\n", curSfx->filename);
+			return;
+		}
+
+		// Try load it again
+		qalBufferData(curSfx->buffer, format, data, info.size, info.rate);
+		error = qalGetError();
+	}
+
+	// Some other error condition
+	if(error != AL_NO_ERROR)
+	{
+		qalDeleteBuffers(1, &curSfx->buffer);
+		S_AL_BufferUseDefault(sfx);
+		Hunk_FreeTempMemory(data);
+		Com_Printf( S_COLOR_RED "ERROR: Can't fill sound buffer for %s - %s\n",
+				curSfx->filename, S_AL_ErrorMsg(error));
+		return;
+	}
+
+	curSfx->info = info;
+	
+	// Free the memory
+	Hunk_FreeTempMemory(data);
+
+	// Woo!
+	curSfx->inMemory = true;
+}
+
+/*
+=================
+S_AL_BufferUse
+=================
+*/
+static void S_AL_BufferUse(sfxHandle_t sfx)
+{
+	if(knownSfx[sfx].filename[0] == '\0')
+		return;
+
+	if((!knownSfx[sfx].inMemory) && (!knownSfx[sfx].isDefault))
+		S_AL_BufferLoad(sfx, true);
+	knownSfx[sfx].lastUsedTime = Sys_Milliseconds();
+}
+
+/*
+=================
+S_AL_BufferInit
+=================
+*/
+static bool S_AL_BufferInit( void )
+{
+	if(alBuffersInitialised)
+		return true;
+
+	// Clear the hash table, and SFX table
+	memset(knownSfx, 0, sizeof(knownSfx));
+	numSfx = 0;
+
+	// Load the default sound, and lock it
+	default_sfx = S_AL_BufferFind("sound/feedback/hit.wav");
+	S_AL_BufferUse(default_sfx);
+	knownSfx[default_sfx].isLocked = true;
+
+	// All done
+	alBuffersInitialised = true;
+	return true;
+}
+
+/*
+=================
+S_AL_BufferShutdown
+=================
+*/
+static void S_AL_BufferShutdown( void )
+{
+	if(!alBuffersInitialised)
+		return;
+
+	// Unlock the default sound effect
+	knownSfx[default_sfx].isLocked = false;
+
+	// Free all used effects
+	for(int i = 0; i < numSfx; i++)
+		S_AL_BufferUnload(i);
+
+	// Clear the tables
+	numSfx = 0;
+
+	// All undone
+	alBuffersInitialised = false;
+}
+
+/*
+=================
+S_AL_RegisterSound
+=================
+*/
+static sfxHandle_t S_AL_RegisterSound( const char *sample, bool compressed )
+{
+	sfxHandle_t sfx = S_AL_BufferFind(sample);
+
+	if((!knownSfx[sfx].inMemory) && (!knownSfx[sfx].isDefault))
+		S_AL_BufferLoad(sfx, s_alPrecache->integer ? true : false);
+	knownSfx[sfx].lastUsedTime = Com_Milliseconds();
+
+	if (knownSfx[sfx].isDefault) {
+		return 0;
+	}
+
+	return sfx;
+}
+
+/*
+=================
+S_AL_SoundDuration
+=================
+*/
+static int S_AL_SoundDuration( sfxHandle_t sfx )
+{
+	if (sfx < 0 || sfx >= numSfx)
+	{
+		Com_Printf(S_COLOR_RED "ERROR: S_AL_SoundDuration: handle %i out of range\n", sfx);
+		return 0;
+	}
+	return knownSfx[sfx].duration;
+}
+
+/*
+=================
+S_AL_BufferGet
+
+Return's a sfx's buffer
+=================
+*/
+static
+ALuint S_AL_BufferGet(sfxHandle_t sfx)
+{
+	return knownSfx[sfx].buffer;
+}
+
+
+//===========================================================================
+
+
+typedef struct src_s
+{
+	ALuint		alSource;		// OpenAL source object
+	sfxHandle_t	sfx;			// Sound effect in use
+
+	int		lastUsedTime;		// Last time used
+	alSrcPriority_t	priority;		// Priority
+	int		entity;			// Owning entity (-1 if none)
+	int		channel;		// Associated channel (-1 if none)
+
+    bool		isActive;		// Is this source currently in use?
+    bool		isPlaying;		// Is this source currently playing, or stopped?
+    bool		isLocked;		// This is locked (un-allocatable)
+    bool		isLooping;		// Is this a looping effect (attached to an entity)
+    bool		isTracking;		// Is this object tracking its owner
+    bool		isStream;		// Is this source a stream
+
+	float		curGain;		// gain employed if source is within maxdistance.
+	float		scaleGain;		// Last gain value for this source. 0 if muted.
+	
+	float		lastTimePos;		// On stopped loops, the last position in the buffer
+	int		lastSampleTime;		// Time when this was stopped
+	vec3_t		loopSpeakerPos;		// Origin of the loop speaker
+	
+	bool	local;			// Is this local (relative to the cam)
+} src_t;
+
+#ifdef __APPLE__
+	#define MAX_SRC 64
+#else
+	#define MAX_SRC 128
+#endif
+static src_t srcList[MAX_SRC];
+static int srcCount = 0;
+static int srcActiveCnt = 0;
+static bool alSourcesInitialised = false;
+static int lastListenerNumber = -1;
+static vec3_t lastListenerOrigin = { 0.0f, 0.0f, 0.0f };
+
+typedef struct sentity_s
+{
+	vec3_t				origin;
+
+	bool				srcAllocated; // If a src_t has been allocated to this entity
+	int					srcIndex;
+
+	bool				loopAddedThisFrame;
+	alSrcPriority_t	loopPriority;
+	sfxHandle_t			loopSfx;
+	bool				startLoopingSound;
+} sentity_t;
+
+static sentity_t entityList[MAX_GENTITIES];
+
+/*
+=================
+S_AL_SanitiseVector
+=================
+*/
+#define S_AL_SanitiseVector(v) _S_AL_SanitiseVector(v,__LINE__)
+static void _S_AL_SanitiseVector( vec3_t v, int line )
+{
+	if( Q_isnan( v[ 0 ] ) || Q_isnan( v[ 1 ] ) || Q_isnan( v[ 2 ] ) )
+	{
+		Com_DPrintf( S_COLOR_YELLOW "WARNING: vector with one or more NaN components "
+				"being passed to OpenAL at %s:%d -- zeroing\n", __FILE__, line );
+		VectorClear( v );
+	}
+}
+
+/*
+=================
+S_AL_Gain
+Set gain to 0 if muted, otherwise set it to given value.
+=================
+*/
+
+static void S_AL_Gain(ALuint source, float gainval)
+{
+	if(s_muted->integer)
+		qalSourcef(source, AL_GAIN, 0.0f);
+	else
+		qalSourcef(source, AL_GAIN, gainval);
+}
+
+/*
+=================
+S_AL_ScaleGain
+Adapt the gain if necessary to get a quicker fadeout when the source is too far away.
+=================
+*/
+
+static void S_AL_ScaleGain(src_t *chksrc, vec3_t origin)
+{
+	float distance;
+	
+	if(!chksrc->local)
+		distance = Distance(origin, lastListenerOrigin);
+		
+	// If we exceed a certain distance, scale the gain linearly until the sound
+	// vanishes into nothingness.
+	if(!chksrc->local && (distance -= s_alMaxDistance->value) > 0)
+	{
+		float scaleFactor;
+
+		if(distance >= s_alGraceDistance->value)
+			scaleFactor = 0.0f;
+		else
+			scaleFactor = 1.0f - distance / s_alGraceDistance->value;
+		
+		scaleFactor *= chksrc->curGain;
+		
+		if(chksrc->scaleGain != scaleFactor)
+		{
+			chksrc->scaleGain = scaleFactor;
+			S_AL_Gain(chksrc->alSource, chksrc->scaleGain);
+		}
+	}
+	else if(chksrc->scaleGain != chksrc->curGain)
+	{
+		chksrc->scaleGain = chksrc->curGain;
+		S_AL_Gain(chksrc->alSource, chksrc->scaleGain);
+	}
+}
+
+/*
+=================
+S_AL_HearingThroughEntity
+
+Also see S_Base_HearingThroughEntity
+=================
+*/
+static bool S_AL_HearingThroughEntity( int entityNum )
+{
+
+	if( lastListenerNumber == entityNum )
+	{
+		// This is an outrageous hack to detect
+		// whether or not the player is rendering in third person or not. We can't
+		// ask the renderer because the renderer has no notion of entities and we
+		// can't ask cgame since that would involve changing the API and hence mod
+		// compatibility. I don't think there is any way around this, but I'll leave
+		// the FIXME just in case anyone has a bright idea.
+	    float distanceSq = DistanceSquared( entityList[ entityNum ].origin, lastListenerOrigin );
+		if( distanceSq > THIRD_PERSON_THRESHOLD_SQ )
+			return false; //we're the player, but third person
+
+        //we're the player
+		return true;
+	}
+
+    //not the player
+	return false;
+}
+
+/*
+=================
+S_AL_SrcInit
+=================
+*/
+static bool S_AL_SrcInit( void )
+{
+	int i;
+	int limit;
+
+	// Clear the sources data structure
+	memset(srcList, 0, sizeof(srcList));
+	srcCount = 0;
+	srcActiveCnt = 0;
+
+	// Cap s_alSources to MAX_SRC
+	limit = s_alSources->integer;
+	if(limit > MAX_SRC)
+		limit = MAX_SRC;
+	else if(limit < 16)
+		limit = 16;
+ 
+	S_AL_ClearError( false );
+	// Allocate as many sources as possible
+	for(i = 0; i < limit; i++)
+	{
+		qalGenSources(1, &srcList[i].alSource);
+		if(qalGetError() != AL_NO_ERROR)
+			break;
+		srcCount++;
+	}
+
+	// All done. Print this for informational purposes
+	Com_Printf( "Allocated %d sources.\n", srcCount);
+	alSourcesInitialised = true;
+	return true;
+}
+
+/*
+=================
+S_AL_SrcShutdown
+=================
+*/
+static
+void S_AL_SrcShutdown( void )
+{
+	int i;
+	src_t *curSource;
+
+	if(!alSourcesInitialised)
+		return;
+
+	// Destroy all the sources
+	for(i = 0; i < srcCount; i++)
+	{
+		curSource = &srcList[i];
+		
+		if(curSource->isLocked)
+			Com_DPrintf( S_COLOR_YELLOW "WARNING: Source %d is locked\n", i);
+
+		if(curSource->entity > 0)
+			entityList[curSource->entity].srcAllocated = false;
+
+		qalSourceStop(srcList[i].alSource);
+		qalDeleteSources(1, &srcList[i].alSource);
+	}
+
+	memset(srcList, 0, sizeof(srcList));
+
+	alSourcesInitialised = false;
+}
+
+/*
+=================
+S_AL_SrcSetup
+=================
+*/
+static void S_AL_SrcSetup(srcHandle_t src, sfxHandle_t sfx, alSrcPriority_t priority, int entity, int channel, bool local)
+{
+	src_t *curSource;
+
+	// Set up src struct
+	curSource = &srcList[src];
+	
+	curSource->lastUsedTime = Sys_Milliseconds();
+	curSource->sfx = sfx;
+	curSource->priority = priority;
+	curSource->entity = entity;
+	curSource->channel = channel;
+	curSource->isPlaying = false;
+	curSource->isLocked = false;
+	curSource->isLooping = false;
+	curSource->isTracking = false;
+	curSource->isStream = false;
+	curSource->curGain = s_alGain->value * s_volume->value;
+	curSource->scaleGain = curSource->curGain;
+	curSource->local = local;
+
+	// Set up OpenAL source
+	if(sfx >= 0)
+	{
+        	// Mark the SFX as used, and grab the raw AL buffer
+        	S_AL_BufferUse(sfx);
+        	qalSourcei(curSource->alSource, AL_BUFFER, S_AL_BufferGet(sfx));
+	}
+
+	qalSourcef(curSource->alSource, AL_PITCH, 1.0f);
+	S_AL_Gain(curSource->alSource, curSource->curGain);
+	qalSourcefv(curSource->alSource, AL_POSITION, vec3_origin);
+	qalSourcefv(curSource->alSource, AL_VELOCITY, vec3_origin);
+	qalSourcei(curSource->alSource, AL_LOOPING, AL_FALSE);
+	qalSourcef(curSource->alSource, AL_REFERENCE_DISTANCE, s_alMinDistance->value);
+
+	if(local)
+	{
+		qalSourcei(curSource->alSource, AL_SOURCE_RELATIVE, AL_TRUE);
+		qalSourcef(curSource->alSource, AL_ROLLOFF_FACTOR, 0.0f);
+	}
+	else
+	{
+		qalSourcei(curSource->alSource, AL_SOURCE_RELATIVE, AL_FALSE);
+		qalSourcef(curSource->alSource, AL_ROLLOFF_FACTOR, s_alRolloff->value);
+	}
+}
+
+/*
+=================
+S_AL_SaveLoopPos
+Remove given source as loop master if it is the master and hand off master status to another source in this case.
+=================
+*/
+
+static void S_AL_SaveLoopPos(src_t *dest, ALuint alSource)
+{
+	int error;
+	
+	S_AL_ClearError(false);
+	
+	qalGetSourcef(alSource, AL_SEC_OFFSET, &dest->lastTimePos);
+	if((error = qalGetError()) != AL_NO_ERROR)
+	{
+		// Old OpenAL implementations don't support AL_SEC_OFFSET
+
+		if(error != AL_INVALID_ENUM)
+		{
+			Com_Printf(S_COLOR_YELLOW "WARNING: Could not get time offset for alSource %d: %s\n",
+				   alSource, S_AL_ErrorMsg(error));
+		}
+		
+		dest->lastTimePos = -1;
+	}
+	else
+		dest->lastSampleTime = Sys_Milliseconds();
+}
+
+/*
+=================
+S_AL_NewLoopMaster
+Remove given source as loop master if it is the master and hand off master status to another source in this case.
+=================
+*/
+
+static void S_AL_NewLoopMaster(src_t *rmSource, bool iskilled)
+{
+	int index;
+	src_t *curSource = NULL;
+	alSfx_t *curSfx;
+	
+	curSfx = &knownSfx[rmSource->sfx];
+
+	if(rmSource->isPlaying)
+		curSfx->loopActiveCnt--;
+	if(iskilled)
+		curSfx->loopCnt--;
+	
+	if(curSfx->loopCnt)
+	{
+		if(rmSource->priority == SRCPRI_ENTITY)
+		{
+			if(!iskilled && rmSource->isPlaying)
+			{
+				// only sync ambient loops...
+				// It makes more sense to have sounds for weapons/projectiles unsynced
+				S_AL_SaveLoopPos(rmSource, rmSource->alSource);
+			}
+		}
+		else if(rmSource == &srcList[curSfx->masterLoopSrc])
+		{
+			int firstInactive = -1;
+
+			// Only if rmSource was the master and if there are still playing loops for
+			// this sound will we need to find a new master.
+	
+			if(iskilled || curSfx->loopActiveCnt)
+			{
+				for(index = 0; index < srcCount; index++)
+				{
+					curSource = &srcList[index];
+	
+					if(curSource->sfx == rmSource->sfx && curSource != rmSource &&
+					   curSource->isActive && curSource->isLooping && curSource->priority == SRCPRI_AMBIENT)
+					{
+						if(curSource->isPlaying)
+						{
+							curSfx->masterLoopSrc = index;
+							break;
+						}
+						else if(firstInactive < 0)
+							firstInactive = index;
+					}
+				}
+			}
+		
+			if(!curSfx->loopActiveCnt)
+			{
+				if(firstInactive < 0)
+				{
+					if(iskilled)
+					{
+						curSfx->masterLoopSrc = -1;
+						return;
+					}
+					else
+						curSource = rmSource;
+				}
+				else
+					curSource = &srcList[firstInactive];
+
+				if(rmSource->isPlaying)
+				{
+					// this was the last not stopped source, save last sample position + time
+					S_AL_SaveLoopPos(curSource, rmSource->alSource);
+				}
+				else
+				{
+					// second case: all loops using this sound have stopped due to listener being of of range,
+					// and now the inactive master gets deleted. Just move over the soundpos settings to the
+					// new master.
+					curSource->lastTimePos = rmSource->lastTimePos;
+					curSource->lastSampleTime = rmSource->lastSampleTime;
+				}
+			}
+		}
+	}
+	else
+		curSfx->masterLoopSrc = -1;
+}
+
+/*
+=================
+S_AL_SrcKill
+=================
+*/
+static void S_AL_SrcKill(srcHandle_t src)
+{
+	src_t *curSource = &srcList[src];
+	
+	// I'm not touching it. Unlock it first.
+	if(curSource->isLocked)
+		return;
+
+	// Remove the entity association and loop master status
+	if(curSource->isLooping)
+	{
+		curSource->isLooping = false;
+
+		if(curSource->entity != -1)
+		{
+			sentity_t *curEnt = &entityList[curSource->entity];
+			
+			curEnt->srcAllocated = false;
+			curEnt->srcIndex = -1;
+			curEnt->loopAddedThisFrame = false;
+			curEnt->startLoopingSound = false;
+		}
+		
+		S_AL_NewLoopMaster(curSource, true);
+	}
+
+	// Stop it if it's playing
+	if(curSource->isPlaying)
+	{
+		qalSourceStop(curSource->alSource);
+		curSource->isPlaying = false;
+	}
+
+	// Detach any buffers
+	qalSourcei(curSource->alSource, AL_BUFFER, 0);
+
+	curSource->sfx = 0;
+	curSource->lastUsedTime = 0;
+	curSource->priority = SRCPRI_AMBIENT;
+	curSource->entity = -1;
+	curSource->channel = -1;
+	if(curSource->isActive)
+	{
+		curSource->isActive = false;
+		srcActiveCnt--;
+	}
+	curSource->isLocked = false;
+	curSource->isTracking = false;
+	curSource->local = false;
+}
+
+/*
+=================
+S_AL_SrcAlloc
+=================
+*/
+static
+srcHandle_t S_AL_SrcAlloc( alSrcPriority_t priority, int entnum, int channel )
+{
+	int i;
+	int empty = -1;
+	int weakest = -1;
+	int weakest_time = Sys_Milliseconds();
+	int weakest_pri = 999;
+	float weakest_gain = 1000.0;
+	bool weakest_isplaying = true;
+	int weakest_numloops = 0;
+	src_t *curSource;
+
+	for(i = 0; i < srcCount; i++)
+	{
+		curSource = &srcList[i];
+		
+		// If it's locked, we aren't even going to look at it
+		if(curSource->isLocked)
+			continue;
+
+		// Is it empty or not?
+		if(!curSource->isActive)
+		{
+			empty = i;
+			break;
+		}
+
+		if(curSource->isPlaying)
+		{
+			if(weakest_isplaying && curSource->priority < priority &&
+			   (curSource->priority < weakest_pri ||
+			   (!curSource->isLooping && (curSource->scaleGain < weakest_gain || curSource->lastUsedTime < weakest_time))))
+			{
+				// If it has lower priority, is fainter or older, flag it as weak
+				// the last two values are only compared if it's not a looping sound, because we want to prevent two
+				// loops (loops are added EVERY frame) fighting for a slot
+				weakest_pri = curSource->priority;
+				weakest_time = curSource->lastUsedTime;
+				weakest_gain = curSource->scaleGain;
+				weakest = i;
+			}
+		}
+		else
+		{
+			weakest_isplaying = false;
+			
+			if(weakest < 0 ||
+			   knownSfx[curSource->sfx].loopCnt > weakest_numloops ||
+			   curSource->priority < weakest_pri ||
+			   curSource->lastUsedTime < weakest_time)
+			{
+				// Sources currently not playing of course have lowest priority
+				// also try to always keep at least one loop master for every loop sound
+				weakest_pri = curSource->priority;
+				weakest_time = curSource->lastUsedTime;
+				weakest_numloops = knownSfx[curSource->sfx].loopCnt;
+				weakest = i;
+			}
+		}
+
+		// The channel system is not actually adhered to by baseq3, and not
+		// implemented in snd_dma.c, so while the following is strictly correct, it
+		// causes incorrect behaviour versus defacto baseq3
+#if 0
+		// Is it an exact match, and not on channel 0?
+		if((curSource->entity == entnum) && (curSource->channel == channel) && (channel != 0))
+		{
+			S_AL_SrcKill(i);
+			return i;
+		}
+#endif
+	}
+
+	if(empty == -1)
+		empty = weakest;
+	
+	if(empty >= 0)
+	{
+		S_AL_SrcKill(empty);
+		srcList[empty].isActive = true;
+		srcActiveCnt++;
+	}
+
+	return empty;
+}
+
+/*
+=================
+S_AL_SrcFind
+
+Finds an active source with matching entity and channel numbers
+Returns -1 if there isn't one
+=================
+*/
+#if 0
+static
+srcHandle_t S_AL_SrcFind(int entnum, int channel)
+{
+	int i;
+	for(i = 0; i < srcCount; i++)
+	{
+		if(!srcList[i].isActive)
+			continue;
+		if((srcList[i].entity == entnum) && (srcList[i].channel == channel))
+			return i;
+	}
+	return -1;
+}
+#endif
+
+/*
+=================
+S_AL_SrcLock
+
+Locked sources will not be automatically reallocated or managed
+=================
+*/
+static
+void S_AL_SrcLock(srcHandle_t src)
+{
+	srcList[src].isLocked = true;
+}
+
+/*
+=================
+S_AL_SrcUnlock
+
+Once unlocked, the source may be reallocated again
+=================
+*/
+static
+void S_AL_SrcUnlock(srcHandle_t src)
+{
+	srcList[src].isLocked = false;
+}
+
+/*
+=================
+S_AL_UpdateEntityPosition
+=================
+*/
+static
+void S_AL_UpdateEntityPosition( int entityNum, const vec3_t origin )
+{
+	vec3_t sanOrigin;
+
+	VectorCopy( origin, sanOrigin );
+	S_AL_SanitiseVector( sanOrigin );
+	if ( entityNum < 0 || entityNum >= MAX_GENTITIES )
+		Com_Error( ERR_DROP, "S_UpdateEntityPosition: bad entitynum %i", entityNum );
+	VectorCopy( sanOrigin, entityList[entityNum].origin );
+}
+
+/*
+=================
+S_AL_CheckInput
+Check whether input values from mods are out of range.
+Necessary for i.g. Western Quake3 mod which is buggy.
+=================
+*/
+static bool S_AL_CheckInput(int entityNum, sfxHandle_t sfx)
+{
+	if (entityNum < 0 || entityNum >= MAX_GENTITIES)
+		Com_Error(ERR_DROP, "ERROR: S_AL_CheckInput: bad entitynum %i", entityNum);
+
+	if (sfx < 0 || sfx >= numSfx)
+	{
+		Com_Printf(S_COLOR_RED "ERROR: S_AL_CheckInput: handle %i out of range\n", sfx);
+		return true;
+	}
+
+	return false;
+}
+
+/*
+=================
+S_AL_StartLocalSound
+
+Play a local (non-spatialized) sound effect
+=================
+*/
+static
+void S_AL_StartLocalSound(sfxHandle_t sfx, int channel)
+{
+	srcHandle_t src;
+	
+	if(S_AL_CheckInput(0, sfx))
+		return;
+
+	// Try to grab a source
+	src = S_AL_SrcAlloc(SRCPRI_LOCAL, -1, channel);
+	
+	if(src == -1)
+		return;
+
+	// Set up the effect
+	S_AL_SrcSetup(src, sfx, SRCPRI_LOCAL, -1, channel, true);
+
+	// Start it playing
+	srcList[src].isPlaying = true;
+	qalSourcePlay(srcList[src].alSource);
+}
+
+/*
+=================
+S_AL_StartSound
+
+Play a one-shot sound effect
+=================
+*/
+static void S_AL_StartSound( vec3_t origin, int entnum, int entchannel, sfxHandle_t sfx )
+{
+	vec3_t sorigin;
+	srcHandle_t src;
+	src_t *curSource;
+
+	if(origin)
+	{
+		if(S_AL_CheckInput(0, sfx))
+			return;
+		
+		VectorCopy(origin, sorigin);
+	}
+	else
+	{
+		if(S_AL_CheckInput(entnum, sfx))
+			return;
+
+		if(S_AL_HearingThroughEntity(entnum))
+		{
+			S_AL_StartLocalSound(sfx, entchannel);
+			return;
+		}
+		
+		VectorCopy(entityList[entnum].origin, sorigin);
+	}
+	
+	S_AL_SanitiseVector(sorigin);
+	
+	if((srcActiveCnt > 5 * srcCount / 3) &&
+		(DistanceSquared(sorigin, lastListenerOrigin) >=
+		(s_alMaxDistance->value + s_alGraceDistance->value) * (s_alMaxDistance->value + s_alGraceDistance->value)))
+	{
+		// We're getting tight on sources and source is not within hearing distance so don't add it
+		return;
+	}
+
+	// Try to grab a source
+	src = S_AL_SrcAlloc(SRCPRI_ONESHOT, entnum, entchannel);
+	if(src == -1)
+		return;
+
+	S_AL_SrcSetup(src, sfx, SRCPRI_ONESHOT, entnum, entchannel, false);
+	
+	curSource = &srcList[src];
+
+	if(!origin)
+		curSource->isTracking = true;
+		
+	qalSourcefv(curSource->alSource, AL_POSITION, sorigin );
+	S_AL_ScaleGain(curSource, sorigin);
+
+	// Start it playing
+	curSource->isPlaying = true;
+	qalSourcePlay(curSource->alSource);
+}
+
+/*
+=================
+S_AL_ClearLoopingSounds
+=================
+*/
+static void S_AL_ClearLoopingSounds( bool killall )
+{
+	int i;
+	for(i = 0; i < srcCount; i++)
+	{
+		if((srcList[i].isLooping) && (srcList[i].entity != -1))
+			entityList[srcList[i].entity].loopAddedThisFrame = false;
+	}
+}
+
+/*
+=================
+S_AL_SrcLoop
+=================
+*/
+static void S_AL_SrcLoop( alSrcPriority_t priority, sfxHandle_t sfx,
+		const vec3_t origin, const vec3_t velocity, int entityNum )
+{
+	int				src;
+	sentity_t	*sent = &entityList[ entityNum ];
+	src_t		*curSource;
+	vec3_t		sorigin, svelocity;
+
+	if(S_AL_CheckInput(entityNum, sfx))
+		return;
+
+	// Do we need to allocate a new source for this entity
+	if( !sent->srcAllocated )
+	{
+		// Try to get a channel
+		src = S_AL_SrcAlloc( priority, entityNum, -1 );
+		if( src == -1 )
+		{
+			Com_DPrintf( S_COLOR_YELLOW "WARNING: Failed to allocate source "
+					"for loop sfx %d on entity %d\n", sfx, entityNum );
+			return;
+		}
+
+		curSource = &srcList[src];
+
+		sent->startLoopingSound = true;
+
+		curSource->lastTimePos = -1.0;
+		curSource->lastSampleTime = Sys_Milliseconds();
+	}
+	else
+	{
+		src = sent->srcIndex;
+		curSource = &srcList[src];
+	}
+
+	sent->srcAllocated = true;
+	sent->srcIndex = src;
+
+	sent->loopPriority = priority;
+	sent->loopSfx = sfx;
+
+	// If this is not set then the looping sound is stopped.
+	sent->loopAddedThisFrame = true;
+
+	// UGH
+	// These lines should be called via S_AL_SrcSetup, but we
+	// can't call that yet as it buffers sfxes that may change
+	// with subsequent calls to S_AL_SrcLoop
+	curSource->entity = entityNum;
+	curSource->isLooping = true;
+
+	if( S_AL_HearingThroughEntity( entityNum ) )
+	{
+		curSource->local = true;
+
+		VectorClear(sorigin);
+
+		qalSourcefv(curSource->alSource, AL_POSITION, sorigin);
+		qalSourcefv(curSource->alSource, AL_VELOCITY, vec3_origin);
+	}
+	else
+	{
+		curSource->local = false;
+
+		if(origin)
+			VectorCopy(origin, sorigin);
+		else
+			VectorCopy(sent->origin, sorigin);
+
+		S_AL_SanitiseVector(sorigin);
+		
+		VectorCopy(sorigin, curSource->loopSpeakerPos);
+		
+		if(velocity)
+		{
+			VectorCopy(velocity, svelocity);
+			S_AL_SanitiseVector(svelocity);
+		}
+		else
+			VectorClear(svelocity);
+
+		qalSourcefv(curSource->alSource, AL_POSITION, (ALfloat *) sorigin);
+		qalSourcefv(curSource->alSource, AL_VELOCITY, (ALfloat *) svelocity);
+	}
+}
+
+/*
+=================
+S_AL_AddLoopingSound
+=================
+*/
+static void S_AL_AddLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
+{
+	S_AL_SrcLoop(SRCPRI_ENTITY, sfx, origin, velocity, entityNum);
+}
+
+/*
+=================
+S_AL_AddRealLoopingSound
+=================
+*/
+static void S_AL_AddRealLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
+{
+	S_AL_SrcLoop(SRCPRI_AMBIENT, sfx, origin, velocity, entityNum);
+}
+
+/*
+=================
+S_AL_StopLoopingSound
+=================
+*/
+static
+void S_AL_StopLoopingSound(int entityNum )
+{
+	if(entityList[entityNum].srcAllocated)
+		S_AL_SrcKill(entityList[entityNum].srcIndex);
+}
+
+/*
+=================
+S_AL_SrcUpdate
+
+Update state (move things around, manage sources, and so on)
+=================
+*/
+static
+void S_AL_SrcUpdate( void )
+{
+	int i;
+	int entityNum;
+	ALint state;
+	src_t *curSource;
+	
+	for(i = 0; i < srcCount; i++)
+	{
+		entityNum = srcList[i].entity;
+		curSource = &srcList[i];
+
+		if(curSource->isLocked)
+			continue;
+
+		if(!curSource->isActive)
+			continue;
+
+		// Update source parameters
+		if((s_alGain->modified) || (s_volume->modified))
+			curSource->curGain = s_alGain->value * s_volume->value;
+		if((s_alRolloff->modified) && (!curSource->local))
+			qalSourcef(curSource->alSource, AL_ROLLOFF_FACTOR, s_alRolloff->value);
+		if(s_alMinDistance->modified)
+			qalSourcef(curSource->alSource, AL_REFERENCE_DISTANCE, s_alMinDistance->value);
+
+		if(curSource->isLooping)
+		{
+			sentity_t *sent = &entityList[ entityNum ];
+
+			// If a looping effect hasn't been touched this frame, pause or kill it
+			if(sent->loopAddedThisFrame)
+			{
+				alSfx_t *curSfx;
+			
+				// The sound has changed without an intervening removal
+				if(curSource->isActive && !sent->startLoopingSound &&
+						curSource->sfx != sent->loopSfx)
+				{
+					S_AL_NewLoopMaster(curSource, true);
+
+					curSource->isPlaying = false;
+					qalSourceStop(curSource->alSource);
+					qalSourcei(curSource->alSource, AL_BUFFER, 0);
+					sent->startLoopingSound = true;
+				}
+
+				// The sound hasn't been started yet
+				if(sent->startLoopingSound)
+				{
+					S_AL_SrcSetup(i, sent->loopSfx, sent->loopPriority,
+							entityNum, -1, curSource->local);
+					curSource->isLooping = true;
+					
+					knownSfx[curSource->sfx].loopCnt++;
+					sent->startLoopingSound = false;
+				}
+				
+				curSfx = &knownSfx[curSource->sfx];
+
+				S_AL_ScaleGain(curSource, curSource->loopSpeakerPos);
+				if(!curSource->scaleGain)
+				{
+					if(curSource->isPlaying)
+					{
+						// Sound is mute, stop playback until we are in range again
+						S_AL_NewLoopMaster(curSource, false);
+						qalSourceStop(curSource->alSource);
+						curSource->isPlaying = false;
+					}
+					else if(!curSfx->loopActiveCnt && curSfx->masterLoopSrc < 0)
+						curSfx->masterLoopSrc = i;
+					
+					continue;
+				}
+
+				if(!curSource->isPlaying)
+				{
+					qalSourcei(curSource->alSource, AL_LOOPING, AL_TRUE);
+					curSource->isPlaying = true;
+					qalSourcePlay(curSource->alSource);
+
+					if(curSource->priority == SRCPRI_AMBIENT)
+					{
+						// If there are other ambient looping sources with the same sound,
+						// make sure the sound of these sources are in sync.
+
+						if(curSfx->loopActiveCnt)
+						{
+							int offset, error;
+						
+							// we already have a master loop playing, get buffer position.
+							S_AL_ClearError(false);
+							qalGetSourcei(srcList[curSfx->masterLoopSrc].alSource, AL_SAMPLE_OFFSET, &offset);
+							if((error = qalGetError()) != AL_NO_ERROR)
+							{
+								if(error != AL_INVALID_ENUM)
+								{
+									Com_Printf(S_COLOR_YELLOW "WARNING: Cannot get sample offset from source %d: "
+										   "%s\n", i, S_AL_ErrorMsg(error));
+								}
+							}
+							else
+								qalSourcei(curSource->alSource, AL_SAMPLE_OFFSET, offset);
+						}
+						else if(curSfx->loopCnt && curSfx->masterLoopSrc >= 0)
+						{
+							float secofs;
+						
+							src_t *master = &srcList[curSfx->masterLoopSrc];
+							// This loop sound used to be played, but all sources are stopped. Use last sample position/time
+							// to calculate offset so the player thinks the sources continued playing while they were inaudible.
+						
+							if(master->lastTimePos >= 0)
+							{
+								secofs = master->lastTimePos + (Sys_Milliseconds() - master->lastSampleTime) / 1000.0f;
+								secofs = fmodf(secofs, (float) curSfx->info.samples / curSfx->info.rate);
+						
+								qalSourcef(curSource->alSource, AL_SEC_OFFSET, secofs);
+							}
+
+							// I be the master now
+							curSfx->masterLoopSrc = i;
+						}
+						else
+							curSfx->masterLoopSrc = i;
+					}
+					else if(curSource->lastTimePos >= 0)
+					{
+						float secofs;
+						
+						// For unsynced loops (SRCPRI_ENTITY) just carry on playing as if the sound was never stopped
+						
+						secofs = curSource->lastTimePos + (Sys_Milliseconds() - curSource->lastSampleTime) / 1000.0f;
+						secofs = fmodf(secofs, (float) curSfx->info.samples / curSfx->info.rate);
+						qalSourcef(curSource->alSource, AL_SEC_OFFSET, secofs);
+					}
+						
+					curSfx->loopActiveCnt++;
+				}
+
+				// Update locality
+				if(curSource->local)
+				{
+					qalSourcei(curSource->alSource, AL_SOURCE_RELATIVE, AL_TRUE);
+					qalSourcef(curSource->alSource, AL_ROLLOFF_FACTOR, 0.0f);
+				}
+				else
+				{
+					qalSourcei(curSource->alSource, AL_SOURCE_RELATIVE, AL_FALSE);
+					qalSourcef(curSource->alSource, AL_ROLLOFF_FACTOR, s_alRolloff->value);
+				}
+				
+			}
+			else if(curSource->priority == SRCPRI_AMBIENT)
+			{
+				if(curSource->isPlaying)
+				{
+					S_AL_NewLoopMaster(curSource, false);
+					qalSourceStop(curSource->alSource);
+					curSource->isPlaying = false;
+				}
+			}
+			else
+				S_AL_SrcKill(i);
+
+			continue;
+		}
+
+		if(!curSource->isStream)
+		{
+        		// Check if it's done, and flag it
+	        	qalGetSourcei(curSource->alSource, AL_SOURCE_STATE, &state);
+	        	if(state == AL_STOPPED)
+        		{
+	        		curSource->isPlaying = false;
+		        	S_AL_SrcKill(i);
+		        	continue;
+        		}
+                }
+
+		// Query relativity of source, don't move if it's true
+		qalGetSourcei(curSource->alSource, AL_SOURCE_RELATIVE, &state);
+
+		// See if it needs to be moved
+		if(curSource->isTracking && !state)
+		{
+			qalSourcefv(curSource->alSource, AL_POSITION, entityList[entityNum].origin);
+ 			S_AL_ScaleGain(curSource, entityList[entityNum].origin);
+		}
+	}
+}
+
+/*
+=================
+S_AL_SrcShutup
+=================
+*/
+static
+void S_AL_SrcShutup( void )
+{
+	int i;
+	for(i = 0; i < srcCount; i++)
+		S_AL_SrcKill(i);
+}
+
+/*
+=================
+S_AL_SrcGet
+=================
+*/
+static
+ALuint S_AL_SrcGet(srcHandle_t src)
+{
+	return srcList[src].alSource;
+}
+
+
+//===========================================================================
+
+// Q3A cinematics use up to 12 buffers at once
+#define MAX_STREAM_BUFFERS 20
+
+static srcHandle_t streamSourceHandles[MAX_RAW_STREAMS];
+static bool streamPlaying[MAX_RAW_STREAMS];
+static ALuint streamSources[MAX_RAW_STREAMS];
+static ALuint streamBuffers[MAX_RAW_STREAMS][MAX_STREAM_BUFFERS];
+static int streamNumBuffers[MAX_RAW_STREAMS];
+static int streamBufIndex[MAX_RAW_STREAMS];
+
+/*
+=================
+S_AL_AllocateStreamChannel
+=================
+*/
+static void S_AL_AllocateStreamChannel(int stream, int entityNum)
+{
+        srcHandle_t cursrc;
+        ALuint alsrc;
+        
+	if ((stream < 0) || (stream >= MAX_RAW_STREAMS))
+		return;
+
+        if(entityNum >= 0)
+        {
+                // This is a stream that tracks an entity
+        	// Allocate a streamSource at normal priority
+        	cursrc = S_AL_SrcAlloc(SRCPRI_ENTITY, entityNum, 0);
+        	if(cursrc < 0)
+	        	return;
+
+        	S_AL_SrcSetup(cursrc, -1, SRCPRI_ENTITY, entityNum, 0, false);
+        	alsrc = S_AL_SrcGet(cursrc);
+        	srcList[cursrc].isTracking = true;
+        	srcList[cursrc].isStream = true;
+        }
+        else
+        {
+                // Unspatialized stream source
+
+        	// Allocate a streamSource at high priority
+        	cursrc = S_AL_SrcAlloc(SRCPRI_STREAM, -2, 0);
+        	if(cursrc < 0)
+	        	return;
+
+        	alsrc = S_AL_SrcGet(cursrc);
+
+        	// Lock the streamSource so nobody else can use it, and get the raw streamSource
+        	S_AL_SrcLock(cursrc);
+        
+        	// make sure that after unmuting the S_AL_Gain in S_Update() does not turn
+        	// volume up prematurely for this source
+        	srcList[cursrc].scaleGain = 0.0f;
+
+        	// Set some streamSource parameters
+        	qalSourcei (alsrc, AL_BUFFER,          0            );
+        	qalSourcei (alsrc, AL_LOOPING,         AL_FALSE     );
+        	qalSource3f(alsrc, AL_POSITION,        0.0, 0.0, 0.0);
+        	qalSource3f(alsrc, AL_VELOCITY,        0.0, 0.0, 0.0);
+        	qalSource3f(alsrc, AL_DIRECTION,       0.0, 0.0, 0.0);
+        	qalSourcef (alsrc, AL_ROLLOFF_FACTOR,  0.0          );
+        	qalSourcei (alsrc, AL_SOURCE_RELATIVE, AL_TRUE      );
+        }
+
+        streamSourceHandles[stream] = cursrc;
+       	streamSources[stream] = alsrc;
+
+	streamNumBuffers[stream] = 0;
+	streamBufIndex[stream] = 0;
+}
+
+/*
+=================
+S_AL_FreeStreamChannel
+=================
+*/
+static void S_AL_FreeStreamChannel( int stream )
+{
+	if ((stream < 0) || (stream >= MAX_RAW_STREAMS))
+		return;
+
+	// Detach any buffers
+	qalSourcei(streamSources[stream], AL_BUFFER, 0);
+
+	// Delete the buffers
+	if (streamNumBuffers[stream] > 0) {
+		qalDeleteBuffers(streamNumBuffers[stream], streamBuffers[stream]);
+		streamNumBuffers[stream] = 0;
+	}
+
+	// Release the output streamSource
+	S_AL_SrcUnlock(streamSourceHandles[stream]);
+	S_AL_SrcKill(streamSourceHandles[stream]);
+	streamSources[stream] = 0;
+	streamSourceHandles[stream] = -1;
+}
+
+/*
+=================
+S_AL_RawSamples
+=================
+*/
+static
+void S_AL_RawSamples(int stream, int samples, int rate, int width, int channels, const byte *data, float volume, int entityNum)
+{
+	int numBuffers;
+	ALuint buffer;
+	ALuint format;
+
+	if ((stream < 0) || (stream >= MAX_RAW_STREAMS))
+		return;
+
+	format = S_AL_Format( width, channels );
+
+	// Create the streamSource if necessary
+	if(streamSourceHandles[stream] == -1)
+	{
+		S_AL_AllocateStreamChannel(stream, entityNum);
+	
+		// Failed?
+		if(streamSourceHandles[stream] == -1)
+		{
+			Com_Printf( S_COLOR_RED "ERROR: Can't allocate streaming streamSource\n");
+			return;
+		}
+	}
+
+	qalGetSourcei(streamSources[stream], AL_BUFFERS_QUEUED, &numBuffers);
+
+	if (numBuffers == MAX_STREAM_BUFFERS)
+	{
+		Com_DPrintf(S_COLOR_RED"WARNING: Steam dropping raw samples, reached MAX_STREAM_BUFFERS\n");
+		return;
+	}
+
+	// Allocate a new AL buffer if needed
+	if (numBuffers == streamNumBuffers[stream])
+	{
+		ALuint oldBuffers[MAX_STREAM_BUFFERS];
+		int	i;
+
+		if (!S_AL_GenBuffers(1, &buffer, "stream"))
+			return;
+
+		::memcpy(oldBuffers, &streamBuffers[stream], sizeof (oldBuffers));
+
+		// Reorder buffer array in order of oldest to newest
+		for ( i = 0; i < streamNumBuffers[stream]; ++i )
+			streamBuffers[stream][i] = oldBuffers[(streamBufIndex[stream] + i) % streamNumBuffers[stream]];
+
+		// Add the new buffer to end
+		streamBuffers[stream][streamNumBuffers[stream]] = buffer;
+		streamBufIndex[stream] = streamNumBuffers[stream];
+		streamNumBuffers[stream]++;
+	}
+
+	// Select next buffer in loop
+	buffer = streamBuffers[stream][ streamBufIndex[stream] ];
+	streamBufIndex[stream] = (streamBufIndex[stream] + 1) % streamNumBuffers[stream];
+
+	// Fill buffer
+	qalBufferData(buffer, format, (ALvoid *)data, (samples * width * channels), rate);
+
+	// Shove the data onto the streamSource
+	qalSourceQueueBuffers(streamSources[stream], 1, &buffer);
+
+	if(entityNum < 0)
+	{
+        	// Volume
+        	S_AL_Gain (streamSources[stream], volume * s_volume->value * s_alGain->value);
+        }
+
+	// Start stream
+	if(!streamPlaying[stream])
+	{
+		qalSourcePlay( streamSources[stream] );
+		streamPlaying[stream] = true;
+	}
+}
+
+/*
+=================
+S_AL_StreamUpdate
+=================
+*/
+static
+void S_AL_StreamUpdate( int stream )
+{
+	int		numBuffers;
+	ALint	state;
+
+	if ((stream < 0) || (stream >= MAX_RAW_STREAMS))
+		return;
+
+	if(streamSourceHandles[stream] == -1)
+		return;
+
+	// Un-queue any buffers
+	qalGetSourcei( streamSources[stream], AL_BUFFERS_PROCESSED, &numBuffers );
+	while( numBuffers-- )
+	{
+		ALuint buffer;
+		qalSourceUnqueueBuffers(streamSources[stream], 1, &buffer);
+	}
+
+	// Start the streamSource playing if necessary
+	qalGetSourcei( streamSources[stream], AL_BUFFERS_QUEUED, &numBuffers );
+
+	qalGetSourcei(streamSources[stream], AL_SOURCE_STATE, &state);
+	if(state == AL_STOPPED)
+	{
+		streamPlaying[stream] = false;
+
+		// If there are no buffers queued up, release the streamSource
+		if( !numBuffers )
+			S_AL_FreeStreamChannel( stream );
+	}
+
+	if( !streamPlaying[stream] && numBuffers )
+	{
+		qalSourcePlay( streamSources[stream] );
+		streamPlaying[stream] = true;
+	}
+}
+
+/*
+=================
+S_AL_StreamDie
+=================
+*/
+static
+void S_AL_StreamDie( int stream )
+{
+	if ((stream < 0) || (stream >= MAX_RAW_STREAMS))
+		return;
+
+	if(streamSourceHandles[stream] == -1)
+		return;
+
+	streamPlaying[stream] = false;
+	qalSourceStop(streamSources[stream]);
+
+	S_AL_FreeStreamChannel(stream);
+}
+
+
+//===========================================================================
+
+
+#define NUM_MUSIC_BUFFERS	4
+#define	MUSIC_BUFFER_SIZE 4096
+
+static bool musicPlaying = false;
+static srcHandle_t musicSourceHandle = -1;
+static ALuint musicSource;
+static ALuint musicBuffers[NUM_MUSIC_BUFFERS];
+
+static snd_stream_t *mus_stream;
+static snd_stream_t *intro_stream;
+static char s_backgroundLoop[MAX_QPATH];
+
+static byte decode_buffer[MUSIC_BUFFER_SIZE];
+
+/*
+=================
+S_AL_MusicSourceGet
+=================
+*/
+static void S_AL_MusicSourceGet( void )
+{
+	// Allocate a musicSource at high priority
+	musicSourceHandle = S_AL_SrcAlloc(SRCPRI_STREAM, -2, 0);
+	if(musicSourceHandle == -1)
+		return;
+
+	// Lock the musicSource so nobody else can use it, and get the raw musicSource
+	S_AL_SrcLock(musicSourceHandle);
+	musicSource = S_AL_SrcGet(musicSourceHandle);
+
+	// make sure that after unmuting the S_AL_Gain in S_Update() does not turn
+	// volume up prematurely for this source
+	srcList[musicSourceHandle].scaleGain = 0.0f;
+
+	// Set some musicSource parameters
+	qalSource3f(musicSource, AL_POSITION,        0.0, 0.0, 0.0);
+	qalSource3f(musicSource, AL_VELOCITY,        0.0, 0.0, 0.0);
+	qalSource3f(musicSource, AL_DIRECTION,       0.0, 0.0, 0.0);
+	qalSourcef (musicSource, AL_ROLLOFF_FACTOR,  0.0          );
+	qalSourcei (musicSource, AL_SOURCE_RELATIVE, AL_TRUE      );
+}
+
+/*
+=================
+S_AL_MusicSourceFree
+=================
+*/
+static void S_AL_MusicSourceFree( void )
+{
+	// Release the output musicSource
+	S_AL_SrcUnlock(musicSourceHandle);
+	S_AL_SrcKill(musicSourceHandle);
+	musicSource = 0;
+	musicSourceHandle = -1;
+}
+
+/*
+=================
+S_AL_CloseMusicFiles
+=================
+*/
+static void S_AL_CloseMusicFiles(void)
+{
+	if(intro_stream)
+	{
+		S_CodecCloseStream(intro_stream);
+		intro_stream = NULL;
+	}
+	
+	if(mus_stream)
+	{
+		S_CodecCloseStream(mus_stream);
+		mus_stream = NULL;
+	}
+}
+
+/*
+=================
+S_AL_StopBackgroundTrack
+=================
+*/
+static
+void S_AL_StopBackgroundTrack( void )
+{
+	if(!musicPlaying)
+		return;
+
+	// Stop playing
+	qalSourceStop(musicSource);
+
+	// Detach any buffers
+	qalSourcei(musicSource, AL_BUFFER, 0);
+
+	// Delete the buffers
+	qalDeleteBuffers(NUM_MUSIC_BUFFERS, musicBuffers);
+
+	// Free the musicSource
+	S_AL_MusicSourceFree();
+
+	// Unload the stream
+	S_AL_CloseMusicFiles();
+
+	musicPlaying = false;
+}
+
+/*
+=================
+S_AL_MusicProcess
+=================
+*/
+static
+void S_AL_MusicProcess(ALuint b)
+{
+	ALenum error;
+	int l;
+	ALuint format;
+	snd_stream_t *curstream;
+
+	S_AL_ClearError( false );
+
+	if(intro_stream)
+		curstream = intro_stream;
+	else
+		curstream = mus_stream;
+
+	if(!curstream)
+		return;
+
+	l = S_CodecReadStream(curstream, MUSIC_BUFFER_SIZE, decode_buffer);
+
+	// Run out data to read, start at the beginning again
+	if(l == 0)
+	{
+		S_CodecCloseStream(curstream);
+
+		// the intro stream just finished playing so we don't need to reopen
+		// the music stream.
+		if(intro_stream)
+			intro_stream = NULL;
+		else
+			mus_stream = S_CodecOpenStream(s_backgroundLoop);
+		
+		curstream = mus_stream;
+
+		if(!curstream)
+		{
+			S_AL_StopBackgroundTrack();
+			return;
+		}
+
+		l = S_CodecReadStream(curstream, MUSIC_BUFFER_SIZE, decode_buffer);
+	}
+
+	format = S_AL_Format(curstream->info.width, curstream->info.channels);
+
+	if( l == 0 )
+	{
+		// We have no data to buffer, so buffer silence
+		byte dummyData[ 2 ] = { 0 };
+
+		qalBufferData( b, AL_FORMAT_MONO16, (void *)dummyData, 2, 22050 );
+	}
+	else
+		qalBufferData(b, format, decode_buffer, l, curstream->info.rate);
+
+	if( ( error = qalGetError( ) ) != AL_NO_ERROR )
+	{
+		S_AL_StopBackgroundTrack( );
+		Com_Printf( S_COLOR_RED "ERROR: while buffering data for music stream - %s\n",
+				S_AL_ErrorMsg( error ) );
+		return;
+	}
+}
+
+/*
+=================
+S_AL_StartBackgroundTrack
+=================
+*/
+static
+void S_AL_StartBackgroundTrack( const char *intro, const char *loop )
+{
+	int i;
+	bool issame;
+
+	// Stop any existing music that might be playing
+	S_AL_StopBackgroundTrack();
+
+	if((!intro || !*intro) && (!loop || !*loop))
+		return;
+
+	// Allocate a musicSource
+	S_AL_MusicSourceGet();
+	if(musicSourceHandle == -1)
+		return;
+
+	if (!loop || !*loop)
+	{
+		loop = intro;
+		issame = true;
+	}
+	else if(intro && *intro && !strcmp(intro, loop))
+		issame = true;
+	else
+		issame = false;
+
+	// Copy the loop over
+	Q_strncpyz( s_backgroundLoop, loop, sizeof( s_backgroundLoop ) );
+
+	if(!issame)
+	{
+		// Open the intro and don't mind whether it succeeds.
+		// The important part is the loop.
+		intro_stream = S_CodecOpenStream(intro);
+	}
+	else
+		intro_stream = NULL;
+
+	mus_stream = S_CodecOpenStream(s_backgroundLoop);
+	if(!mus_stream)
+	{
+		S_AL_CloseMusicFiles();
+		S_AL_MusicSourceFree();
+		return;
+	}
+
+	// Generate the musicBuffers
+	if (!S_AL_GenBuffers(NUM_MUSIC_BUFFERS, musicBuffers, "music"))
+		return;
+	
+	// Queue the musicBuffers up
+	for(i = 0; i < NUM_MUSIC_BUFFERS; i++)
+	{
+		S_AL_MusicProcess(musicBuffers[i]);
+	}
+
+	qalSourceQueueBuffers(musicSource, NUM_MUSIC_BUFFERS, musicBuffers);
+
+	// Set the initial gain property
+	S_AL_Gain(musicSource, s_alGain->value * s_musicVolume->value);
+	
+	// Start playing
+	qalSourcePlay(musicSource);
+
+	musicPlaying = true;
+}
+
+/*
+=================
+S_AL_MusicUpdate
+=================
+*/
+static
+void S_AL_MusicUpdate( void )
+{
+	int		numBuffers;
+	ALint	state;
+
+	if(!musicPlaying)
+		return;
+
+	qalGetSourcei( musicSource, AL_BUFFERS_PROCESSED, &numBuffers );
+	while( numBuffers-- )
+	{
+		ALuint b;
+		qalSourceUnqueueBuffers(musicSource, 1, &b);
+		S_AL_MusicProcess(b);
+		qalSourceQueueBuffers(musicSource, 1, &b);
+	}
+
+	// Hitches can cause OpenAL to be starved of buffers when streaming.
+	// If this happens, it will stop playback. This restarts the source if
+	// it is no longer playing, and if there are buffers available
+	qalGetSourcei( musicSource, AL_SOURCE_STATE, &state );
+	qalGetSourcei( musicSource, AL_BUFFERS_QUEUED, &numBuffers );
+	if( state == AL_STOPPED && numBuffers )
+	{
+		Com_DPrintf( S_COLOR_YELLOW "Restarted OpenAL music\n" );
+		qalSourcePlay(musicSource);
+	}
+
+	// Set the gain property
+	S_AL_Gain(musicSource, s_alGain->value * s_musicVolume->value);
+}
+
+
+//===========================================================================
+
+
+// Local state variables
+static ALCdevice *alDevice;
+static ALCcontext *alContext;
+
+#ifdef USE_VOIP
+static ALCdevice *alCaptureDevice;
+static cvar_t *s_alCapture;
+#endif
+
+#ifdef _WIN32
+#define ALDRIVER_DEFAULT "OpenAL32.dll"
+#elif defined(__APPLE__)
+#define ALDRIVER_DEFAULT "/System/Library/Frameworks/OpenAL.framework/OpenAL"
+#elif defined(__OpenBSD__)
+#define ALDRIVER_DEFAULT "libopenal.so"
+#else
+#define ALDRIVER_DEFAULT "libopenal.so.1"
+#endif
+
+/*
+=================
+S_AL_StopAllSounds
+=================
+*/
+static
+void S_AL_StopAllSounds( void )
+{
+	int i;
+	S_AL_SrcShutup();
+	S_AL_StopBackgroundTrack();
+	for (i = 0; i < MAX_RAW_STREAMS; i++)
+		S_AL_StreamDie(i);
+}
+
+/*
+=================
+S_AL_Respatialize
+=================
+*/
+static
+void S_AL_Respatialize( int entityNum, const vec3_t origin, vec3_t axis[3], int inwater )
+{
+	float		orientation[6];
+	vec3_t	sorigin;
+
+	VectorCopy( origin, sorigin );
+	S_AL_SanitiseVector( sorigin );
+
+	S_AL_SanitiseVector( axis[ 0 ] );
+	S_AL_SanitiseVector( axis[ 1 ] );
+	S_AL_SanitiseVector( axis[ 2 ] );
+
+	orientation[0] = axis[0][0]; orientation[1] = axis[0][1]; orientation[2] = axis[0][2];
+	orientation[3] = axis[2][0]; orientation[4] = axis[2][1]; orientation[5] = axis[2][2];
+
+	lastListenerNumber = entityNum;
+	VectorCopy( sorigin, lastListenerOrigin );
+
+	// Set OpenAL listener paramaters
+	qalListenerfv(AL_POSITION, (ALfloat *)sorigin);
+	qalListenerfv(AL_VELOCITY, vec3_origin);
+	qalListenerfv(AL_ORIENTATION, orientation);
+}
+
+/*
+=================
+S_AL_Update
+=================
+*/
+static
+void S_AL_Update( void )
+{
+	int i;
+
+	if(s_muted->modified)
+	{
+		// muted state changed. Let S_AL_Gain turn up all sources again.
+		for(i = 0; i < srcCount; i++)
+		{
+			if(srcList[i].isActive)
+				S_AL_Gain(srcList[i].alSource, srcList[i].scaleGain);
+		}
+		
+		s_muted->modified = false;
+	}
+
+	// Update SFX channels
+	S_AL_SrcUpdate();
+
+	// Update streams
+	for (i = 0; i < MAX_RAW_STREAMS; i++)
+		S_AL_StreamUpdate(i);
+	S_AL_MusicUpdate();
+
+	// Doppler
+	if(s_doppler->modified)
+	{
+		s_alDopplerFactor->modified = true;
+		s_doppler->modified = false;
+	}
+
+	// Doppler parameters
+	if(s_alDopplerFactor->modified)
+	{
+		if(s_doppler->integer)
+			qalDopplerFactor(s_alDopplerFactor->value);
+		else
+			qalDopplerFactor(0.0f);
+		s_alDopplerFactor->modified = false;
+	}
+	if(s_alDopplerSpeed->modified)
+	{
+		qalSpeedOfSound(s_alDopplerSpeed->value);
+		s_alDopplerSpeed->modified = false;
+	}
+
+	// Clear the modified flags on the other cvars
+	s_alGain->modified = false;
+	s_volume->modified = false;
+	s_musicVolume->modified = false;
+	s_alMinDistance->modified = false;
+	s_alRolloff->modified = false;
+}
+
+/*
+=================
+S_AL_DisableSounds
+=================
+*/
+static
+void S_AL_DisableSounds( void )
+{
+	S_AL_StopAllSounds();
+}
+
+/*
+=================
+S_AL_BeginRegistration
+=================
+*/
+static
+void S_AL_BeginRegistration( void )
+{
+	if(!numSfx)
+		S_AL_BufferInit();
+}
+
+/*
+=================
+S_AL_ClearSoundBuffer
+=================
+*/
+static
+void S_AL_ClearSoundBuffer( void )
+{
+}
+
+/*
+=================
+S_AL_SoundList
+=================
+*/
+static
+void S_AL_SoundList( void )
+{
+}
+
+#ifdef USE_VOIP
+static
+void S_AL_StartCapture( void )
+{
+	if (alCaptureDevice != NULL)
+		qalcCaptureStart(alCaptureDevice);
+}
+
+static
+int S_AL_AvailableCaptureSamples( void )
+{
+	int retval = 0;
+	if (alCaptureDevice != NULL)
+	{
+		ALint samples = 0;
+		qalcGetIntegerv(alCaptureDevice, ALC_CAPTURE_SAMPLES, sizeof (samples), &samples);
+		retval = (int) samples;
+	}
+	return retval;
+}
+
+static
+void S_AL_Capture( int samples, byte *data )
+{
+	if (alCaptureDevice != NULL)
+		qalcCaptureSamples(alCaptureDevice, data, samples);
+}
+
+void S_AL_StopCapture( void )
+{
+	if (alCaptureDevice != NULL)
+		qalcCaptureStop(alCaptureDevice);
+}
+
+void S_AL_MasterGain( float gain )
+{
+	qalListenerf(AL_GAIN, gain);
+}
+#endif
+
+
+/*
+=================
+S_AL_SoundInfo
+=================
+*/
+static void S_AL_SoundInfo(void)
+{
+	Com_Printf( "OpenAL info:\n" );
+	Com_Printf( "  Vendor:         %s\n", qalGetString( AL_VENDOR ) );
+	Com_Printf( "  Version:        %s\n", qalGetString( AL_VERSION ) );
+	Com_Printf( "  Renderer:       %s\n", qalGetString( AL_RENDERER ) );
+	Com_Printf( "  AL Extensions:  %s\n", qalGetString( AL_EXTENSIONS ) );
+	Com_Printf( "  ALC Extensions: %s\n", qalcGetString( alDevice, ALC_EXTENSIONS ) );
+
+	if(enumeration_all_ext)
+		Com_Printf("  Device:         %s\n", qalcGetString(alDevice, ALC_ALL_DEVICES_SPECIFIER));
+	else if(enumeration_ext)
+		Com_Printf("  Device:         %s\n", qalcGetString(alDevice, ALC_DEVICE_SPECIFIER));
+
+	if(enumeration_all_ext || enumeration_ext)
+		Com_Printf("  Available Devices:\n%s", s_alAvailableDevices->string);
+
+#ifdef USE_VOIP
+	if(capture_ext)
+	{
+		Com_Printf("  Input Device:   %s\n", qalcGetString(alCaptureDevice, ALC_CAPTURE_DEVICE_SPECIFIER));
+		Com_Printf("  Available Input Devices:\n%s", s_alAvailableInputDevices->string);
+	}
+#endif
+}
+
+
+
+/*
+=================
+S_AL_Shutdown
+=================
+*/
+static
+void S_AL_Shutdown( void )
+{
+	// Shut down everything
+	int i;
+	for (i = 0; i < MAX_RAW_STREAMS; i++)
+		S_AL_StreamDie(i);
+	S_AL_StopBackgroundTrack( );
+	S_AL_SrcShutdown( );
+	S_AL_BufferShutdown( );
+
+	qalcDestroyContext(alContext);
+	qalcCloseDevice(alDevice);
+
+#ifdef USE_VOIP
+	if (alCaptureDevice != NULL) {
+		qalcCaptureStop(alCaptureDevice);
+		qalcCaptureCloseDevice(alCaptureDevice);
+		alCaptureDevice = NULL;
+		Com_Printf( "OpenAL capture device closed.\n" );
+	}
+#endif
+
+	for (i = 0; i < MAX_RAW_STREAMS; i++) {
+		streamSourceHandles[i] = -1;
+		streamPlaying[i] = false;
+		streamSources[i] = 0;
+	}
+
+	QAL_Shutdown();
+}
+
+#endif
+
+/*
+=================
+S_AL_Init
+=================
+*/
+bool S_AL_Init( soundInterface_t *si )
+{
+#ifdef USE_OPENAL
+	const char* device = NULL;
+	const char* inputdevice = NULL;
+	int i;
+
+	if( !si ) {
+		return false;
+	}
+
+	for (i = 0; i < MAX_RAW_STREAMS; i++) {
+		streamSourceHandles[i] = -1;
+		streamPlaying[i] = false;
+		streamSources[i] = 0;
+		streamNumBuffers[i] = 0;
+		streamBufIndex[i] = 0;
+	}
+
+	// New console variables
+	s_alPrecache = Cvar_Get( "s_alPrecache", "1", CVAR_ARCHIVE );
+	s_alGain = Cvar_Get( "s_alGain", "1.0", CVAR_ARCHIVE );
+	s_alSources = Cvar_Get( "s_alSources", "96", CVAR_ARCHIVE );
+	s_alDopplerFactor = Cvar_Get( "s_alDopplerFactor", "1.0", CVAR_ARCHIVE );
+	s_alDopplerSpeed = Cvar_Get( "s_alDopplerSpeed", "9000", CVAR_ARCHIVE );
+	s_alMinDistance = Cvar_Get( "s_alMinDistance", "120", CVAR_CHEAT );
+	s_alMaxDistance = Cvar_Get("s_alMaxDistance", "1024", CVAR_CHEAT);
+	s_alRolloff = Cvar_Get( "s_alRolloff", "2", CVAR_CHEAT);
+	s_alGraceDistance = Cvar_Get("s_alGraceDistance", "512", CVAR_CHEAT);
+
+
+	s_alInputDevice = Cvar_Get( "s_alInputDevice", "", CVAR_ARCHIVE | CVAR_LATCH );
+	s_alDevice = Cvar_Get("s_alDevice", "", CVAR_ARCHIVE | CVAR_LATCH);
+	s_alDriver = Cvar_Get( "s_alDriver", ALDRIVER_DEFAULT, CVAR_ARCHIVE | CVAR_LATCH | CVAR_PROTECTED);
+
+	// Load QAL
+	if( !QAL_Init( s_alDriver->string ) )
+	{
+		Com_Printf( "Failed to load library: \"%s\".\n", s_alDriver->string );
+		if( !Q_stricmp( s_alDriver->string, ALDRIVER_DEFAULT ) || !QAL_Init( ALDRIVER_DEFAULT ) ) {
+			return false;
+		}
+	}
+
+	device = s_alDevice->string;
+	if(device && !*device)
+		device = NULL;
+
+	inputdevice = s_alInputDevice->string;
+	if(inputdevice && !*inputdevice)
+		inputdevice = NULL;
+
+
+	// Device enumeration support
+	enumeration_all_ext = qalcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT");
+	enumeration_ext = qalcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT");
+
+	if(enumeration_ext || enumeration_all_ext)
+	{
+		char devicenames[16384] = "";
+		const char *devicelist;
+#ifdef _WIN32
+		const char *defaultdevice;
+#endif
+		int curlen;
+
+		// get all available devices + the default device name.
+		if(enumeration_all_ext)
+		{
+			devicelist = qalcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
+#ifdef _WIN32
+			defaultdevice = qalcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
+#endif
+		}
+		else
+		{
+			// We don't have ALC_ENUMERATE_ALL_EXT but normal enumeration.
+			devicelist = qalcGetString(NULL, ALC_DEVICE_SPECIFIER);
+#ifdef _WIN32
+			defaultdevice = qalcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
+#endif
+			enumeration_ext = true;
+		}
+
+#ifdef _WIN32
+		// check whether the default device is generic hardware. If it is, change to
+		// Generic Software as that one works more reliably with various sound systems.
+		// If it's not, use OpenAL's default selection as we don't want to ignore
+		// native hardware acceleration.
+		if(!device && defaultdevice && !strcmp(defaultdevice, "Generic Hardware"))
+			device = "Generic Software";
+#endif
+
+		// dump a list of available devices to a cvar for the user to see.
+
+		if(devicelist)
+		{
+			while((curlen = strlen(devicelist)))
+			{
+				Q_strcat(devicenames, sizeof(devicenames), devicelist);
+				Q_strcat(devicenames, sizeof(devicenames), "\n");
+
+				devicelist += curlen + 1;
+			}
+		}
+
+		s_alAvailableDevices = Cvar_Get("s_alAvailableDevices", devicenames, CVAR_ROM | CVAR_NORESTART);
+	}
+
+	alDevice = qalcOpenDevice(device);
+	if( !alDevice && device )
+	{
+		Com_Printf( "Failed to open OpenAL device '%s', trying default.\n", device );
+		alDevice = qalcOpenDevice(NULL);
+	}
+
+	if( !alDevice )
+	{
+		QAL_Shutdown( );
+		Com_Printf( "Failed to open OpenAL device.\n" );
+		return false;
+	}
+
+	// Create OpenAL context
+	alContext = qalcCreateContext( alDevice, NULL );
+	if( !alContext )
+	{
+		QAL_Shutdown( );
+		qalcCloseDevice( alDevice );
+		Com_Printf( "Failed to create OpenAL context.\n" );
+		return false;
+	}
+	qalcMakeContextCurrent( alContext );
+
+	// Initialize sources, buffers, music
+	S_AL_BufferInit( );
+	S_AL_SrcInit( );
+
+	// Set up OpenAL parameters (doppler, etc)
+	qalDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
+	qalDopplerFactor( s_alDopplerFactor->value );
+	qalSpeedOfSound( s_alDopplerSpeed->value );
+
+#ifdef USE_VOIP
+	// !!! FIXME: some of these alcCaptureOpenDevice() values should be cvars.
+	// !!! FIXME: add support for capture device enumeration.
+	// !!! FIXME: add some better error reporting.
+	s_alCapture = Cvar_Get( "s_alCapture", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	if (!s_alCapture->integer)
+	{
+		Com_Printf("OpenAL capture support disabled by user ('+set s_alCapture 1' to enable)\n");
+	}
+#if USE_MUMBLE
+	else if (cl_useMumble->integer)
+	{
+		Com_Printf("OpenAL capture support disabled for Mumble support\n");
+	}
+#endif
+	else
+	{
+#ifdef __APPLE__
+		// !!! FIXME: Apple has a 1.1-compliant OpenAL, which includes
+		// !!! FIXME:  capture support, but they don't list it in the
+		// !!! FIXME:  extension string. We need to check the version string,
+		// !!! FIXME:  then the extension string, but that's too much trouble,
+		// !!! FIXME:  so we'll just check the function pointer for now.
+		if (qalcCaptureOpenDevice == NULL)
+#else
+		if (!qalcIsExtensionPresent(NULL, "ALC_EXT_capture"))
+#endif
+		{
+			Com_Printf("No ALC_EXT_capture support, can't record audio.\n");
+		}
+		else
+		{
+			char inputdevicenames[16384] = "";
+			const char *inputdevicelist;
+			const char *defaultinputdevice;
+			int curlen;
+
+			capture_ext = true;
+
+			// get all available input devices + the default input device name.
+			inputdevicelist = qalcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
+			defaultinputdevice = qalcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
+
+			// dump a list of available devices to a cvar for the user to see.
+			if (inputdevicelist)
+			{
+				while((curlen = strlen(inputdevicelist)))
+				{
+					Q_strcat(inputdevicenames, sizeof(inputdevicenames), inputdevicelist);
+					Q_strcat(inputdevicenames, sizeof(inputdevicenames), "\n");
+					inputdevicelist += curlen + 1;
+				}
+			}
+
+			s_alAvailableInputDevices = Cvar_Get("s_alAvailableInputDevices", inputdevicenames, CVAR_ROM | CVAR_NORESTART);
+
+			Com_Printf("OpenAL default capture device is '%s'\n", defaultinputdevice ? defaultinputdevice : "none");
+			alCaptureDevice = qalcCaptureOpenDevice(inputdevice, 48000, AL_FORMAT_MONO16, VOIP_MAX_PACKET_SAMPLES*4);
+			if( !alCaptureDevice && inputdevice )
+			{
+				Com_Printf( "Failed to open OpenAL Input device '%s', trying default.\n", inputdevice );
+				alCaptureDevice = qalcCaptureOpenDevice(NULL, 48000, AL_FORMAT_MONO16, VOIP_MAX_PACKET_SAMPLES*4);
+			}
+			Com_Printf( "OpenAL capture device %s.\n",
+				    (alCaptureDevice == NULL) ? "failed to open" : "opened");
+		}
+	}
+#endif
+
+	si->Shutdown = S_AL_Shutdown;
+	si->StartSound = S_AL_StartSound;
+	si->StartLocalSound = S_AL_StartLocalSound;
+	si->StartBackgroundTrack = S_AL_StartBackgroundTrack;
+	si->StopBackgroundTrack = S_AL_StopBackgroundTrack;
+	si->RawSamples = S_AL_RawSamples;
+	si->StopAllSounds = S_AL_StopAllSounds;
+	si->ClearLoopingSounds = S_AL_ClearLoopingSounds;
+	si->AddLoopingSound = S_AL_AddLoopingSound;
+	si->AddRealLoopingSound = S_AL_AddRealLoopingSound;
+	si->StopLoopingSound = S_AL_StopLoopingSound;
+	si->Respatialize = S_AL_Respatialize;
+	si->UpdateEntityPosition = S_AL_UpdateEntityPosition;
+	si->Update = S_AL_Update;
+	si->DisableSounds = S_AL_DisableSounds;
+	si->BeginRegistration = S_AL_BeginRegistration;
+	si->RegisterSound = S_AL_RegisterSound;
+	si->SoundDuration = S_AL_SoundDuration;
+	si->ClearSoundBuffer = S_AL_ClearSoundBuffer;
+	si->SoundInfo = S_AL_SoundInfo;
+	si->SoundList = S_AL_SoundList;
+
+#ifdef USE_VOIP
+	si->StartCapture = S_AL_StartCapture;
+	si->AvailableCaptureSamples = S_AL_AvailableCaptureSamples;
+	si->Capture = S_AL_Capture;
+	si->StopCapture = S_AL_StopCapture;
+	si->MasterGain = S_AL_MasterGain;
+#endif
+
+	return true;
+#else
+	return false;
+#endif
+}
diff --git a/src/client/snd_public.h b/src/client/snd_public.h
new file mode 100644
index 0000000..b8e97b9
--- /dev/null
+++ b/src/client/snd_public.h
@@ -0,0 +1,88 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#ifndef _SND_PUBLIC_H_
+#define _SND_PUBLIC_H_
+
+void S_Init( void );
+void S_Shutdown( void );
+
+// if origin is NULL, the sound will be dynamically sourced from the entity
+void S_StartSound( vec3_t origin, int entnum, int entchannel, sfxHandle_t sfx );
+void S_StartLocalSound( sfxHandle_t sfx, int channelNum );
+
+void S_StartBackgroundTrack( const char *intro, const char *loop );
+void S_StopBackgroundTrack( void );
+
+// cinematics and voice-over-network will send raw samples
+// 1.0 volume will be direct output of source samples
+void S_RawSamples(int stream, int samples, int rate, int width, int channels,
+				   const byte *data, float volume, int entityNum);
+
+// stop all sounds and the background track
+void S_StopAllSounds( void );
+
+// all continuous looping sounds must be added before calling S_Update
+void S_ClearLoopingSounds( bool killall );
+void S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx );
+void S_AddRealLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx );
+void S_StopLoopingSound(int entityNum );
+
+// recompute the relative volumes for all running sounds
+// relative to the given entityNum / orientation
+void S_Respatialize( int entityNum, const vec3_t origin, vec3_t axis[3], int inwater );
+
+// let the sound system know where an entity currently is
+void S_UpdateEntityPosition( int entityNum, const vec3_t origin );
+
+void S_Update( void );
+
+void S_DisableSounds( void );
+
+void S_BeginRegistration( void );
+
+// RegisterSound will allways return a valid sample, even if it
+// has to create a placeholder.  This prevents continuous filesystem
+// checks for missing files
+sfxHandle_t	S_RegisterSound( const char *sample, bool compressed );
+
+int S_SoundDuration( sfxHandle_t handle );
+
+void S_DisplayFreeMemory(void);
+
+void S_ClearSoundBuffer( void );
+
+void SNDDMA_Activate( void );
+
+void S_UpdateBackgroundTrack( void );
+
+
+#ifdef USE_VOIP
+void S_StartCapture( void );
+int S_AvailableCaptureSamples( void );
+void S_Capture( int samples, byte *data );
+void S_StopCapture( void );
+void S_MasterGain( float gain );
+#endif
+#endif
diff --git a/src/client/snd_wavelet.cpp b/src/client/snd_wavelet.cpp
new file mode 100644
index 0000000..e06e3ef
--- /dev/null
+++ b/src/client/snd_wavelet.cpp
@@ -0,0 +1,252 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#include "snd_local.h"
+
+#define C0 0.4829629131445341
+#define C1 0.8365163037378079
+#define C2 0.2241438680420134
+#define C3 -0.1294095225512604
+
+void daub4(float b[], unsigned long n, int isign)
+{
+	float wksp[4097] = { 0.0f };
+#define a(x) b[(x)-1]					// numerical recipies so a[1] = b[0]
+ 
+
+	unsigned long nh,nh1,i,j;
+
+	if (n < 4) return;
+
+	nh1=(nh=n >> 1)+1;
+	if (isign >= 0) {
+		for (i=1,j=1;j<=n-3;j+=2,i++) {
+			wksp[i]	   = C0*a(j)+C1*a(j+1)+C2*a(j+2)+C3*a(j+3);
+			wksp[i+nh] = C3*a(j)-C2*a(j+1)+C1*a(j+2)-C0*a(j+3);
+		}
+		wksp[i   ] = C0*a(n-1)+C1*a(n)+C2*a(1)+C3*a(2);
+		wksp[i+nh] = C3*a(n-1)-C2*a(n)+C1*a(1)-C0*a(2);
+	} else {
+		wksp[1] = C2*a(nh)+C1*a(n)+C0*a(1)+C3*a(nh1);
+		wksp[2] = C3*a(nh)-C0*a(n)+C1*a(1)-C2*a(nh1);
+		for (i=1,j=3;i<nh;i++) {
+			wksp[j++] = C2*a(i)+C1*a(i+nh)+C0*a(i+1)+C3*a(i+nh1);
+			wksp[j++] = C3*a(i)-C0*a(i+nh)+C1*a(i+1)-C2*a(i+nh1);
+		}
+	}
+	for (i=1;i<=n;i++) {
+		a(i) = wksp[i];
+	}
+}
+
+void wt1(float a[], unsigned long n, int isign)
+{
+	unsigned long nn;
+	int inverseStartLength = n/4;
+	if (n < inverseStartLength) return;
+	if (isign >= 0) {
+		for (nn=n;nn>=inverseStartLength;nn>>=1) daub4(a,nn,isign);
+	} else {
+		for (nn=inverseStartLength;nn<=n;nn<<=1) daub4(a,nn,isign);
+	}
+}
+
+/* The number of bits required by each value */
+static unsigned char numBits[] = {
+   0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+};
+
+byte MuLawEncode(short s) {
+	unsigned long adjusted;
+	byte sign, exponent, mantissa;
+
+	sign = (s<0)?0:0x80;
+
+	if (s<0) s=-s;
+	adjusted = (long)s << (16-sizeof(short)*8);
+	adjusted += 128L + 4L;
+	if (adjusted > 32767) adjusted = 32767;
+	exponent = numBits[(adjusted>>7)&0xff] - 1;
+	mantissa = (adjusted>>(exponent+3))&0xf;
+	return ~(sign | (exponent<<4) | mantissa);
+}
+
+short MuLawDecode(byte uLaw) {
+	signed long adjusted;
+	byte exponent, mantissa;
+
+	uLaw = ~uLaw;
+	exponent = (uLaw>>4) & 0x7;
+	mantissa = (uLaw&0xf) + 16;
+	adjusted = (mantissa << (exponent +3)) - 128 - 4;
+
+	return (uLaw & 0x80)? adjusted : -adjusted;
+}
+
+short mulawToShort[256];
+static bool madeTable = false;
+
+static	int	NXStreamCount;
+
+void NXPutc(NXStream *stream, char out) {
+	stream[NXStreamCount++] = out;
+}
+
+
+void encodeWavelet( sfx_t *sfx, short *packets) {
+	float	wksp[4097] = {0}, temp;
+	int		i, samples, size;
+	sndBuffer		*newchunk, *chunk;
+	byte			*out;
+
+	if (!madeTable) {
+		for (i=0;i<256;i++) {
+			mulawToShort[i] = (float)MuLawDecode((byte)i);
+		}
+		madeTable = true;
+	}
+	chunk = NULL;
+
+	samples = sfx->soundLength;
+	while(samples>0) {
+		size = samples;
+		if (size>(SND_CHUNK_SIZE*2)) {
+			size = (SND_CHUNK_SIZE*2);
+		}
+
+		if (size<4) {
+			size = 4;
+		}
+
+		newchunk = SND_malloc();
+		if (sfx->soundData == NULL) {
+			sfx->soundData = newchunk;
+		} else if (chunk != NULL) {
+			chunk->next = newchunk;
+		}
+		chunk = newchunk;
+		for(i=0; i<size; i++) {
+			wksp[i] = *packets;
+			packets++;
+		}
+		wt1(wksp, size, 1);
+		out = (byte *)chunk->sndChunk;
+
+		for(i=0;i<size;i++) {
+			temp = wksp[i];
+			if (temp > 32767) temp = 32767; else if (temp<-32768) temp = -32768;
+			out[i] = MuLawEncode((short)temp);
+		}
+
+		chunk->size = size;
+		samples -= size;
+	}
+}
+
+void decodeWavelet(sndBuffer *chunk, short *to) {
+	float			wksp[4097] = {0};
+	int				i;
+	byte			*out;
+
+	int size = chunk->size;
+	
+	out = (byte *)chunk->sndChunk;
+	for(i=0;i<size;i++) {
+		wksp[i] = mulawToShort[out[i]];
+	}
+
+	wt1(wksp, size, -1);
+	
+	if (!to) return;
+
+	for(i=0; i<size; i++) {
+		to[i] = wksp[i];
+	}
+}
+
+
+void encodeMuLaw( sfx_t *sfx, short *packets) {
+	int		i, samples, size, grade, poop;
+	sndBuffer		*newchunk, *chunk;
+	byte			*out;
+
+	if (!madeTable) {
+		for (i=0;i<256;i++) {
+			mulawToShort[i] = (float)MuLawDecode((byte)i);
+		}
+		madeTable = true;
+	}
+
+	chunk = NULL;
+	samples = sfx->soundLength;
+	grade = 0;
+
+	while(samples>0) {
+		size = samples;
+		if (size>(SND_CHUNK_SIZE*2)) {
+			size = (SND_CHUNK_SIZE*2);
+		}
+
+		newchunk = SND_malloc();
+		if (sfx->soundData == NULL) {
+			sfx->soundData = newchunk;
+		} else if (chunk != NULL) {
+			chunk->next = newchunk;
+		}
+		chunk = newchunk;
+		out = (byte *)chunk->sndChunk;
+		for(i=0; i<size; i++) {
+			poop = packets[0]+grade;
+			if (poop>32767) {
+				poop = 32767;
+			} else if (poop<-32768) {
+				poop = -32768;
+			}
+			out[i] = MuLawEncode((short)poop);
+			grade = poop - mulawToShort[out[i]];
+			packets++;
+		}
+		chunk->size = size;
+		samples -= size;
+	}
+}
+
+void decodeMuLaw(sndBuffer *chunk, short *to) {
+	int				i;
+	byte			*out;
+
+	int size = chunk->size;
+	
+	out = (byte *)chunk->sndChunk;
+	for(i=0;i<size;i++) {
+		to[i] = mulawToShort[out[i]];
+	}
+}