SDLPAL/aviplay.c

/* -*- mode: c; tab-width: 4; c-basic-offset: 4; c-file-style: "linux" -*- */
//
// Copyright (c) 2017, SDLPAL development team.
// All rights reserved.
//
// This file is part of SDLPAL.
//
// SDLPAL 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.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

//
// aviplay.c
//
// Simple quick and dirty AVI player specially designed for PAL Win95.
//

/*
 * Portions based on:
 *
 * Microsoft Video-1 Decoder
 * Copyright (C) 2003 The FFmpeg project
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * Microsoft Video-1 Decoder by Mike Melanson (melanson@pcisys.net)
 * For more information about the MS Video-1 format, visit:
 *   http://www.pcisys.net/~melanson/codecs/
 */

#include "main.h"

typedef struct
{
    FILE         *fp;                 // pointer to the AVI file
    SDL_Surface  *surface;            // video buffer
    
    DWORD         dwVideoEndOffset;
    WORD          wWidth, wHeight;    // width and height of video
    WORD          wMsPerFrame;        // milliseconds per frame
    DWORD         dwAudioSamplesPerSec;
    DWORD         dwAudioBitsPerSample;
    DWORD         dwAudioChannels;
    SDL_AudioCVT  cvt;

    SDL_mutex    *mtxAudioData;
    BYTE          bAudioBuf[25600000];  // ring buffer for audio data
    DWORD         dwAudioReadPos;
    DWORD         dwAudioWritePos;
} AVIPlayState;

static SDL_mutex *gpAVIPlayStateMutex = NULL;
static AVIPlayState *gpAVIPlayState = NULL;

typedef struct
{
    DWORD   dwFourCC;
    DWORD   dwSize;
    BYTE    bData[1];
} AVIChunk;

typedef struct
{
    DWORD         dwMicroSecPerFrame; // frame display rate (or 0)
    DWORD         dwMaxBytesPerSec; // max. transfer rate
    DWORD         dwPaddingGranularity; // pad to multiples of this size
    DWORD         dwFlags; // the ever-present flags
    DWORD         dwTotalFrames; // # frames in file
    DWORD         dwInitialFrames;
    DWORD         dwStreams;
    DWORD         dwSuggestedBufferSize;
    DWORD         dwWidth;
    DWORD         dwHeight;
    DWORD         dwReserved[4];
} MainAVIHeader;

typedef struct
{
    DWORD         fccType;
    DWORD         fccHandler;
    DWORD         dwFlags;
    WORD          wPriority;
    WORD          wLanguage;
    DWORD         dwInitialFrames;
    DWORD         dwScale;
    DWORD         dwRate; /* dwRate / dwScale == samples/second */
    DWORD         dwStart;
    DWORD         dwLength; /* In units above... */
    DWORD         dwSuggestedBufferSize;
    DWORD         dwQuality;
    DWORD         dwSampleSize;
    DWORD         rcFrame[4];
} AVIStreamHeader;

typedef struct
{
    DWORD         biSize;
    DWORD         biWidth;
    DWORD         biHeight;
    WORD          biPlanes;
    WORD          biBitCount;
    DWORD         biCompression;
    DWORD         biSizeImage;
    DWORD         biXPelsPerMeter;
    DWORD         biYPelsPerMeter;
    DWORD         biClrUsed;
    DWORD         biClrImportant;
} BitmapInfoHeader;

typedef struct
{
    WORD          wFormatTag;
    WORD          nChannels;
    DWORD         nSamplesPerSec;
    DWORD         nAvgBytesPerSec;
    WORD          nBlockAlign;
    WORD          wBitsPerSample;
} WaveFormat;

