WaveSoundLoader.cpp

#include "WaveSoundLoader.h"
 
#include "Context.h"
 
#include "Resources/ResourceStore.h"
 
#include "Foundation/Logging/Logger.h"
 
#define fourccRIFF 'FFIR'
#define fourccDATA 'atad'
#define fourccFMT ' tmf'
#define fourccWAVE 'EVAW'
#define fourccXWMA 'AMWX'
#define fourccDPDS 'sdpd'
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("WaveSoundLoader");
}
 
namespace
{
  template<typename T>
  bool read(uint8_t * & begin, uint8_t * end, T & t)
  {
    if (sizeof(T) >= (end - begin)) return false;
 
    std::memcpy(&t, begin, sizeof(T));
 
    begin += sizeof(T);
 
    return true;
  }
 
  bool findChunk(uint8_t * begin, uint8_t * end, uint32_t fourCC, uint32_t & chunkSize, uint32_t & chunkPosition)
  {
    uint32_t RIFFDataSize;
    uint32_t fileType;
    uint32_t offset = 0;
 
    while (true) {
      uint32_t chunkType;
      if (!read(begin, end, chunkType)) {
        return false;
      }
 
      uint32_t chunkDataSize;
      if (!read(begin, end, chunkDataSize)) {
        return false;
      }
      switch (chunkType) {
      case fourccRIFF:
        RIFFDataSize = chunkDataSize;
        chunkDataSize = 4;
        if (!read(begin, end, fileType)) {
          return false;
        }
        break;
 
      default:
        begin += chunkDataSize;
        break;
      }
 
      offset += sizeof(uint32_t) * 2;
 
      if (chunkType == fourCC) {
        chunkSize = chunkDataSize;
        chunkPosition = offset;
        return true;
      }
 
      offset += chunkDataSize;
    }
 
    return true;
  }
 
  bool readChunkData(uint8_t * begin, size_t size, void * buffer, uint32_t bufferSize, uint32_t bufferOffset)
  {
    if (bufferOffset >= size) return false;
 
    std::memcpy(buffer, begin + bufferOffset, bufferSize);
 
    return true;
  }
}
 
bool Cogs::Core::WaveSoundLoader::canLoad(Context * /*context*/, const SoundLoadInfo & /*loadInfo*/)
{
  return true;
}
 
bool Cogs::Core::WaveSoundLoader::load(Context * context, const SoundLoadInfo & loadInfo)
{
  auto content = context->resourceStore->getResourceContents(loadInfo.resourcePath);
 
  if (content.empty()) {
    LOG_ERROR(logger, "Could not open %s.", loadInfo.resourcePath.c_str());
    return false;
  }
 
  uint32_t chunkSize;
  uint32_t chunkPosition;
 
  // Check the file type, should be fourccWAVE or 'XWMA'
  findChunk(content.data(), content.data() + content.size(), fourccRIFF, chunkSize, chunkPosition);
 
  uint32_t fileType;
  readChunkData(content.data(), content.size(), &fileType, sizeof(fileType), chunkPosition);
 
  if (fileType != fourccWAVE) {
    LOG_ERROR(logger, "Only WAVE format supported.");
    return false;
  }
 
  auto sound = (Sound *)(loadInfo.handle.get());
 
  // Find format information
  if (!findChunk(content.data(), content.data() + content.size(), fourccFMT, chunkSize, chunkPosition)) {
    LOG_ERROR(logger, "Could not locate sound format information in %s.", loadInfo.resourcePath.c_str());
    return false;
  }
 
  readChunkData(content.data(), content.size(), &sound->format, chunkSize, chunkPosition);
 
  // Find and read sound data.
  if (!findChunk(content.data(), content.data() + content.size(), fourccDATA, chunkSize, chunkPosition)) {
    LOG_ERROR(logger, "Could not locate data chunk in sound.");
    return false;
  }
 
  if (!chunkSize) {
    LOG_WARNING(logger, "Empty sound data specified.");
  }
 
  sound->data.resize(chunkSize);
  readChunkData(content.data(), content.size(), sound->data.data(), chunkSize, chunkPosition);
 
  return true;
}