//------------------------------------------------------------------------------
// <copyright file="KinectAudioStream.cpp" company="Microsoft">
//   Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <summary>
//   Implementation for KinectAudioStream methods.
//   KinectAudioStream wraps the Kinect audio stream and does proper format
//   conversion during read.
// </summary>
//------------------------------------------------------------------------------

#include "stdafx.h"
#include "KinectAudioStream.h"

#include <stdio.h>

/// <summary>
/// KinectAudioStream constructor.
/// </summary>
KinectAudioStream::KinectAudioStream(IStream *p32BitAudio) :
  m_cRef(1),
  m_p32BitAudio(p32BitAudio),
  m_SpeechActive(false) {
}

/// <summary>
/// SetSpeechState method
/// </summary>
void KinectAudioStream::SetSpeechState(bool state) {
  m_SpeechActive = state;
}

/////////////////////////////////////////////
// IStream methods
__pragma(warning(push))
__pragma(warning(disable:6101)) // Suppress warning about returning uninitialized memory *pBuffer. It is written correctly.
__pragma(warning(disable:6386)) // Suppress warning about buffer overrun while writing to 'pByteBuffer'. There are no overruns.
STDMETHODIMP KinectAudioStream::Read(
                                     _Out_writes_bytes_to_(cbBuffer, *pcbRead) void *pBuffer, 
                                     _In_ ULONG cbBuffer, 
                                     _Out_opt_ ULONG *pcbRead) {
  if (pBuffer == NULL || pcbRead == NULL || cbBuffer == 0) {
    return E_INVALIDARG;
  }

  HRESULT hr = S_OK;

  // 32bit -> 16bit conversion support
  INT16* p16Buffer = (INT16*)pBuffer;
  int factor = sizeof(float)/sizeof(INT16);

  // 32 bit read support
  float* p32Buffer = new float[cbBuffer/factor];
  byte* pByteBuffer = (byte*)p32Buffer;
  ULONG bytesRead = 0;
  ULONG bytesRemaining = cbBuffer * factor;

  // Speech reads at high frequency - this slows down the process
  int sleepDuration = 50;

  // Speech Service isn't tolerant of partial reads
  while (bytesRemaining > 0) {
    // Stop returning Audio data if Speech isn't active
    if (!m_SpeechActive) {
      *pcbRead = 0;
      hr = S_FALSE;
      goto exit;
    }

    // bytesRead will always be a multiple of 4 ( = sizeof(float))
    hr = m_p32BitAudio->Read(pByteBuffer, bytesRemaining, &bytesRead);
    pByteBuffer += bytesRead;
    bytesRemaining -= bytesRead;

    // All Audio buffers drained - wait for buffers to fill
    if (bytesRemaining != 0) {
      Sleep(sleepDuration);
    }
  }

  // Convert float value [-1,1] to int16 [SHRT_MIN, SHRT_MAX] and copy to output butter
  for (UINT i = 0; i < cbBuffer/factor; i++) {
    float sample = p32Buffer[i];

    // Make sure it is in the range [-1, +1]
    if (sample > 1.0f) {
      sample = 1.0f;
    } else if (sample < -1.0f) {
      sample = -1.0f;
    }

    // Scale float to the range (SHRT_MIN, SHRT_MAX] and then
    // convert to 16-bit signed with proper rounding
    float sampleScaled = sample * (float)SHRT_MAX;
    p16Buffer[i] = (sampleScaled > 0.f) ? (INT16)(sampleScaled + 0.5f) : (INT16)(sampleScaled - 0.5f);
  }

  *pcbRead = cbBuffer;

 exit:
  delete[] p32Buffer;
  return hr;
}
__pragma(warning(pop))

STDMETHODIMP KinectAudioStream::Write(_In_reads_bytes_(cb) const void *pv, _In_ ULONG cb, _Out_opt_ ULONG *pcbWritten) {
  return E_NOTIMPL;
}

STDMETHODIMP KinectAudioStream::Seek(LARGE_INTEGER /* dlibMove */, DWORD /* dwOrigin */, _Out_opt_ ULARGE_INTEGER *plibNewPosition) {
  // Speech seeks and expects a seek implementation - but the NUIAudio stream doesn't support seeking
  if (plibNewPosition != NULL) {
    plibNewPosition->QuadPart = 0;
  }

  return S_OK;
}

STDMETHODIMP KinectAudioStream::SetSize(ULARGE_INTEGER) {
  return E_NOTIMPL;
}

STDMETHODIMP KinectAudioStream::CopyTo(_In_ IStream *, ULARGE_INTEGER, _Out_opt_ ULARGE_INTEGER *, _Out_opt_ ULARGE_INTEGER *) {
  return E_NOTIMPL;
}

STDMETHODIMP KinectAudioStream::Commit(DWORD) {
  return E_NOTIMPL;
}

STDMETHODIMP KinectAudioStream::Revert() {
  return E_NOTIMPL;
}

STDMETHODIMP KinectAudioStream::LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD) {
  return E_NOTIMPL;
}

STDMETHODIMP KinectAudioStream::UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD) {
  return E_NOTIMPL;
}

STDMETHODIMP KinectAudioStream::Stat(__RPC__out STATSTG *, DWORD) {
  return E_NOTIMPL;
}

STDMETHODIMP KinectAudioStream::Clone(__RPC__deref_out_opt IStream **) {
  return E_NOTIMPL;
}