#define AVI_RIFF (((DWORD)'R') | (((DWORD)'I') << 8) | (((DWORD)'F') << 16) | (((DWORD)'F') << 24))
#define AVI_hdrl (((DWORD)'h') | (((DWORD)'d') << 8) | (((DWORD)'r') << 16) | (((DWORD)'l') << 24))
#define AVI_strl (((DWORD)'s') | (((DWORD)'t') << 8) | (((DWORD)'r') << 16) | (((DWORD)'l') << 24))
#define AVI_strh (((DWORD)'s') | (((DWORD)'t') << 8) | (((DWORD)'r') << 16) | (((DWORD)'h') << 24))
#define AVI_strf (((DWORD)'s') | (((DWORD)'t') << 8) | (((DWORD)'r') << 16) | (((DWORD)'f') << 24))
#define AVI_avih (((DWORD)'a') | (((DWORD)'v') << 8) | (((DWORD)'i') << 16) | (((DWORD)'h') << 24))
#define AVI_LIST (((DWORD)'L') | (((DWORD)'I') << 8) | (((DWORD)'S') << 16) | (((DWORD)'T') << 24))
#define AVI_movi (((DWORD)'m') | (((DWORD)'o') << 8) | (((DWORD)'v') << 16) | (((DWORD)'i') << 24))
#define AVI_01wb (((DWORD)'0') | (((DWORD)'1') << 8) | (((DWORD)'w') << 16) | (((DWORD)'b') << 24))
#define AVI_00dc (((DWORD)'0') | (((DWORD)'0') << 8) | (((DWORD)'d') << 16) | (((DWORD)'c') << 24))
#define AVI_00db (((DWORD)'0') | (((DWORD)'0') << 8) | (((DWORD)'d') << 16) | (((DWORD)'b') << 24))
#define AVI_rec  (((DWORD)'r') | (((DWORD)'e') << 8) | (((DWORD)'c') << 16) | (((DWORD)' ') << 24))
#define AVI_JUNK (((DWORD)'J') | (((DWORD)'U') << 8) | (((DWORD)'N') << 16) | (((DWORD)'K') << 24))
#define AVI_vids (((DWORD)'v') | (((DWORD)'i') << 8) | (((DWORD)'d') << 16) | (((DWORD)'s') << 24))
#define AVI_auds (((DWORD)'a') | (((DWORD)'u') << 8) | (((DWORD)'d') << 16) | (((DWORD)'s') << 24))

static VOID
PAL_ParseAVInfoList(
    AVIPlayState    *lpAVIPlayState,
    DWORD            dwEndOffset
)
{
    AVIChunk         hdr;
    DWORD            dwNextOffset;
    MainAVIHeader    aviHeader;
    AVIStreamHeader  streamHdr;
    BitmapInfoHeader bitmapHdr;
    WaveFormat       waveFormat;
    DWORD            dwInfoType = 0;

    while (ftell(lpAVIPlayState->fp) < dwEndOffset)
    {
        if (feof(lpAVIPlayState->fp))
        {
            return; // end of file reached
        }

        fread(&hdr, sizeof(DWORD) * 2, 1, lpAVIPlayState->fp);
        hdr.dwFourCC = SDL_SwapLE32(hdr.dwFourCC);
        hdr.dwSize = SDL_SwapLE32(hdr.dwSize);

        dwNextOffset = ftell(lpAVIPlayState->fp) + hdr.dwSize;

        switch (hdr.dwFourCC)
        {
        case AVI_strh:
            fread(&streamHdr, sizeof(AVIStreamHeader), 1, lpAVIPlayState->fp);
            dwInfoType = SDL_SwapLE32(streamHdr.fccType);
            break;

        case AVI_strf:
            if (dwInfoType == AVI_vids)
            {
                fread(&bitmapHdr, sizeof(bitmapHdr), 1, lpAVIPlayState->fp);
            }
            else if (dwInfoType == AVI_auds)
            {
                fread(&waveFormat, sizeof(waveFormat), 1, lpAVIPlayState->fp);
                lpAVIPlayState->dwAudioChannels = SDL_SwapLE16(waveFormat.nChannels);
                lpAVIPlayState->dwAudioSamplesPerSec = SDL_SwapLE16(waveFormat.nSamplesPerSec);
                lpAVIPlayState->dwAudioBitsPerSample = SDL_SwapLE16(waveFormat.wBitsPerSample);
            }
            break;

        default:
            break;
        }
        
        fseek(lpAVIPlayState->fp, dwNextOffset, SEEK_SET);
    }

}

static VOID
PAL_ParseHdrlList(
    AVIPlayState    *lpAVIPlayState,
    DWORD            dwEndOffset
)
{
    AVIChunk         hdr;
    DWORD            dwNextOffset, dwListType;
    MainAVIHeader    aviHeader;

    while (ftell(lpAVIPlayState->fp) < dwEndOffset)
    {
        if (feof(lpAVIPlayState->fp))
        {
            return; // end of file reached
        }
        
        fread(&hdr, sizeof(DWORD) * 2, 1, lpAVIPlayState->fp);
        hdr.dwFourCC = SDL_SwapLE32(hdr.dwFourCC);
        hdr.dwSize = SDL_SwapLE32(hdr.dwSize);

        dwNextOffset = ftell(lpAVIPlayState->fp) + hdr.dwSize;

        switch (hdr.dwFourCC)
        {
        case AVI_avih:
            fread(&aviHeader, sizeof(aviHeader), 1, lpAVIPlayState->fp);
            lpAVIPlayState->wWidth = aviHeader.dwWidth;
            lpAVIPlayState->wHeight = aviHeader.dwHeight;
            lpAVIPlayState->wMsPerFrame = aviHeader.dwMicroSecPerFrame / 1000;
            break;

        case AVI_LIST:
            fread(&dwListType, sizeof(dwListType), 1, lpAVIPlayState->fp);
            if (SDL_SwapLE32(dwListType) == AVI_strl)
            {
                PAL_ParseAVInfoList(lpAVIPlayState, dwNextOffset);
            }
            break;
        }

        fseek(lpAVIPlayState->fp, dwNextOffset, SEEK_SET);
    }
}

static VOID
PAL_ReadAVIInfo(
    AVIPlayState    *lpAVIPlayState
)
{
    AVIChunk   hdr;
    DWORD      dwListType = 0;
    DWORD      dwNextOffset = 0;

    //
    // Skip RIFF header
    //
    fseek(lpAVIPlayState->fp, 12, SEEK_SET);
    
    while (TRUE)
    {
        if (feof(lpAVIPlayState->fp))
        {
            return; // end of file reached
        }

        fread(&hdr, sizeof(DWORD) * 2, 1, lpAVIPlayState->fp);
        hdr.dwFourCC = SDL_SwapLE32(hdr.dwFourCC);
        hdr.dwSize = SDL_SwapLE32(hdr.dwSize);
        
        dwNextOffset = ftell(lpAVIPlayState->fp) + hdr.dwSize;

        switch (hdr.dwFourCC)
        {
        case AVI_LIST:
            fread(&dwListType, sizeof(DWORD), 1, lpAVIPlayState->fp);
            dwListType = SDL_SwapLE32(dwListType);

            switch (dwListType)
            {
            case AVI_hdrl:
                PAL_ParseHdrlList(lpAVIPlayState, dwNextOffset);
                break;

            case AVI_movi:
                //
                // Stop right here as the actual movie data starts
                //
                lpAVIPlayState->dwVideoEndOffset = dwNextOffset;
                return;
            }
            
            break;

        case AVI_JUNK:
        default:
            //
            // Ignore these chunks
            //
            break;
        }

        fseek(lpAVIPlayState->fp, dwNextOffset, SEEK_SET);
    }
}

static AVIPlayState *
PAL_OpenAVI(
    LPCSTR     lpszPath
)
{
    AVIPlayState *ret;

    ret = (AVIPlayState *)UTIL_calloc(1, sizeof(AVIPlayState));

    //
    // Open the file
    //
    ret->fp = UTIL_OpenFile(lpszPath);
    if (ret->fp == NULL)
    {
        fprintf(stderr, "Cannot open file: %s!\n", lpszPath);
        free(ret);
        return NULL;
    }

    PAL_ReadAVIInfo(ret);

    if (ret->wWidth == 0 || ret->wHeight == 0)
    {
        return NULL;
    }

    //
    // Create surface
    //
    ret->surface = SDL_CreateRGBSurface(SDL_SWSURFACE, ret->wWidth, ret->wHeight, 16,
                                        0x7C00, 0x03E0, 0x001F, 0x0000);

    //
    // Create mutex
    //
    ret->mtxAudioData = SDL_CreateMutex();

    //
    // Build SDL audio conversion info
    //
    SDL_BuildAudioCVT(&ret->cvt,
        (ret->dwAudioBitsPerSample == 8) ? AUDIO_U8 : AUDIO_S16LSB,
        ret->dwAudioChannels,
        ret->dwAudioSamplesPerSec,
        AUDIO_S16SYS,
        gConfig.iAudioChannels,
        gConfig.iSampleRate);

    return ret;
}

static AVIChunk *
PAL_ReadAVChunk(
    AVIPlayState  *lpAVIPlayState
)
{
    AVIChunk   hdr;
    AVIChunk  *ret = NULL;
    DWORD      dwNextOffset;

begin:
    if (feof(lpAVIPlayState->fp) || ftell(lpAVIPlayState->fp) >= lpAVIPlayState->dwVideoEndOffset)
    {
        return NULL; // end of file reached
    }

    fread(&hdr, sizeof(DWORD) * 2, 1, lpAVIPlayState->fp);
    hdr.dwFourCC = SDL_SwapLE32(hdr.dwFourCC);
    hdr.dwSize = SDL_SwapLE32(hdr.dwSize);

    dwNextOffset = ftell(lpAVIPlayState->fp) + hdr.dwSize;

    switch (hdr.dwFourCC)
    {
    case AVI_LIST:
        //
        // Just skip list header here
        //
        fseek(lpAVIPlayState->fp, sizeof(DWORD), SEEK_CUR);
        goto begin;

    case AVI_01wb:
    case AVI_00db:
    case AVI_00dc:
        //
        // got actual audio/video frame
        //
        ret = (AVIChunk *)UTIL_malloc(sizeof(DWORD) * 2 + hdr.dwSize);
        *ret = hdr;
        fread(ret->bData, hdr.dwSize, 1, lpAVIPlayState->fp);
        break;

    case AVI_JUNK:
    default:
        //
        // Ignore these chunks
        //
        fseek(lpAVIPlayState->fp, dwNextOffset, SEEK_SET);
        goto begin;
    }

    fseek(lpAVIPlayState->fp, dwNextOffset, SEEK_SET);
    return ret;
}

static VOID
PAL_CloseAVI(
    AVIPlayState  *lpAVIPlayState
)
{
    if (lpAVIPlayState->fp != NULL)
    {
        fclose(lpAVIPlayState->fp);
    }

    if (lpAVIPlayState->surface != NULL)
    {
        SDL_FreeSurface(lpAVIPlayState->surface);
    }

    if (lpAVIPlayState->mtxAudioData != NULL)
    {
        SDL_DestroyMutex(lpAVIPlayState->mtxAudioData);
    }

    free(lpAVIPlayState);
}

static VOID
PAL_AVIFeedAudio(
    AVIPlayState   *lpAVIPlayState,
    LPBYTE          lpBuffer,
    DWORD           dwSize
)
{
    SDL_mutexP(lpAVIPlayState->mtxAudioData);

    while (dwSize > 0)
    {
        DWORD dwFeedSize = dwSize;

        if (lpAVIPlayState->dwAudioWritePos + dwSize > sizeof(lpAVIPlayState->bAudioBuf))
        {
            dwFeedSize = sizeof(lpAVIPlayState->bAudioBuf) - lpAVIPlayState->dwAudioWritePos;
        }

        memcpy(&lpAVIPlayState->bAudioBuf[lpAVIPlayState->dwAudioWritePos], lpBuffer, dwFeedSize);

        lpAVIPlayState->dwAudioWritePos += dwFeedSize;
        lpAVIPlayState->dwAudioWritePos %= sizeof(lpAVIPlayState->bAudioBuf);

        lpBuffer += dwFeedSize;
        dwSize -= dwFeedSize;
    }

    SDL_mutexV(lpAVIPlayState->mtxAudioData);
}

VOID
PAL_AVIInit(
    VOID
)
{
    gpAVIPlayStateMutex = SDL_CreateMutex();
}

VOID
PAL_AVIShutdown(
    VOID
)
{
    SDL_DestroyMutex(gpAVIPlayStateMutex);
}

static VOID
PAL_RenderAVIFrame(
    SDL_Surface      *lpSurface,
    AVIChunk         *lpChunk
)
{
#define AV_RL16(x) ((((LPCBYTE)(x))[1] << 8) | ((LPCBYTE)(x))[0])
#define CHECK_STREAM_PTR(n) if ((stream_ptr + n) > lpChunk->dwSize) { return; }
    int block_ptr, pixel_ptr;
    int total_blocks;
    int pixel_x, pixel_y;  // pixel width and height iterators
    int block_x, block_y;  // block width and height iterators
    int blocks_wide, blocks_high;  // width and height in 4x4 blocks
    int block_inc;
    int row_dec;

    /* decoding parameters */
    int stream_ptr;
    unsigned char byte_a, byte_b;
    unsigned short flags;
    int skip_blocks;
    unsigned short colors[8];
    unsigned short *pixels = (unsigned short *)lpSurface->pixels;
    int stride = lpSurface->pitch / 2;

    stream_ptr = 0;
    skip_blocks = 0;
    blocks_wide = lpSurface->w / 4;
    blocks_high = lpSurface->h / 4;
    total_blocks = blocks_wide * blocks_high;
    block_inc = 4;
    row_dec = stride + 4;

    for (block_y = blocks_high; block_y > 0; block_y--)
    {
        block_ptr = ((block_y * 4) - 1) * stride;
        for (block_x = blocks_wide; block_x > 0; block_x--)
        {
            // check if this block should be skipped
            if (skip_blocks)
            {
                block_ptr += block_inc;
                skip_blocks--;
                total_blocks--;
                continue;
            }
            
            pixel_ptr = block_ptr;
            
            // get the next two bytes in the encoded data stream
            CHECK_STREAM_PTR(2);
            byte_a = lpChunk->bData[stream_ptr++];
            byte_b = lpChunk->bData[stream_ptr++];
            
            // check if the decode is finished
            if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0))
            {
                return;
            }
            else if ((byte_b & 0xFC) == 0x84)
            {
                // skip code, but don't count the current block
                skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;
            }
            else if (byte_b < 0x80)
            {
                // 2- or 8-color encoding modes
                flags = (byte_b << 8) | byte_a;
                
                CHECK_STREAM_PTR(4);
                colors[0] = AV_RL16(&lpChunk->bData[stream_ptr]);
                stream_ptr += 2;
                colors[1] = AV_RL16(&lpChunk->bData[stream_ptr]);
                stream_ptr += 2;
                
                if (colors[0] & 0x8000)
                {
                    // 8-color encoding
                    CHECK_STREAM_PTR(12);
                    colors[2] = AV_RL16(&lpChunk->bData[stream_ptr]);
                    stream_ptr += 2;
                    colors[3] = AV_RL16(&lpChunk->bData[stream_ptr]);
                    stream_ptr += 2;
                    colors[4] = AV_RL16(&lpChunk->bData[stream_ptr]);
                    stream_ptr += 2;
                    colors[5] = AV_RL16(&lpChunk->bData[stream_ptr]);
                    stream_ptr += 2;
                    colors[6] = AV_RL16(&lpChunk->bData[stream_ptr]);
                    stream_ptr += 2;
                    colors[7] = AV_RL16(&lpChunk->bData[stream_ptr]);
                    stream_ptr += 2;
                    
                    for (pixel_y = 0; pixel_y < 4; pixel_y++)
                    {
                        for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
                        {
                            pixels[pixel_ptr++] =
                            colors[((pixel_y & 0x2) << 1) +
                                   (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];
                        }
                        pixel_ptr -= row_dec;
                    }
                }
                else
                {
                    // 2-color encoding
                    for (pixel_y = 0; pixel_y < 4; pixel_y++)
                    {
                        for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
                        {
                            pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];
                        }
                        pixel_ptr -= row_dec;
                    }
                }
            }
            else
            {
                // otherwise, it's a 1-color block
                colors[0] = (byte_b << 8) | byte_a;

                for (pixel_y = 0; pixel_y < 4; pixel_y++)
                {
                    for (pixel_x = 0; pixel_x < 4; pixel_x++)
                    {
                        pixels[pixel_ptr++] = colors[0];
                    }
                    pixel_ptr -= row_dec;
                }
            }
            
            block_ptr += block_inc;
            total_blocks--;
        }
    }
}

BOOL
PAL_PlayAVI(
    LPCSTR     lpszPath
)
{
    AVIPlayState *avi;
    AVIChunk     *chunk;
    DWORD         dwNextFrameTime = 0, dwCurrentTime = 0;
    BOOL          fEndPlay = FALSE;

    //
    // Open AVI file
    //
    avi = PAL_OpenAVI(lpszPath);
    if (avi == NULL)
    {
        return FALSE;
    }

    SDL_mutexP(gpAVIPlayStateMutex);
    gpAVIPlayState = avi;
    SDL_mutexV(gpAVIPlayStateMutex);

    PAL_ClearKeyState();

    while (!fEndPlay && (chunk = PAL_ReadAVChunk(avi)) != NULL)
    {
        dwCurrentTime = SDL_GetTicks();

        switch (chunk->dwFourCC)
        {
        case AVI_00dc:
        case AVI_00db:
            //
            // Video frame
            //
            PAL_RenderAVIFrame(avi->surface, chunk);
            VIDEO_DrawSurfaceToScreen(avi->surface);

            dwNextFrameTime = dwCurrentTime + avi->wMsPerFrame;
            dwCurrentTime = SDL_GetTicks();
            if (dwCurrentTime >= dwNextFrameTime)
            {
                UTIL_Delay(1);
            }
            else
            {
                UTIL_Delay(dwNextFrameTime - dwCurrentTime);
            }

            if (g_InputState.dwKeyPress & (kKeyMenu | kKeySearch))
            {
                fEndPlay = TRUE;
            }
            break;

        case AVI_01wb:
            //
            // Audio data, just feed into buffer
            //
            PAL_AVIFeedAudio(avi, chunk->bData, chunk->dwSize);
            break;
        }

        free(chunk);
    }

    SDL_mutexP(gpAVIPlayStateMutex);
    gpAVIPlayState = NULL;
    SDL_mutexV(gpAVIPlayStateMutex);

    if (fEndPlay)
    {
        //
        // Simulate a short delay (like the original game)
        //
        UTIL_Delay(500);
    }

    PAL_CloseAVI(avi);
    return TRUE;
}

VOID SDLCALL
AVI_FillAudioBuffer(
    LPVOID          udata,
    LPBYTE          stream,
    INT             len
)
{
    SDL_mutexP(gpAVIPlayStateMutex);
    if (gpAVIPlayState != NULL)
    {
        FLOAT flRateScale = ((FLOAT)gConfig.iSampleRate / gpAVIPlayState->dwAudioSamplesPerSec);
        while (len > 0 && gpAVIPlayState->dwAudioReadPos != gpAVIPlayState->dwAudioWritePos)
        {
            INT remainingLen = gpAVIPlayState->dwAudioWritePos - gpAVIPlayState->dwAudioReadPos;
            INT samplesToRead;

            if (remainingLen < 0)
            {
                remainingLen = sizeof(gpAVIPlayState->bAudioBuf) - gpAVIPlayState->dwAudioReadPos;
            }

            samplesToRead = remainingLen / gpAVIPlayState->dwAudioChannels / (gpAVIPlayState->dwAudioBitsPerSample / 8);
            if (samplesToRead > len / 2 / gConfig.iAudioChannels / flRateScale)
            {
                samplesToRead = len / 2 / gConfig.iAudioChannels / flRateScale;
            }

            gpAVIPlayState->cvt.buf = stream;
            gpAVIPlayState->cvt.len = samplesToRead *
                gpAVIPlayState->dwAudioChannels * (gpAVIPlayState->dwAudioBitsPerSample / 8);

            memcpy(stream, &gpAVIPlayState->bAudioBuf[gpAVIPlayState->dwAudioReadPos],
                samplesToRead * gpAVIPlayState->dwAudioChannels * (gpAVIPlayState->dwAudioBitsPerSample / 8));

            SDL_ConvertAudio(&gpAVIPlayState->cvt);

            stream += (DWORD)(samplesToRead * 2 * gConfig.iAudioChannels * flRateScale);
            len -= samplesToRead * 2 * gConfig.iAudioChannels * flRateScale;

            gpAVIPlayState->dwAudioReadPos += samplesToRead * gpAVIPlayState->dwAudioChannels *
                (gpAVIPlayState->dwAudioBitsPerSample / 8);

            gpAVIPlayState->dwAudioReadPos %= sizeof(gpAVIPlayState->bAudioBuf);
        }
    }
    SDL_mutexV(gpAVIPlayStateMutex);
}