misc.wiiremote/trunk/wiimote.cpp

// _______________________________________________________________________________
//
//   - WiiYourself! - native C++ Wiimote library  v1.15
//    (c) gl.tter 2007-10 - http://gl.tter.org
//
//    see License.txt for conditions of use.  see History.txt for change log.
// _______________________________________________________________________________
//
//  wiimote.cpp  (tab = 4 spaces)

// VC-specifics:
#ifdef _MSC_VER 
 // disable warning "C++ exception handler used, but unwind semantics are not enabled."
 //                  in <xstring> (I don't use it - or just enable C++ exceptions)
# pragma warning(disable: 4530)
//  auto-link with the necessary libs
# pragma comment(lib, "setupapi.lib")   
# pragma comment(lib, "hid.lib")        // for HID API (from DDK)
# pragma comment(lib, "winmm.lib")      // for timeGetTime()
#endif // _MSC_VER

#include "wiimote.h"
#include <setupapi.h>
extern "C" {
# ifdef __MINGW32__
#  include <ddk/hidsdi.h>// from WinDDK
# else
#  include <api/hidsdi.h>
# endif
}
#include <sys/types.h>  // for _stat
#include <sys/stat.h>   // "
#include <process.h>    // for _beginthreadex()
#ifdef __BORLANDC__
# include <cmath.h>     // for orientation
#else
# include <math.h>      // "
#endif
#include <mmreg.h>      // for WAVEFORMATEXTENSIBLE
#include <mmsystem.h>   // for timeGetTime()

#include "ext.h" // FIXME: nx cia

// apparently not defined in some compilers:
#ifndef min
# define min(a,b)   (((a) < (b)) ? (a) : (b))
#endif
// ------------------------------------------------------------------------------------
// helpers
// ------------------------------------------------------------------------------------
template<class T> inline T sign  (const T& val)  { return (val<0)? T(-1) : T(1); }
template<class T> inline T square(const T& val)  { return val*val; }
#define ARRAY_ENTRIES(array)    (sizeof(array)/sizeof(array[0]))

// ------------------------------------------------------------------------------------
//  Tracing & Debugging
// ------------------------------------------------------------------------------------
#define PREFIX  _T("WiiYourself! : ")

// comment these to auto-strip their code from the library:
//  (they currently use OutputDebugString() via _TRACE() - change to suit)
/*#if (_MSC_VER >= 1400) // VC 2005+ (earlier versions don't support variable args)
# define TRACE(fmt, ...) _TRACE(PREFIX          fmt          _T("\n"), __VA_ARGS__)
# define WARN(fmt, ...)  _TRACE(PREFIX _T("* ") fmt _T(" *") _T("\n"), __VA_ARGS__)
#elif defined(__MINGW32__)
# define TRACE(fmt, ...) _TRACE(PREFIX          fmt          _T("\n") , ##__VA_ARGS__)
# define WARN(fmt, ...)  _TRACE(PREFIX _T("* ") fmt _T(" *") _T("\n") , ##__VA_ARGS__)
#endif*/
# define TRACE(fmt, ...) post((PREFIX          fmt          _T("\n")), __VA_ARGS__)
# define WARN(fmt, ...)  post((PREFIX _T("* ") fmt _T(" *") _T("\n")), __VA_ARGS__)
// uncomment any of these for deeper debugging:
//#define DEEP_TRACE(fmt, ...) post(PREFIX _T("|") fmt _T("\n"), __VA_ARGS__)    // VC 2005+
//#define DEEP_TRACE(fmt, ...) post(PREFIX _T("|") fmt _T("\n") , ##__VA_ARGS__) // mingw
//#define BEEP_DEBUG_READS
//#define BEEP_DEBUG_WRITES
//#define BEEP_ON_ORIENTATION_ESTIMATE
//#define BEEP_ON_PERIODIC_STATUSREFRESH

// internals: auto-strip code from the macros if they weren't defined
#ifndef TRACE
# define TRACE
#endif
#ifndef DEEP_TRACE
# define DEEP_TRACE
#endif
#ifndef WARN
# define WARN
#endif
// ------------------------------------------------------------------------------------
static void _cdecl _TRACE (const TCHAR* fmt, ...)
    {
    static TCHAR buffer[256];
    if (!fmt) return;

    va_list  argptr;
    va_start (argptr, fmt);
#if (_MSC_VER >= 1400) // VC 2005+
    _vsntprintf_s(buffer, ARRAY_ENTRIES(buffer), _TRUNCATE, fmt, argptr);
#else
    _vsntprintf  (buffer, ARRAY_ENTRIES(buffer),             fmt, argptr);
#endif
    va_end (argptr);

    OutputDebugString(buffer);
    }

// ------------------------------------------------------------------------------------
//  wiimote
// ------------------------------------------------------------------------------------
// class statics
HMODULE        wiimote::HidDLL                = NULL;
unsigned       wiimote::_TotalCreated         = 0;
unsigned       wiimote::_TotalConnected       = 0;
hidwrite_ptr   wiimote::_HidD_SetOutputReport = NULL;

// (keep in sync with 'speaker_freq'):
const unsigned wiimote::FreqLookup [TOTAL_FREQUENCIES] = 
                                {    0, 4200, 3920, 3640, 3360,
                                  3130, 2940, 2760, 2610, 2470 };

const TCHAR*   wiimote::ButtonNameFromBit        [TOTAL_BUTTON_BITS] =
                                { _T("Left") , _T("Right"), _T("Down"), _T("Up"),
                                  _T("Plus") , _T("??")   , _T("??")  , _T("??") ,
                                  _T("Two")  , _T("One")  , _T("B")   , _T("A") ,
                                  _T("Minus"), _T("??")   , _T("??")  , _T("Home") };

const TCHAR*   wiimote::ClassicButtonNameFromBit [TOTAL_BUTTON_BITS] =
                                { _T("??")   , _T("TrigR")  , _T("Plus") , _T("Home"),
                                  _T("Minus"), _T("TrigL") , _T("Down") , _T("Right") ,
                                  _T("Up")   , _T("Left")   , _T("ZR")   , _T("X") ,
                                  _T("A")    , _T("Y")      , _T("B")    , _T("ZL") };
// ------------------------------------------------------------------------------------
wiimote::wiimote ()
    :
    DataRead             (CreateEvent(NULL, FALSE, FALSE, NULL)),
    Handle               (INVALID_HANDLE_VALUE),
    ReportType           (IN_BUTTONS),
    bStatusReceived      (false), // for output method detection
    bConnectInProgress   (true ),
    bInitInProgress      (false),
    bEnablingMotionPlus  (false),
    bConnectionLost      (false), // set if write fails after connection
    bMotionPlusDetected  (false),
    bMotionPlusEnabled   (false),
    bMotionPlusExtension (false),
    bCalibrateAtRest     (false),
    bUseHIDwrite         (false), // if OS supports it
    ChangedCallback      (NULL),
    CallbackTriggerFlags (CHANGED_ALL),
    InternalChanged      (NO_CHANGE),
    CurrentSample        (NULL),
    HIDwriteThread       (NULL),
    ReadParseThread      (NULL),
    SampleThread         (NULL),
    AsyncRumbleThread    (NULL),
    AsyncRumbleTimeout   (0),
    UniqueID             (0)    // not _guaranteed_ unique, see comments in header
#ifdef ID2_FROM_DEVICEPATH      // (see comments in header)
    // UniqueID2             (0)    
#endif
    {
    _ASSERT(DataRead != INVALID_HANDLE_VALUE);
                
    // if this is the first wiimote object, detect & enable HID write support
    if(++_TotalCreated == 1)
        {
        HidDLL = LoadLibrary(_T("hid.dll"));
        _ASSERT(HidDLL);
        if(!HidDLL)
            WARN(_T("Couldn't load hid.dll - shouldn't happen!"));
        else{
            _HidD_SetOutputReport = (hidwrite_ptr)
                                    GetProcAddress(HidDLL, "HidD_SetOutputReport");
            if(_HidD_SetOutputReport)
                TRACE(_T("OS supports HID writes."));
            else
                TRACE(_T("OS doesn't support HID writes."));
            }
        }

    // clear our public and private state data completely (including deadzones)
    Clear         (true);
    Internal.Clear(true);

    // and the state recording vars
    memset(&Recording, 0, sizeof(Recording));

    // for overlapped IO (Read/WriteFile)
    memset(&Overlapped, 0, sizeof(Overlapped));
    Overlapped.hEvent     = DataRead;
    Overlapped.Offset     =
    Overlapped.OffsetHigh = 0;

    // for async HID output method
    InitializeCriticalSection(&HIDwriteQueueLock);
    // for polling
    InitializeCriticalSection(&StateLock);

    // request millisecond timer accuracy
    timeBeginPeriod(1);     
    }
// ------------------------------------------------------------------------------------
wiimote::~wiimote ()
    {
    Disconnect();

    // events & critical sections are kept open for the lifetime of the object,
    //  so tidy them up here:
    if(DataRead != INVALID_HANDLE_VALUE)
        CloseHandle(DataRead);

    DeleteCriticalSection(&HIDwriteQueueLock);
    DeleteCriticalSection(&StateLock);

    // tidy up timer accuracy request
    timeEndPeriod(1);       

    // release HID DLL (for dynamic HID write method)
    if((--_TotalCreated == 0) && HidDLL)
        {
        FreeLibrary(HidDLL);
        HidDLL                = NULL;
        _HidD_SetOutputReport = NULL;
        }
    }

// ------------------------------------------------------------------------------------
bool wiimote::Connect (unsigned wiimote_index, bool force_hidwrites)
    {
    if(wiimote_index == FIRST_AVAILABLE)
        TRACE(_T("Connecting first available Wiimote:"));
    else
        TRACE(_T("Connecting Wiimote %u:"), wiimote_index);

    // auto-disconnect if user is being naughty
    if(IsConnected())
        Disconnect();

    // get the GUID of the HID class
    GUID guid;
    HidD_GetHidGuid(&guid);

    // get a handle to all devices that are part of the HID class
    // Brian: Fun fact:  DIGCF_PRESENT worked on my machine just fine.  I reinstalled
    //   Vista, and now it no longer finds the Wiimote with that parameter enabled...
    HDEVINFO dev_info = SetupDiGetClassDevs(&guid, NULL, NULL, DIGCF_DEVICEINTERFACE);// | DIGCF_PRESENT);
    if(!dev_info) {
        WARN(_T("couldn't get device info"));
        return false;
        }

    // enumerate the devices
    SP_DEVICE_INTERFACE_DATA didata;
    didata.cbSize = sizeof(didata);
    
    unsigned index          = 0;
    unsigned wiimotes_found = 0;
    while(SetupDiEnumDeviceInterfaces(dev_info, NULL, &guid, index, &didata))
        {
        // get the buffer size for this device detail instance
        DWORD req_size = 0;
        SetupDiGetDeviceInterfaceDetail(dev_info, &didata, NULL, 0, &req_size, NULL);

        // (bizarre way of doing it) create a buffer large enough to hold the
        //  fixed-size detail struct components, and the variable string size
        SP_DEVICE_INTERFACE_DETAIL_DATA *didetail =
                                (SP_DEVICE_INTERFACE_DETAIL_DATA*) new BYTE[req_size];
        _ASSERT(didetail);
        didetail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);

        // now actually get the detail struct
        if(!SetupDiGetDeviceInterfaceDetail(dev_info, &didata, didetail,
                                            req_size, &req_size, NULL)) {
            WARN(_T("couldn't get devinterface info for %u"), index);
            break;
            }

        // open a shared handle to the device to query it (this will succeed even
        //  if the wiimote is already Connect()'ed)
        DEEP_TRACE(_T(".. querying device %s"), didetail->DevicePath);
        Handle = CreateFile(didetail->DevicePath, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
                                                  NULL, OPEN_EXISTING, 0, NULL);
        if(Handle == INVALID_HANDLE_VALUE) {
            DEEP_TRACE(_T(".... failed with err %x (probably harmless)."), 
                       GetLastError());
            goto skip;
            }
    
        // get the device attributes
        HIDD_ATTRIBUTES attrib;
        attrib.Size = sizeof(attrib);
        if(HidD_GetAttributes(Handle, &attrib))
            {
            // is this a wiimote?
            if((attrib.VendorID != VID) || (attrib.ProductID != PID))
                goto skip;

            // yes, but is it the one we're interested in?
            ++wiimotes_found;
            if((wiimote_index != FIRST_AVAILABLE) &&
               (wiimote_index != wiimotes_found))
                goto skip;

            // the wiimote is installed, but it may not be currently paired:
            if(wiimote_index == FIRST_AVAILABLE)
                TRACE(_T(".. opening Wiimote %u:"), wiimotes_found);
            else
                TRACE(_T(".. opening:"));


            // re-open the handle, but this time we don't allow write sharing
            //  (that way subsequent calls can still _discover_ wiimotes above, but
            //   will correctly fail here if they're already connected)
            CloseHandle(Handle);
            
            // note this also means that if another application has already opened
            //  the device, the library can no longer connect it (this may happen
            //  with software that enumerates all joysticks in the system, because
            //  even though the wiimote is not a standard joystick (and can't
            //  be read as such), it unfortunately announces itself to the OS
            //  as one.  The SDL library was known to do grab wiimotes like this.
            //  If you cannot stop the application from doing it, you may change the
            //  call below to open the device in full shared mode - but then the
            //  library can no longer detect if you've already connected a device
            //  and will allow you to connect it twice!  So be careful ...
            Handle = CreateFile(didetail->DevicePath, GENERIC_READ|GENERIC_WRITE,
                                                    FILE_SHARE_READ,
                                                    NULL, OPEN_EXISTING,
                                                    FILE_FLAG_OVERLAPPED, NULL);
            if(Handle == INVALID_HANDLE_VALUE) {
                TRACE(_T(".... failed with err %x"), GetLastError());
                goto skip;
                }

            // clear the wiimote state & buffers
            Clear         (false);      // preserves existing deadzones
            Internal.Clear(false);      // "
            InternalChanged = NO_CHANGE;
            memset(ReadBuff , 0, sizeof(ReadBuff));
            bConnectionLost    = false;
            bConnectInProgress = true; // don't parse extensions or request regular
                                       //  updates until complete
            // enable async reading
            BeginAsyncRead();

            // autodetect which write method the Bluetooth stack supports,
            //  by requesting the wiimote status report:
            if(force_hidwrites && !_HidD_SetOutputReport) {
                TRACE(_T(".. can't force HID writes (not supported)"));
                force_hidwrites = false;
                }

            if(force_hidwrites)
                TRACE(_T(".. (HID writes forced)"));
            else{
                //  - try WriteFile() first as it's the most efficient (it uses
                //     harware interrupts where possible and is async-capable):
                bUseHIDwrite = false;
                RequestStatusReport();
                //  and wait for the report to arrive:
                DWORD last_time = timeGetTime();
                while(!bStatusReceived && ((timeGetTime()-last_time) < 500))
                    Sleep(10);
                TRACE(_T(".. WriteFile() %s."), bStatusReceived? _T("succeeded") :
                                                                 _T("failed"));
                }

            // try HID write method (if supported)
            if(!bStatusReceived && _HidD_SetOutputReport)
                {
                bUseHIDwrite = true;
                RequestStatusReport();
                // wait for the report to arrive:
                DWORD last_time = timeGetTime();
                while(!bStatusReceived && ((timeGetTime()-last_time) < 500))
                    Sleep(10);
                // did we get it?
                TRACE(_T(".. HID write %s."), bStatusReceived? _T("succeeded") :
                                                               _T("failed"));
                }

            // still failed?
            if(!bStatusReceived) {
                WARN(_T("output failed - wiimote is not connected (or confused)."));
                Disconnect();
                goto skip;
                }

//Sleep(500);
            // reset it
            Reset();

            // read the wiimote calibration info
            ReadCalibration();

            // allow the result(s) to come in (so that the caller can immediately test
            //  MotionPlusConnected()
            Sleep(300); // note, don't need it on my system, better to be safe though

            // connected succesfully:
            _TotalConnected++;

            // use the first incomding analogue sensor values as the 'at rest'
            //  offsets (only supports the Balance Board currently)
            bCalibrateAtRest = true;

            // refresh the public state from the internal one (so that everything
            //  is available straight away
            RefreshState();

            // attempt to construct a unique hardware ID from the calibration
            //  data bytes (this is obviously not guaranteed to be unique across
            //  all devices, but may work fairly well in practice... ?)
            memcpy(&UniqueID, &CalibrationInfo, sizeof(CalibrationInfo));

            _ASSERT(UniqueID != 0); // if this fires, the calibration data didn't
                                    //  arrive - this shouldn't happen

#ifdef ID2_FROM_DEVICEPATH      // (see comments in header)
            // create a 2nd alternative id by simply adding all the characters
            //  in the device path to create a single number
            UniqueID2 = 0;
            for(unsigned index=0; index<_tcslen(didetail->DevicePath); index++)
                UniqueID2 += didetail->DevicePath[index];
#endif
            // and show when we want to trigger the next periodic status request
            //  (for battery level and connection loss detection)
            NextStatusTime      = timeGetTime() + REQUEST_STATUS_EVERY_MS;
            NextMPlusDetectTime = timeGetTime() + DETECT_MPLUS_EVERY_MS;
            MPlusDetectCount    = DETECT_MPLUS_COUNT;

            // tidy up
            delete[] (BYTE*)didetail;
            break;
            }
skip:
        // tidy up
        delete[] (BYTE*)didetail;

        if(Handle != INVALID_HANDLE_VALUE) {
            CloseHandle(Handle);
            Handle = INVALID_HANDLE_VALUE;
            }
        // if this was the specified wiimote index, abort
        if((wiimote_index != FIRST_AVAILABLE) &&
           (wiimote_index == (wiimotes_found-1)))
           break;

        index++;
        }

    // clean up our list
    SetupDiDestroyDeviceInfoList(dev_info);

    bConnectInProgress = false;
    if(IsConnected()) {
        TRACE(_T(".. connected!"));
        // notify the callbacks (if requested to do so)
        if(CallbackTriggerFlags & CONNECTED)
            {
            ChangedNotifier(CONNECTED, Internal);
            if(ChangedCallback)
                ChangedCallback(*this, CONNECTED, Internal);
            }
        return true;
        }
    TRACE(_T(".. connection failed."));
    return false;
    }
// ------------------------------------------------------------------------------------
void wiimote::CalibrateAtRest ()
    {
    _ASSERT(IsConnected());
    if(!IsConnected())
        return;

    // the app calls this to remove 'at rest' offsets from the analogue sensor
    //  values (currently only works for the Balance Board):
    if(IsBalanceBoard()) {
        TRACE(_T(".. removing 'at rest' BBoard offsets."));
        Internal.BalanceBoard.AtRestKg = Internal.BalanceBoard.Kg;
        RefreshState();
        }
    }
// ------------------------------------------------------------------------------------
void wiimote::Disconnect ()
    {
    if(Handle == INVALID_HANDLE_VALUE)
        return;

    TRACE(_T("Disconnect()."));
    
    if(IsConnected())
        {
        _ASSERT(_TotalConnected > 0); // sanity
        _TotalConnected--;
        
        if(!bConnectionLost)
            Reset();
        }

    CloseHandle(Handle);
    Handle = INVALID_HANDLE_VALUE;
    UniqueID  = 0;
#ifdef ID2_FROM_DEVICEPATH      // (see comments in header)
    UniqueID2 = 0;
#endif

    // close the read thread
    if(ReadParseThread) {
        // unblock it so it can realise we're closing and exit straight away
        SetEvent(DataRead);
        WaitForSingleObject(ReadParseThread, 3000);
        CloseHandle(ReadParseThread);
        ReadParseThread = NULL;
        }
    // close the rumble thread
    if(AsyncRumbleThread) {
        WaitForSingleObject(AsyncRumbleThread, 3000);
        CloseHandle(AsyncRumbleThread);
        AsyncRumbleThread  = NULL;
        AsyncRumbleTimeout = 0;
        }
    // and the sample streaming thread
    if(SampleThread) {
        WaitForSingleObject(SampleThread, 3000);
        CloseHandle(SampleThread);
        SampleThread = NULL;
        }

#ifndef USE_DYNAMIC_HIDQUEUE
    HID.Deallocate();
#endif

    bStatusReceived = false;

    // and clear the state
    Clear         (false); // (preserves deadzones)
    Internal.Clear(false); // "
    InternalChanged = NO_CHANGE;
    }
// ------------------------------------------------------------------------------------
void wiimote::Reset ()
    {
    TRACE(_T("Resetting wiimote."));
    
    if(bMotionPlusEnabled)
        DisableMotionPlus();

    // stop updates (by setting report type to non-continuous, buttons-only)
    if(IsBalanceBoard())
        SetReportType(IN_BUTTONS_BALANCE_BOARD, false);
    else
        SetReportType(IN_BUTTONS, false);

    SetRumble    (false);
    SetLEDs      (0x00);
//  MuteSpeaker  (true);
    EnableSpeaker(false);

    Sleep(150); // avoids loosing the extension calibration data on Connect()
    }
// ------------------------------------------------------------------------------------
unsigned __stdcall wiimote::ReadParseThreadfunc (void* param)
    {
    // this thread waits for the async ReadFile() to deliver data & parses it.
    //  it also requests periodic status updates, deals with connection loss
    //  and ends state recordings with a specific duration:
    _ASSERT(param);
    wiimote    &remote     = *(wiimote*)param;
    OVERLAPPED &overlapped = remote.Overlapped;
    unsigned exit_code     = 0; // (success)

    while(1)
        {
        // wait until the overlapped read completes, or the timeout is reached:
        DWORD wait = WaitForSingleObject(overlapped.hEvent, 500);

        // before we deal with the result, let's do some housekeeping:

        //  if we were recently Disconect()ed, exit now
        if(remote.Handle == INVALID_HANDLE_VALUE) {
            DEEP_TRACE(_T("read thread: wiimote was disconnected"));
            break;
            }
        //  ditto if the connection was lost (eg. through a failed write)
        if(remote.bConnectionLost)
            {
connection_lost:
            TRACE(_T("read thread: connection to wiimote was lost"));
            remote.Disconnect();
            remote.InternalChanged = (state_change_flags)
                                (remote.InternalChanged | CONNECTION_LOST);
            // report via the callback (if any)
            if(remote.CallbackTriggerFlags & CONNECTION_LOST)
                {
                remote.ChangedNotifier(CONNECTION_LOST, remote.Internal);
                if(remote.ChangedCallback)
                    remote.ChangedCallback(remote, CONNECTION_LOST, remote.Internal);
                }
            break;
            }

        DWORD time = timeGetTime();
        //  periodic events (but not if we're streaming audio,
        //                   we don't want to cause a glitch)
        if(remote.IsConnected() && !remote.bInitInProgress &&
           !remote.IsPlayingAudio())
            {
            // status request due? 
            if(time > remote.NextStatusTime)
                {
#ifdef BEEP_ON_PERIODIC_STATUSREFRESH
                Beep(2000,50);
#endif
                remote.RequestStatusReport();
                // and schedule the next one
                remote.NextStatusTime = time + REQUEST_STATUS_EVERY_MS;
                }
            // motion plus detection due?
            if(!remote.IsBalanceBoard()     &&
//             !remote.bConnectInProgress   &&
               !remote.bMotionPlusExtension &&
               (remote.Internal.ExtensionType != MOTION_PLUS) &&
               (remote.Internal.ExtensionType != PARTIALLY_INSERTED) &&
               (time > remote.NextMPlusDetectTime))
                {
                remote.DetectMotionPlusExtensionAsync();
                // we try several times in quick succession before the next
                //  delay:
                if(--remote.MPlusDetectCount == 0) {
                    remote.NextMPlusDetectTime = time + DETECT_MPLUS_EVERY_MS;
                    remote.MPlusDetectCount    = DETECT_MPLUS_COUNT;
#ifdef _DEBUG
                    TRACE(_T("--"));
#endif
                    }
                }
            }

        //  if we're state recording and have reached the specified duration, stop
        if(remote.Recording.bEnabled && (remote.Recording.EndTimeMS != UNTIL_STOP) &&
           (time >= remote.Recording.EndTimeMS))
           remote.Recording.bEnabled = false;

        // now handle the wait result:
        //  did the wait time out?
        if(wait == WAIT_TIMEOUT) {
            DEEP_TRACE(_T("read thread: timed out"));
            continue; // wait again
            }
        //  did an error occurr?
        if(wait != WAIT_OBJECT_0) {
            DEEP_TRACE(_T("read thread: error waiting!"));
            remote.bConnectionLost = true;
            // deal with it straight away to avoid a longer delay
            goto connection_lost;
            }
    
        // data was received:
#ifdef BEEP_DEBUG_READS
        Beep(500,1);
#endif
        DWORD read = 0;
        //  get the data read result
        GetOverlappedResult(remote.Handle, &overlapped, &read, TRUE);
        //  if we read data, parse it
        if(read) {
            DEEP_TRACE(_T("read thread: parsing data"));
            remote.OnReadData(read);
            }
        else
            DEEP_TRACE(_T("read thread: didn't get any data??"));
        }

    TRACE(_T("(ending read thread)"));
#ifdef BEEP_DEBUG_READS
    if(exit_code != 0)
        Beep(200,1000);
#endif
    return exit_code;
    }
// ------------------------------------------------------------------------------------
bool wiimote::BeginAsyncRead ()
    {
    // (this is also called before we're fully connected)
    if(Handle == INVALID_HANDLE_VALUE)
        return false;

    DEEP_TRACE(_T(".. starting async read"));
#ifdef BEEP_DEBUG_READS
    Beep(1000,1);
#endif

    DWORD read;
    if (!ReadFile(Handle, ReadBuff, REPORT_LENGTH, &read, &Overlapped)) {
        DWORD err = GetLastError();
        if(err != ERROR_IO_PENDING) {
            DEEP_TRACE(_T(".... ** ReadFile() failed! **"));
            return false;
            }
        }

    // launch the completion wait/callback thread
    if(!ReadParseThread) {
        ReadParseThread = (HANDLE)_beginthreadex(NULL, 0, ReadParseThreadfunc,
                                                 this, 0, NULL);
        DEEP_TRACE(_T(".... creating read thread"));
        _ASSERT(ReadParseThread);
        if(!ReadParseThread)
            return false;
        SetThreadPriority(ReadParseThread, WORKER_THREAD_PRIORITY);
        }

    // if ReadFile completed while we called, signal the thread to proceed
    if(read) {
        DEEP_TRACE(_T(".... got data right away"));
        SetEvent(DataRead);
        }
    return true;
    }
// ------------------------------------------------------------------------------------
void wiimote::OnReadData (DWORD bytes_read)
    {
    _ASSERT(bytes_read == REPORT_LENGTH);

    // copy our input buffer
    BYTE buff [REPORT_LENGTH];
    memcpy(buff, ReadBuff, bytes_read);

    // start reading again
    BeginAsyncRead();

    // parse it
    ParseInput(buff);
    }
// ------------------------------------------------------------------------------------
void wiimote::SetReportType (input_report type, bool continuous)
    {
    _ASSERT(IsConnected());
    if(!IsConnected())
        return;

    // the balance board only uses one type of report
    _ASSERT(!IsBalanceBoard() || type == IN_BUTTONS_BALANCE_BOARD);
    if(IsBalanceBoard() && (type != IN_BUTTONS_BALANCE_BOARD))
        return;

#ifdef TRACE
    #define TYPE2NAME(_type)    (type==_type)? _T(#_type)
    const TCHAR* name = TYPE2NAME(IN_BUTTONS)               :
                        TYPE2NAME(IN_BUTTONS_ACCEL_IR)      :
                        TYPE2NAME(IN_BUTTONS_ACCEL_EXT)     :
                        TYPE2NAME(IN_BUTTONS_ACCEL_IR_EXT)  :
                        TYPE2NAME(IN_BUTTONS_BALANCE_BOARD) :
                        _T("(unknown??)");
    TRACE(_T("ReportType: %s (%s)"), name, (continuous? _T("continuous") :
                                                        _T("non-continuous")));
#endif
    ReportType = type;

    switch(type)
        {
        case IN_BUTTONS_ACCEL_IR:
            EnableIR(wiimote_state::ir::EXTENDED);
            break;
        case IN_BUTTONS_ACCEL_IR_EXT:
            EnableIR(wiimote_state::ir::BASIC);
            break;
        default:
            DisableIR();
            break;
        }

    BYTE buff [REPORT_LENGTH] = {0};
    buff[0] = OUT_TYPE;
    buff[1] = (continuous ? 0x04 : 0x00) | GetRumbleBit();
    buff[2] = (BYTE)type;
    WriteReport(buff);
//  Sleep(15);
    }
// ------------------------------------------------------------------------------------
void wiimote::SetLEDs (BYTE led_bits)
    {
    _ASSERT(IsConnected());
    if(!IsConnected() || bInitInProgress)
        return;

    _ASSERT(led_bits <= 0x0f);
    led_bits &= 0xf;
    
    BYTE buff [REPORT_LENGTH] = {0};
    buff[0] = OUT_LEDs;
    buff[1] = (led_bits<<4) | GetRumbleBit();
    WriteReport(buff);

    Internal.LED.Bits = led_bits;
    }
// ------------------------------------------------------------------------------------
void wiimote::SetRumble (bool on)
    {
    _ASSERT(IsConnected());
    if(!IsConnected())
        return;

    if(Internal.bRumble == on)
        return;

    Internal.bRumble = on;

    // if we're streaming audio, we don't need to send a report (sending it makes
    // the audio glitch, and the rumble bit is sent with every report anyway)
    if(IsPlayingAudio())
        return;

    BYTE buff [REPORT_LENGTH] = {0};
    buff[0] = OUT_STATUS;
    buff[1] = on? 0x01 : 0x00;
    WriteReport(buff);
    }
// ------------------------------------------------------------------------------------
unsigned __stdcall wiimote::AsyncRumbleThreadfunc (void* param)
    {
    // auto-disables rumble after x milliseconds:
    _ASSERT(param);
    wiimote &remote = *(wiimote*)param;
    
    while(remote.IsConnected())
        {
        if(remote.AsyncRumbleTimeout)
            {
            DWORD current_time = timeGetTime();
            if(current_time >= remote.AsyncRumbleTimeout)
                {
                if(remote.Internal.bRumble)
                    remote.SetRumble(false);
                remote.AsyncRumbleTimeout = 0;
                }
            Sleep(1);
            }
        else
            Sleep(4);
        }
    return 0;
    }
// ------------------------------------------------------------------------------------
void wiimote::RumbleForAsync (unsigned milliseconds)
    {
    // rumble for a fixed amount of time
    _ASSERT(IsConnected());
    if(!IsConnected())
        return;

    SetRumble(true);

    // show how long thread should wait to disable rumble again
    // (it it's currently rumbling it will just extend the time)
    AsyncRumbleTimeout = timeGetTime() + milliseconds;

    // create the thread?
    if(AsyncRumbleThread)
        return;

    AsyncRumbleThread = (HANDLE)_beginthreadex(NULL, 0, AsyncRumbleThreadfunc, this,
                                               0, NULL);
    _ASSERT(AsyncRumbleThread);
    if(!AsyncRumbleThread) {
        WARN(_T("couldn't create rumble thread!"));
        return;
        }
    SetThreadPriority(AsyncRumbleThread, WORKER_THREAD_PRIORITY);
    }
// ------------------------------------------------------------------------------------
void wiimote::RequestStatusReport ()
    {
    // (this can be called before we're fully connected)
    _ASSERT(Handle != INVALID_HANDLE_VALUE);
    if(Handle == INVALID_HANDLE_VALUE)
        return;

    BYTE buff [REPORT_LENGTH] = {0};
    buff[0] = OUT_STATUS;
    buff[1] = GetRumbleBit();
    WriteReport(buff);
    }
// ------------------------------------------------------------------------------------
bool wiimote::ReadAddress (int address, short size)
    {
    // asynchronous
    BYTE buff [REPORT_LENGTH] = {0};
    buff[0] = OUT_READMEMORY;
    buff[1] = (BYTE)(((address & 0xff000000) >> 24) | GetRumbleBit());
    buff[2] = (BYTE)( (address & 0x00ff0000) >> 16);
    buff[3] = (BYTE)( (address & 0x0000ff00) >>  8);
    buff[4] = (BYTE)( (address & 0x000000ff));
    buff[5] = (BYTE)( (size    & 0xff00    ) >>  8);
    buff[6] = (BYTE)( (size    & 0xff));
    return WriteReport(buff);
    }
// ------------------------------------------------------------------------------------
void wiimote::WriteData (int address, BYTE size, const BYTE* buff)
    {
    // asynchronous
    BYTE write [REPORT_LENGTH] = {0};
    write[0] = OUT_WRITEMEMORY;
    write[1] = (BYTE)(((address & 0xff000000) >> 24) | GetRumbleBit());
    write[2] = (BYTE)( (address & 0x00ff0000) >> 16);
    write[3] = (BYTE)( (address & 0x0000ff00) >>  8);
    write[4] = (BYTE)( (address & 0x000000ff));
    write[5] = size;
    memcpy(write+6, buff, size);
    WriteReport(write);
    }
// ------------------------------------------------------------------------------------
int wiimote::ParseInput (BYTE* buff)
    {
    int changed = 0;

    // lock our internal state (so RefreshState() is blocked until we're done
    EnterCriticalSection(&StateLock);

    switch(buff[0])
        {
        case IN_BUTTONS:
            DEEP_TRACE(_T(".. parsing buttons."));
            changed |= ParseButtons(buff);
            break;

        case IN_BUTTONS_ACCEL:
            DEEP_TRACE(_T(".. parsing buttons/accel."));
            changed |= ParseButtons(buff);
            if(!IsBalanceBoard())
                changed |= ParseAccel(buff);
            break;

        case IN_BUTTONS_ACCEL_EXT:
            DEEP_TRACE(_T(".. parsing extenion/accel."));
            changed |= ParseButtons(buff);
            changed |= ParseExtension(buff, 6);
            if(!IsBalanceBoard())
                changed |= ParseAccel(buff);
            break;

        case IN_BUTTONS_ACCEL_IR:
            DEEP_TRACE(_T(".. parsing ir/accel."));
            changed |= ParseButtons(buff);
            if(!IsBalanceBoard()) {
                changed |= ParseAccel(buff);
                changed |= ParseIR(buff);
                }
            break;

        case IN_BUTTONS_ACCEL_IR_EXT:
            DEEP_TRACE(_T(".. parsing ir/extenion/accel."));
            changed |= ParseButtons(buff);
            changed |= ParseExtension(buff, 16);
            if(!IsBalanceBoard()) {
                changed |= ParseAccel(buff);
                changed |= ParseIR     (buff);
                }
            break;

        case IN_BUTTONS_BALANCE_BOARD:
            DEEP_TRACE(_T(".. parsing buttson/balance."));
            changed |= ParseButtons(buff);
            changed |= ParseExtension(buff, 3);
            break;

        case IN_READADDRESS:
            DEEP_TRACE(_T(".. parsing read address."));
            changed |= ParseButtons    (buff);
            changed |= ParseReadAddress(buff);
            break;

        case IN_STATUS:
            DEEP_TRACE(_T(".. parsing status."));
            changed |= ParseStatus(buff);
            // show that we received the status report (used for output method
            //  detection during Connect())
            bStatusReceived = true;
            break;
        
        default:
            DEEP_TRACE(_T(".. ** unknown input ** (happens)."));
            ///_ASSERT(0);
            //Debug.WriteLine("Unknown report type: " + type.ToString());
            LeaveCriticalSection(&StateLock);
            return false;
        }

    // if we're recording and some state we care about has changed, insert it into
    //  the state history
    if(Recording.bEnabled && (changed & Recording.TriggerFlags))
        {
        DEEP_TRACE(_T(".. adding state to history"));
        state_event event;
        event.time_ms = timeGetTime();
        event.state   = *(wiimote_state*)this;
        Recording.StateHistory->push_back(event);
        }

    // for polling: show which state has changed since the last RefreshState()
    InternalChanged = (state_change_flags)(InternalChanged | changed);

    LeaveCriticalSection(&StateLock);

    // callbacks: call it (if set & state the app is interested in has changed)
    if(changed & CallbackTriggerFlags)
        {
        DEEP_TRACE(_T(".. calling state change callback"));
        ChangedNotifier((state_change_flags)changed, Internal);
        if(ChangedCallback)
            ChangedCallback(*this, (state_change_flags)changed, Internal);
        }
    
    DEEP_TRACE(_T(".. parse complete."));
    return true;
    }
// ------------------------------------------------------------------------------------
state_change_flags wiimote::RefreshState ()
    {
    // nothing changed since the last call?
    if(InternalChanged == NO_CHANGE)
        return NO_CHANGE;

    // copy the internal state to our public data members:
    //  synchronise the interal state with the read/parse thread (we don't want
    //   values changing during the copy)
    EnterCriticalSection(&StateLock);
    
    // remember which state changed since the last call
    state_change_flags changed = InternalChanged;
    
    // preserve the application-set deadzones (if any)
    joystick::deadzone nunchuk_deadzone      = Nunchuk.Joystick.DeadZone;
    joystick::deadzone classic_joyl_deadzone = ClassicController.JoystickL.DeadZone;
    joystick::deadzone classic_joyr_deadzone = ClassicController.JoystickR.DeadZone;
        
     // copy the internal state to the public one
    *(wiimote_state*)this = Internal;
    InternalChanged       = NO_CHANGE;
     
     // restore the application-set deadzones
    Nunchuk.Joystick.DeadZone            = nunchuk_deadzone;
    ClassicController.JoystickL.DeadZone = classic_joyl_deadzone;
    ClassicController.JoystickR.DeadZone = classic_joyr_deadzone;

    LeaveCriticalSection(&StateLock);
    
    return changed;
    }
// ------------------------------------------------------------------------------------
void wiimote::DetectMotionPlusExtensionAsync ()
    {
#ifdef _DEBUG
    TRACE(_T("(looking for motion plus)"));
#endif
    // show that we're expecting the result shortly
    MotionPlusDetectCount++;
    // MotionPLus reports at a different address than other extensions (until
    //  activated, when it maps itself into the usual extension registers), so
    //  try to detect it first:
    ReadAddress(REGISTER_MOTIONPLUS_DETECT, 6);
    }
// ------------------------------------------------------------------------------------
bool wiimote::EnableMotionPlus ()
    {
    _ASSERT(bMotionPlusDetected);
    if(!bMotionPlusDetected)
        return false;
    if(bMotionPlusEnabled)
        return true;

    TRACE(_T("Enabling Motion Plus:"));
    
    bMotionPlusExtension = false;
    bInitInProgress      = true;
    bEnablingMotionPlus  = true;

    // Initialize it:
    WriteData(REGISTER_MOTIONPLUS_INIT  , 0x55);
//  Sleep(50);
    // Enable it (this maps it to the standard extension port):
    WriteData(REGISTER_MOTIONPLUS_ENABLE, 0x04);
//  Sleep(50);
Sleep(500);
    return true;
    }
// ------------------------------------------------------------------------------------
bool wiimote::DisableMotionPlus ()
    {
    if(!bMotionPlusDetected || !bMotionPlusEnabled)
        return false;

    TRACE(_T("Disabling Motion Plus:"));

    // disable it (this makes standard extensions visible again)
    WriteData(REGISTER_EXTENSION_INIT1, 0x55);
    return true;
    }
// ------------------------------------------------------------------------------------
void wiimote::InitializeExtension ()
    {
    TRACE(_T("Initialising Extension."));
    // wibrew.org: The new way to initialize the extension is by writing 0x55 to
    //  0x(4)A400F0, then writing 0x00 to 0x(4)A400FB. It works on all extensions, and
    //  makes the extension type bytes unencrypted. This means that you no longer have
    //  to decrypt the extension bytes using the transform listed above. 
    bInitInProgress = true;
_ASSERT(Internal.bExtension);
    // only initialize if it's not a MotionPlus
    if(!bEnablingMotionPlus) {
        WriteData  (REGISTER_EXTENSION_INIT1, 0x55);
        WriteData  (REGISTER_EXTENSION_INIT2, 0x00);
        }
    else
        bEnablingMotionPlus = false;
    
    ReadAddress(REGISTER_EXTENSION_TYPE , 6);
    }
// ------------------------------------------------------------------------------------
int wiimote::ParseStatus (BYTE* buff)
    {
    // parse the buttons
    int changed = ParseButtons(buff);
            
    // get the battery level
    BYTE battery_raw = buff[6];
    if(Internal.BatteryRaw != battery_raw)
        changed |= BATTERY_CHANGED;
    Internal.BatteryRaw  = battery_raw;
    // it is estimated that ~200 is the maximum battery level
    Internal.BatteryPercent = battery_raw / 2;

    // there is also a flag that shows if the battery is nearly empty
    bool drained = buff[3] & 0x01;
    if(drained != bBatteryDrained)
        {
        bBatteryDrained = drained;
        if(drained)
            changed |= BATTERY_DRAINED;
        }

    // leds
    BYTE leds = buff[3] >> 4;
    if(leds != Internal.LED.Bits)
        changed |= LEDS_CHANGED;
    Internal.LED.Bits = leds;

    // don't handle extensions until a connection is complete
//  if(bConnectInProgress)
//      return changed;

    bool extension = ((buff[3] & 0x02) != 0);
//  TRACE(_T("(extension = %s)"), (extension? _T("TRUE") : _T("false")));

    if(extension != Internal.bExtension)
        {
        if(!Internal.bExtension)
            {
            TRACE(_T("Extension connected:"));
            Internal.bExtension = true;
            InitializeExtension();
            }
        else{
            TRACE(_T("Extension disconnected."));
            Internal.bExtension    = false;
            Internal.ExtensionType = wiimote_state::NONE;
            bMotionPlusEnabled     = false;
            bMotionPlusExtension   = false;
            bMotionPlusDetected    = false;
            bInitInProgress        = false;
            bEnablingMotionPlus    = false;
            changed               |= EXTENSION_DISCONNECTED;
            // renable reports
//          SetReportType(ReportType);
            }
        }
    
    return changed;
    }
// ------------------------------------------------------------------------------------
int wiimote::ParseButtons (BYTE* buff)
    {
    int changed = 0;
    
//  WORD bits = *(WORD*)(buff+1);
    WORD bits = *(WORD*)(buff+1) & Button.ALL;

    if(bits != Internal.Button.Bits)
        changed |= BUTTONS_CHANGED;
    Internal.Button.Bits = bits;
    
    return changed;
    }
// ------------------------------------------------------------------------------------
bool wiimote::EstimateOrientationFrom (wiimote_state::acceleration &accel)
    {
    // Orientation estimate from acceleration data (shared between wiimote and nunchuk)
    //  return true if the orientation was updated

    //  assume the controller is stationary if the acceleration vector is near
    //  1g for several updates (this may not always be correct)
    float length_sq = square(accel.X) + square(accel.Y) + square(accel.Z);

    // TODO: as I'm comparing _squared_ length, I really need different
    //        min/max epsilons...
    #define DOT(x1,y1,z1, x2,y2,z2) ((x1*x2) + (y1*y2) + (z1*z2))

    static const float epsilon = 0.2f;
    if((length_sq >= (1.f-epsilon)) && (length_sq <= (1.f+epsilon)))
        {
        if(++WiimoteNearGUpdates < 2)
            return false;
        
        // wiimote seems to be stationary:  normalize the current acceleration
        //  (ie. the assumed gravity vector)
        float inv_len = 1.f / sqrt(length_sq);
        float x = accel.X * inv_len;
        float y = accel.Y * inv_len;
        float z = accel.Z * inv_len;

        // copy the values
        accel.Orientation.X = x;
        accel.Orientation.Y = y;
        accel.Orientation.Z = z;

        // and extract pitch & roll from them:
        // (may not be optimal)
        float pitch = -asin(y)    * 57.2957795f;
//      float roll  =  asin(x)    * 57.2957795f;
        float roll  =  atan2(x,z) * 57.2957795f;
        if(z < 0) {
            pitch = (y < 0)?  180 - pitch : -180 - pitch;
            roll  = (x < 0)? -180 - roll  :  180 - roll;
            }

        accel.Orientation.Pitch = pitch;
        accel.Orientation.Roll  = roll;

        // show that we just updated orientation
        accel.Orientation.UpdateAge = 0;
#ifdef BEEP_ON_ORIENTATION_ESTIMATE
        Beep(2000, 1);
#endif
        return true; // updated
        }

    // not updated this time:
    WiimoteNearGUpdates = 0;
    // age the last orientation update
    accel.Orientation.UpdateAge++;
    return false;
    }
// ------------------------------------------------------------------------------------
void wiimote::ApplyJoystickDeadZones (wiimote_state::joystick &joy)
    {
    // apply the deadzones to each axis (if set)
    if((joy.DeadZone.X > 0.f) && (joy.DeadZone.X <= 1.f))
        {
        if(fabs(joy.X) <= joy.DeadZone.X)
            joy.X = 0;
        else{
            joy.X -= joy.DeadZone.X * sign(joy.X);
            joy.X /= 1.f - joy.DeadZone.X;
            }
        }
    if((joy.DeadZone.Y > 0.f) && (joy.DeadZone.Y <= 1.f))
        {
        if(fabs(joy.Y) <= joy.DeadZone.Y)
            joy.Y = 0;
        else{
            joy.Y -= joy.DeadZone.Y * sign(joy.Y);
            joy.Y /= 1.f - joy.DeadZone.Y;
            }
        }
    }
// ------------------------------------------------------------------------------------
int wiimote::ParseAccel (BYTE* buff)
    {
    int changed = 0;
    
    BYTE raw_x = buff[3];
    BYTE raw_y = buff[4];
    BYTE raw_z = buff[5];

    if((raw_x != Internal.Acceleration.RawX) ||
       (raw_y != Internal.Acceleration.RawY) ||
       (raw_z != Internal.Acceleration.RawZ))
       changed |= ACCEL_CHANGED;
    
    Internal.Acceleration.RawX = raw_x;
    Internal.Acceleration.RawY = raw_y;
    Internal.Acceleration.RawZ = raw_z;

    // avoid / 0.0 when calibration data hasn't arrived yet
    if(Internal.CalibrationInfo.X0)
        {
        Internal.Acceleration.X =
                    ((float)Internal.Acceleration.RawX  - Internal.CalibrationInfo.X0) / 
                    ((float)Internal.CalibrationInfo.XG - Internal.CalibrationInfo.X0);
        Internal.Acceleration.Y =
                    ((float)Internal.Acceleration.RawY  - Internal.CalibrationInfo.Y0) /
                    ((float)Internal.CalibrationInfo.YG - Internal.CalibrationInfo.Y0);
        Internal.Acceleration.Z =
                    ((float)Internal.Acceleration.RawZ  - Internal.CalibrationInfo.Z0) /
                    ((float)Internal.CalibrationInfo.ZG - Internal.CalibrationInfo.Z0);
        }
    else{
        Internal.Acceleration.X =
        Internal.Acceleration.Y =
        Internal.Acceleration.Z = 0.f;
        }

    // see if we can estimate the orientation from the current values
    if(EstimateOrientationFrom(Internal.Acceleration))
        changed |= ORIENTATION_CHANGED;
    
    return changed;
    }
// ------------------------------------------------------------------------------------
int wiimote::ParseIR (BYTE* buff)
    {
    if(Internal.IR.Mode == wiimote_state::ir::OFF)
        return NO_CHANGE;

    // avoid garbage values when the MotionPlus is enabled, but the app is
    //  still using the extended IR report type
    if(bMotionPlusEnabled && (Internal.IR.Mode == wiimote_state::ir::EXTENDED))
        return NO_CHANGE;

    // take a copy of the existing IR state (so we can detect changes)
    wiimote_state::ir prev_ir = Internal.IR;

    // only updates the other values if the dots are visible (so that the last
    //  valid values stay unmodified)
    switch(Internal.IR.Mode)
        {
        case wiimote_state::ir::BASIC:
            // 2 dots are encoded in 5 bytes, so read 2 at a time
            for(unsigned step=0; step<2; step++)
                {
                ir::dot &dot0 = Internal.IR.Dot[step*2  ];
                ir::dot &dot1 = Internal.IR.Dot[step*2+1];
                const unsigned offs = 6 + (step*5); // 5 bytes for 2 dots

                dot0.bVisible = !(buff[offs  ] == 0xff && buff[offs+1] == 0xff);
                dot1.bVisible = !(buff[offs+3] == 0xff && buff[offs+4] == 0xff);
            
                if(dot0.bVisible) {
                    dot0.RawX = buff[offs  ] | ((buff[offs+2] >> 4) & 0x03) << 8;;
                    dot0.RawY = buff[offs+1] | ((buff[offs+2] >> 6) & 0x03) << 8;;
                    dot0.X    = 1.f - (dot0.RawX / (float)wiimote_state::ir::MAX_RAW_X);
                    dot0.Y    =       (dot0.RawY / (float)wiimote_state::ir::MAX_RAW_Y);
                    }
                if(dot1.bVisible) {
                    dot1.RawX = buff[offs+3] | ((buff[offs+2] >> 0) & 0x03) << 8;
                    dot1.RawY = buff[offs+4] | ((buff[offs+2] >> 2) & 0x03) << 8;
                    dot1.X    = 1.f - (dot1.RawX / (float)wiimote_state::ir::MAX_RAW_X);
                    dot1.Y    =       (dot1.RawY / (float)wiimote_state::ir::MAX_RAW_Y);
                    }
                }
            break;
        
        case wiimote_state::ir::EXTENDED:
            // each dot is encoded into 3 bytes
            for(unsigned index=0; index<4; index++)
                {
                ir::dot &dot = Internal.IR.Dot[index];
                const unsigned offs = 6 + (index * 3);
            
                dot.bVisible = !(buff[offs  ]==0xff && buff[offs+1]==0xff &&
                               buff[offs+2]==0xff);
                if(dot.bVisible) {
                    dot.RawX = buff[offs  ] | ((buff[offs+2] >> 4) & 0x03) << 8;
                    dot.RawY = buff[offs+1] | ((buff[offs+2] >> 6) & 0x03) << 8;
                    dot.X    = 1.f - (dot.RawX / (float)wiimote_state::ir::MAX_RAW_X);
                    dot.Y    =       (dot.RawY / (float)wiimote_state::ir::MAX_RAW_Y);
                    dot.Size = buff[offs+2] & 0x0f;
                    }
                }
            break;

        case wiimote_state::ir::FULL:
            _ASSERT(0); // not supported yet;
            break;
        }

    return memcmp(&prev_ir, &Internal.IR, sizeof(Internal.IR))? IR_CHANGED : 0;
    }
// ------------------------------------------------------------------------------------
inline float wiimote::GetBalanceValue (short sensor, short min, short mid, short max)
    {
    if(max == mid || mid == min)
        return 0;

    float val = (sensor < mid)?
                    68.0f * ((float)(sensor - min) / (mid - min)) :
                    68.0f * ((float)(sensor - mid) / (max - mid)) + 68.0f;
    
    // divide by four (so that each sensor is correct)
    return val * 0.25f;
    }
// ------------------------------------------------------------------------------------
int wiimote::ParseExtension (BYTE *buff, unsigned offset)
    {
    int changed = 0;
    
    switch(Internal.ExtensionType)
        {
        case wiimote_state::NUNCHUK:
            {
            // buttons
            bool c = (buff[offset+5] & 0x02) == 0;
            bool z = (buff[offset+5] & 0x01) == 0;
            
            if((c != Internal.Nunchuk.C) || (z != Internal.Nunchuk.Z))
                changed |= NUNCHUK_BUTTONS_CHANGED;
            
            Internal.Nunchuk.C = c;
            Internal.Nunchuk.Z = z;

            // acceleration
            {
            wiimote_state::acceleration &accel = Internal.Nunchuk.Acceleration;
            
            BYTE raw_x = buff[offset+2];
            BYTE raw_y = buff[offset+3];
            BYTE raw_z = buff[offset+4];
            if((raw_x != accel.RawX) || (raw_y != accel.RawY) || (raw_z != accel.RawZ))
                changed |= NUNCHUK_ACCEL_CHANGED;

            accel.RawX = raw_x;
            accel.RawY = raw_y;
            accel.RawZ = raw_z;

            wiimote_state::nunchuk::calibration_info &calib =
                                                    Internal.Nunchuk.CalibrationInfo;
            accel.X = ((float)raw_x - calib.X0) / ((float)calib.XG - calib.X0);
            accel.Y = ((float)raw_y - calib.Y0) / ((float)calib.YG - calib.Y0);
            accel.Z = ((float)raw_z - calib.Z0) / ((float)calib.ZG - calib.Z0);

            // try to extract orientation from the accel:
            if(EstimateOrientationFrom(accel))
                changed |= NUNCHUK_ORIENTATION_CHANGED;
            }
            {
            // joystick:
            wiimote_state::joystick &joy = Internal.Nunchuk.Joystick;

            float raw_x = buff[offset+0];
            float raw_y = buff[offset+1];
            
            if((raw_x != joy.RawX) || (raw_y != joy.RawY))
                changed |= NUNCHUK_JOYSTICK_CHANGED;

            joy.RawX = raw_x;
            joy.RawY = raw_y;

            // apply the calibration data
            wiimote_state::nunchuk::calibration_info &calib =
                                                    Internal.Nunchuk.CalibrationInfo;
            if(Internal.Nunchuk.CalibrationInfo.MaxX != 0x00)
                joy.X = ((float)raw_x - calib.MidX) / ((float)calib.MaxX - calib.MinX);
            if(calib.MaxY != 0x00)
                joy.Y = ((float)raw_y - calib.MidY) / ((float)calib.MaxY - calib.MinY);

            // i prefer the outputs to range -1 - +1 (note this also affects the
            //  deadzone calculations)
            joy.X *= 2; joy.Y *= 2;

            // apply the public deadzones to the internal state (if set)
            joy.DeadZone = Nunchuk.Joystick.DeadZone;
            ApplyJoystickDeadZones(joy);
            }
            }
            break;
        
        case wiimote_state::CLASSIC:
        case wiimote_state::GH3_GHWT_GUITAR:
        case wiimote_state::GHWT_DRUMS:
            {
            // buttons:
            WORD bits = *(WORD*)(buff+offset+4);
            bits = ~bits; // need to invert bits since 0 is down, and 1 is up

            if(bits != Internal.ClassicController.Button.Bits)
                changed |= CLASSIC_BUTTONS_CHANGED;

            Internal.ClassicController.Button.Bits = bits;

            // joysticks:
            wiimote_state::joystick &joyL = Internal.ClassicController.JoystickL;
            wiimote_state::joystick &joyR = Internal.ClassicController.JoystickR;

            float l_raw_x = (float) (buff[offset+0] & 0x3f);
            float l_raw_y = (float) (buff[offset+1] & 0x3f);
            float r_raw_x = (float)((buff[offset+2]         >> 7) |
                                   ((buff[offset+1] & 0xc0) >> 5) |
                                   ((buff[offset+0] & 0xc0) >> 3));
            float r_raw_y = (float) (buff[offset+2] & 0x1f);

            if((joyL.RawX != l_raw_x) || (joyL.RawY != l_raw_y))
                changed |= CLASSIC_JOYSTICK_L_CHANGED;
            if((joyR.RawX != r_raw_x) || (joyR.RawY != r_raw_y))
                changed |= CLASSIC_JOYSTICK_R_CHANGED;

            joyL.RawX = l_raw_x; joyL.RawY = l_raw_y;
            joyR.RawX = r_raw_x; joyR.RawY = r_raw_y;

            // apply calibration
            wiimote_state::classic_controller::calibration_info &calib =
                                            Internal.ClassicController.CalibrationInfo;
            if(calib.MaxXL != 0x00)
                joyL.X = (joyL.RawX - calib.MidXL) / ((float)calib.MaxXL - calib.MinXL);
            if(calib.MaxYL != 0x00)
                joyL.Y = (joyL.RawY - calib.MidYL) / ((float)calib.MaxYL - calib.MinYL);
            if(calib.MaxXR != 0x00)
                joyR.X = (joyR.RawX - calib.MidXR) / ((float)calib.MaxXR - calib.MinXR);
            if(calib.MaxYR != 0x00)
                joyR.Y = (joyR.RawY - calib.MidYR) / ((float)calib.MaxYR - calib.MinYR);

            // i prefer the joystick outputs to range -1 - +1 (note this also affects
            //  the deadzone calculations)
            joyL.X *= 2; joyL.Y *= 2; joyR.X *= 2; joyR.Y *= 2;

            // apply the public deadzones to the internal state (if set)
            joyL.DeadZone = ClassicController.JoystickL.DeadZone;
            joyR.DeadZone = ClassicController.JoystickR.DeadZone;
            ApplyJoystickDeadZones(joyL);
            ApplyJoystickDeadZones(joyR);

            // triggers
            BYTE raw_trigger_l = ((buff[offset+2] & 0x60) >> 2) |
                                  (buff[offset+3]         >> 5);
            BYTE raw_trigger_r =   buff[offset+3] & 0x1f;
            
            if((raw_trigger_l != Internal.ClassicController.RawTriggerL) ||
               (raw_trigger_r != Internal.ClassicController.RawTriggerR))
               changed |= CLASSIC_TRIGGERS_CHANGED;
            
            Internal.ClassicController.RawTriggerL  = raw_trigger_l;
            Internal.ClassicController.RawTriggerR  = raw_trigger_r;

            if(calib.MaxTriggerL != 0x00)
                Internal.ClassicController.TriggerL =
                                     (float)Internal.ClassicController.RawTriggerL / 
                                    ((float)calib.MaxTriggerL - calib.MinTriggerL);
            if(calib.MaxTriggerR != 0x00)
                Internal.ClassicController.TriggerR =
                                     (float)Internal.ClassicController.RawTriggerR / 
                                    ((float)calib.MaxTriggerR - calib.MinTriggerR);
            }
            break;

        case BALANCE_BOARD:
            {
            wiimote_state::balance_board::sensors_raw prev_raw =
                                                        Internal.BalanceBoard.Raw;
            Internal.BalanceBoard.Raw.TopR    =
                        (short)((short)buff[offset+0] << 8 | buff[offset+1]);
            Internal.BalanceBoard.Raw.BottomR =
                        (short)((short)buff[offset+2] << 8 | buff[offset+3]);
            Internal.BalanceBoard.Raw.TopL    =
                        (short)((short)buff[offset+4] << 8 | buff[offset+5]);
            Internal.BalanceBoard.Raw.BottomL =
                        (short)((short)buff[offset+6] << 8 | buff[offset+7]);

            if((Internal.BalanceBoard.Raw.TopL    != prev_raw.TopL)    ||
               (Internal.BalanceBoard.Raw.TopR    != prev_raw.TopR)    ||
               (Internal.BalanceBoard.Raw.BottomL != prev_raw.BottomL) ||
               (Internal.BalanceBoard.Raw.BottomR != prev_raw.BottomR))
                changed |= BALANCE_WEIGHT_CHANGED;

            Internal.BalanceBoard.Kg.TopL    =
                GetBalanceValue(Internal.BalanceBoard.Raw.TopL,
                                Internal.BalanceBoard.CalibrationInfo.Kg0 .TopL,
                                Internal.BalanceBoard.CalibrationInfo.Kg17.TopL,
                                Internal.BalanceBoard.CalibrationInfo.Kg34.TopL);
            Internal.BalanceBoard.Kg.TopR    =
                GetBalanceValue(Internal.BalanceBoard.Raw.TopR,
                                Internal.BalanceBoard.CalibrationInfo.Kg0 .TopR,
                                Internal.BalanceBoard.CalibrationInfo.Kg17.TopR,
                                Internal.BalanceBoard.CalibrationInfo.Kg34.TopR);
            Internal.BalanceBoard.Kg.BottomL =
                GetBalanceValue(Internal.BalanceBoard.Raw.BottomL,
                                Internal.BalanceBoard.CalibrationInfo.Kg0 .BottomL,
                                Internal.BalanceBoard.CalibrationInfo.Kg17.BottomL,
                                Internal.BalanceBoard.CalibrationInfo.Kg34.BottomL);
            Internal.BalanceBoard.Kg.BottomR =
                GetBalanceValue(Internal.BalanceBoard.Raw.BottomR,
                                Internal.BalanceBoard.CalibrationInfo.Kg0 .BottomR,
                                Internal.BalanceBoard.CalibrationInfo.Kg17.BottomR,
                                Internal.BalanceBoard.CalibrationInfo.Kg34.BottomR);
            
            // uses these as the 'at rest' offsets? (immediately after Connect(),
            //  or if the app called CalibrateAtRest())
            if(bCalibrateAtRest) {
                bCalibrateAtRest = false;
                TRACE(_T(".. Auto-removing 'at rest' BBoard offsets."));
                Internal.BalanceBoard.AtRestKg = Internal.BalanceBoard.Kg;
                }

            // remove the 'at rest' offsets
            Internal.BalanceBoard.Kg.TopL    -= BalanceBoard.AtRestKg.TopL;
            Internal.BalanceBoard.Kg.TopR    -= BalanceBoard.AtRestKg.TopR;
            Internal.BalanceBoard.Kg.BottomL -= BalanceBoard.AtRestKg.BottomL;
            Internal.BalanceBoard.Kg.BottomR -= BalanceBoard.AtRestKg.BottomR;

            // compute the average
            Internal.BalanceBoard.Kg.Total    = Internal.BalanceBoard.Kg.TopL    +
                                                Internal.BalanceBoard.Kg.TopR    +
                                                Internal.BalanceBoard.Kg.BottomL +
                                                Internal.BalanceBoard.Kg.BottomR;
            // and convert to Lbs
            const float KG2LB = 2.20462262f;
            Internal.BalanceBoard.Lb          = Internal.BalanceBoard.Kg;
            Internal.BalanceBoard.Lb.TopL    *= KG2LB;
            Internal.BalanceBoard.Lb.TopR    *= KG2LB;
            Internal.BalanceBoard.Lb.BottomL *= KG2LB;
            Internal.BalanceBoard.Lb.BottomR *= KG2LB;
            Internal.BalanceBoard.Lb.Total   *= KG2LB;
            }
            break;

        case MOTION_PLUS:
            {
            bMotionPlusDetected = true;
            bMotionPlusEnabled  = true;

            short yaw   = ((unsigned short)buff[offset+3] & 0xFC)<<6 |
                           (unsigned short)buff[offset+0];
            short pitch = ((unsigned short)buff[offset+5] & 0xFC)<<6 |
                           (unsigned short)buff[offset+2];
            short roll  = ((unsigned short)buff[offset+4] & 0xFC)<<6 |
                           (unsigned short)buff[offset+1];

            // we get one set of bogus values when the MotionPlus is disconnected,
            //  so ignore them
            if((yaw != 0x3fff) || (pitch != 0x3fff) || (roll != 0x3fff))
                {
                wiimote_state::motion_plus::sensors_raw &raw = Internal.MotionPlus.Raw;
    
                if((raw.Yaw != yaw) || (raw.Pitch != pitch) || (raw.Roll  != roll))
                    changed |= MOTIONPLUS_SPEED_CHANGED;

                raw.Yaw   = yaw;
                raw.Pitch = pitch;
                raw.Roll  = roll;
    
                // convert to float values
                bool    yaw_slow = (buff[offset+3] & 0x2) == 0x2;
                bool  pitch_slow = (buff[offset+3] & 0x1) == 0x1;
                bool   roll_slow = (buff[offset+4] & 0x2) == 0x2;
                float y_scale    =   yaw_slow? 0.05f : 0.25f;
                float p_scale    = pitch_slow? 0.05f : 0.25f;
                float r_scale    =  roll_slow? 0.05f : 0.25f;
            
                Internal.MotionPlus.Speed.Yaw   = -(raw.Yaw   - 0x1F7F) * y_scale;
                Internal.MotionPlus.Speed.Pitch = -(raw.Pitch - 0x1F7F) * p_scale;
                Internal.MotionPlus.Speed.Roll  = -(raw.Roll  - 0x1F7F) * r_scale;
    
                // show if there's an extension plugged into the MotionPlus:
                bool extension = buff[offset+4] & 1;
                if(extension != bMotionPlusExtension)
                    {
                    if(extension) {
                        TRACE(_T(".. MotionPlus extension found."));
                        changed |= MOTIONPLUS_EXTENSION_CONNECTED;
                        }
                    else{
                        TRACE(_T(".. MotionPlus' extension disconnected."));
                        changed |= MOTIONPLUS_EXTENSION_DISCONNECTED;
                        }
                    }
                bMotionPlusExtension = extension;
                }
            // while we're getting data, the plus is obviously detected/enabled
//          bMotionPlusDetected = bMotionPlusEnabled = true;
            }
            break;
        }
    
    return changed;
    }
// ------------------------------------------------------------------------------------
int wiimote::ParseReadAddress (BYTE* buff)
    {
    // decode the address that was queried:
    int address = buff[4]<<8 | buff[5];
    int size    = buff[3] >> 4;
    int changed = 0;

    if((buff[3] & 0x08) != 0) {
        WARN(_T("error: read address not valid."));
        _ASSERT(0);
        return NO_CHANGE;
        }
    // address read failed (write-only)?
    else if((buff[3] & 0x07) != 0)
        {
        // this also happens when attempting to detect a non-existant MotionPlus
        if(MotionPlusDetectCount)
            {
            --MotionPlusDetectCount;
            if(Internal.ExtensionType == MOTION_PLUS)
                {
                if(bMotionPlusDetected)
                    TRACE(_T(".. MotionPlus removed."));
                bMotionPlusDetected  = false;
                bMotionPlusEnabled   = false;
                // the MotionPlus can sometimes get confused - initializing
                //  extenions fixes it:
//              if(address == 0xfa)
//                  InitializeExtension();
                }
            }
        else
            WARN(_T("error: attempt to read from write-only register 0x%X."), buff[3]);

        return NO_CHANGE;
        }

    // *NOTE*: this is a major (but convenient) hack!  The returned data only
    //          contains the lower two bytes of the address that was queried.
    //          as these don't collide between any of the addresses/registers
    //          we currently read, it's OK to match just those two bytes

    // skip the header
    buff += 6;

    switch(address)
        {
        case (REGISTER_CALIBRATION & 0xffff):
            {
            _ASSERT(size == 6);
            TRACE(_T(".. got wiimote calibration."));
            Internal.CalibrationInfo.X0 = buff[0];
            Internal.CalibrationInfo.Y0 = buff[1];
            Internal.CalibrationInfo.Z0 = buff[2];
            Internal.CalibrationInfo.XG = buff[4];
            Internal.CalibrationInfo.YG = buff[5];
            Internal.CalibrationInfo.ZG = buff[6];
            //changed |= CALIBRATION_CHANGED;   
            }
            break;
            
        // note: this covers both the normal extension and motion plus extension
        //        addresses (0x4a400fa / 0x4a600fa)
        case (REGISTER_EXTENSION_TYPE & 0xffff):
            {
            _ASSERT(size == 5);
            QWORD type = *(QWORD*)buff;

//          TRACE(_T("(found extension 0x%I64x)"), type);

            static const QWORD NUNCHUK             = 0x000020A40000ULL;
            static const QWORD CLASSIC             = 0x010120A40000ULL;
            static const QWORD GH3_GHWT_GUITAR     = 0x030120A40000ULL;
            static const QWORD GHWT_DRUMS          = 0x030120A40001ULL;
            static const QWORD BALANCE_BOARD       = 0x020420A40000ULL;
            static const QWORD MOTION_PLUS         = 0x050420A40000ULL;
            static const QWORD MOTION_PLUS_DETECT  = 0x050020a60000ULL;
            static const QWORD MOTION_PLUS_DETECT2 = 0x050420a60000ULL;
            static const QWORD PARTIALLY_INSERTED  = 0xffffffffffffULL;

            // MotionPlus: _before_ it's been activated
            if((type == MOTION_PLUS_DETECT) || (type == MOTION_PLUS_DETECT2))
                {
                if(!bMotionPlusDetected) {
                    TRACE(_T("Motion Plus detected!"));
                    changed |= MOTIONPLUS_DETECTED;
                    }
                bMotionPlusDetected = true;
                --MotionPlusDetectCount;
                break;
                }

            #define IF_TYPE(id) if(type == id) { \
                                    /* sometimes it comes in more than once */ \
                                    if(Internal.ExtensionType == wiimote_state::id)\
                                        break; \
                                    Internal.ExtensionType = wiimote_state::id;

            // MotionPlus: once it's activated & mapped to the standard ext. port
            IF_TYPE(MOTION_PLUS)
                TRACE(_T(".. Motion Plus!"));
                // and start a query for the calibration data
                ReadAddress(REGISTER_EXTENSION_CALIBRATION, 16);
                bMotionPlusDetected = true;
                }
            else IF_TYPE(NUNCHUK)
                TRACE(_T(".. Nunchuk!"));
                bMotionPlusEnabled = false;
                // and start a query for the calibration data
                ReadAddress(REGISTER_EXTENSION_CALIBRATION, 16);
                }
            else IF_TYPE(CLASSIC)
                TRACE(_T(".. Classic Controller!"));
                bMotionPlusEnabled = false;
                // and start a query for the calibration data
                ReadAddress(REGISTER_EXTENSION_CALIBRATION, 16);
                }
            else IF_TYPE(GH3_GHWT_GUITAR)
                // sometimes it comes in more than once?
                TRACE(_T(".. GH3/GHWT Guitar Controller!"));
                bMotionPlusEnabled = false;
                // and start a query for the calibration data
                ReadAddress(REGISTER_EXTENSION_CALIBRATION, 16);
                }
            else IF_TYPE(GHWT_DRUMS)
                TRACE(_T(".. GHWT Drums!"));
                bMotionPlusEnabled = false;
                // and start a query for the calibration data
                ReadAddress(REGISTER_EXTENSION_CALIBRATION, 16);
                }
            else IF_TYPE(BALANCE_BOARD)
                TRACE(_T(".. Balance Board!"));
                bMotionPlusEnabled = false;
                // and start a query for the calibration data
                ReadAddress(REGISTER_BALANCE_CALIBRATION, 24);
                }
            else if(type == PARTIALLY_INSERTED) {
                // sometimes it comes in more than once?
                if(Internal.ExtensionType == wiimote_state::PARTIALLY_INSERTED)
                    Sleep(50);
                TRACE(_T(".. partially inserted!"));
                bMotionPlusEnabled = false;
                Internal.ExtensionType = wiimote_state::PARTIALLY_INSERTED;
                changed |= EXTENSION_PARTIALLY_INSERTED;
                // try initializing the extension again by requesting another
                //  status report (this usually fixes it)
                Internal.bExtension = false;
                RequestStatusReport();
                }
            else{
                TRACE(_T("unknown extension controller found (0x%I64x)"), type);
                }
            }
            break;
        
        case (REGISTER_EXTENSION_CALIBRATION & 0xffff):
        case (REGISTER_BALANCE_CALIBRATION   & 0xffff):
            {
//          _ASSERT(((Internal.ExtensionType == BALANCE_BOARD) && (size == 31)) ||
//                  ((Internal.ExtensionType != BALANCE_BOARD) && (size == 15)));

            switch(Internal.ExtensionType)
                {
                case wiimote_state::NUNCHUK:
                    {
                    wiimote_state::nunchuk::calibration_info
                        &calib = Internal.Nunchuk.CalibrationInfo;

                    calib.X0   = buff[ 0];
                    calib.Y0   = buff[ 1];
                    calib.Z0   = buff[ 2];
                    calib.XG   = buff[ 4];
                    calib.YG   = buff[ 5];
                    calib.ZG   = buff[ 6];
                    calib.MaxX = buff[ 8];
                    calib.MinX = buff[ 9];
                    calib.MidX = buff[10];
                    calib.MaxY = buff[11];
                    calib.MinY = buff[12];
                    calib.MidY = buff[13];

                    changed |= NUNCHUK_CONNECTED;//|NUNCHUK_CALIBRATION_CHANGED;
                    // reenable reports
//                  SetReportType(ReportType);
                    }
                    break;
                
                case wiimote_state::CLASSIC:
                case wiimote_state::GH3_GHWT_GUITAR:
                case wiimote_state::GHWT_DRUMS:
                    {
                    wiimote_state::classic_controller::calibration_info
                        &calib = Internal.ClassicController.CalibrationInfo;
                    
                    calib.MaxXL = buff[ 0] >> 2;
                    calib.MinXL = buff[ 1] >> 2;
                    calib.MidXL = buff[ 2] >> 2;
                    calib.MaxYL = buff[ 3] >> 2;
                    calib.MinYL = buff[ 4] >> 2;
                    calib.MidYL = buff[ 5] >> 2;
                    calib.MaxXR = buff[ 6] >> 3;
                    calib.MinXR = buff[ 7] >> 3;
                    calib.MidXR = buff[ 8] >> 3;
                    calib.MaxYR = buff[ 9] >> 3;
                    calib.MinYR = buff[10] >> 3;
                    calib.MidYR = buff[11] >> 3;
                    // this doesn't seem right...
                    //  calib.MinTriggerL = buff[12] >> 3;
                    //  calib.MaxTriggerL = buff[14] >> 3;
                    //  calib.MinTriggerR = buff[13] >> 3;
                    //  calib.MaxTriggerR = buff[15] >> 3;
                    calib.MinTriggerL = 0;
                    calib.MaxTriggerL = 31;
                    calib.MinTriggerR = 0;
                    calib.MaxTriggerR = 31;

                    changed |= CLASSIC_CONNECTED;//|CLASSIC_CALIBRATION_CHANGED;
                    // reenable reports
//                  SetReportType(ReportType);
                    }
                    break;

                case BALANCE_BOARD:
                    {
                    // first part, 0 & 17kg calibration values
                    wiimote_state::balance_board::calibration_info
                        &calib = Internal.BalanceBoard.CalibrationInfo;

                    calib.Kg0 .TopR    = (short)((short)buff[0] << 8 | buff[1]);
                    calib.Kg0 .BottomR = (short)((short)buff[2] << 8 | buff[3]);
                    calib.Kg0 .TopL    = (short)((short)buff[4] << 8 | buff[5]);
                    calib.Kg0 .BottomL = (short)((short)buff[6] << 8 | buff[7]);

                    calib.Kg17.TopR    = (short)((short)buff[8] << 8 | buff[9]);
                    calib.Kg17.BottomR = (short)((short)buff[10] << 8 | buff[11]);
                    calib.Kg17.TopL    = (short)((short)buff[12] << 8 | buff[13]);
                    calib.Kg17.BottomL = (short)((short)buff[14] << 8 | buff[15]);

                    // 2nd part is scanned above
                    }
                    break;

                case MOTION_PLUS:
                    {
                    // TODO: not known how the calibration values work
                    changed |= MOTIONPLUS_ENABLED;
                    bMotionPlusEnabled = true;
                    bInitInProgress    = false;
                    // reenable reports
//                  SetReportType(ReportType);
                    }
                    break;
                }
            case 0x34:
                {
                if(Internal.ExtensionType == BALANCE_BOARD)
                    {
                    wiimote_state::balance_board::calibration_info
                        &calib = Internal.BalanceBoard.CalibrationInfo;

                    // 2nd part of the balance board calibration,
                    //  34kg calibration values
                    calib.Kg34.TopR    = (short)((short)buff[0] << 8 | buff[1]);
                    calib.Kg34.BottomR = (short)((short)buff[2] << 8 | buff[3]);
                    calib.Kg34.TopL    = (short)((short)buff[4] << 8 | buff[5]);
                    calib.Kg34.BottomL = (short)((short)buff[6] << 8 | buff[7]);
                        
                    changed |= BALANCE_CONNECTED;
                    // reenable reports
                    SetReportType(IN_BUTTONS_BALANCE_BOARD);
                    }
                // else unknown what these are for
                }
            bInitInProgress = false;
            }
            break;

        default:
//          _ASSERT(0); // shouldn't happen
            break;
        }
    
    return changed;
    }
// ------------------------------------------------------------------------------------
void wiimote::ReadCalibration ()
    {
    TRACE(_T("Requestion wiimote calibration:"));
    // this appears to change the report type to 0x31
    ReadAddress(REGISTER_CALIBRATION, 7);
    }
// ------------------------------------------------------------------------------------
void wiimote::EnableIR (wiimote_state::ir::mode mode)
    {
    Internal.IR.Mode = mode;

    BYTE buff [REPORT_LENGTH] = {0};
    buff[0] = OUT_IR;
    buff[1] = 0x04 | GetRumbleBit();
    WriteReport(buff);

    memset(buff, 0, REPORT_LENGTH);
    buff[0] = OUT_IR2;
    buff[1] = 0x04 | GetRumbleBit();
    WriteReport(buff);

    static const BYTE ir_sens1[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00,
                                    0xc0};
    static const BYTE ir_sens2[] = {0x40, 0x00};

    WriteData(REGISTER_IR, 0x08);
    Sleep(25);  // wait a little to make IR more reliable (for some)
    WriteData(REGISTER_IR_SENSITIVITY_1, sizeof(ir_sens1), ir_sens1);
    WriteData(REGISTER_IR_SENSITIVITY_2, sizeof(ir_sens2), ir_sens2);
    WriteData(REGISTER_IR_MODE, (BYTE)mode);
    }
// ------------------------------------------------------------------------------------
void wiimote::DisableIR ()
    {
    Internal.IR.Mode = wiimote_state::ir::OFF;

    BYTE buff [REPORT_LENGTH] = {0};
    buff[0] = OUT_IR;
    buff[1] = GetRumbleBit();
    WriteReport(buff);

    memset(buff, 0, REPORT_LENGTH);
    buff[0] = OUT_IR2;
    buff[1] = GetRumbleBit();
    WriteReport(buff);
    }
// ------------------------------------------------------------------------------------
unsigned __stdcall wiimote::HIDwriteThreadfunc (void* param)
    {
    _ASSERT(param);
    TRACE(_T("(starting HID write thread)"));
    wiimote &remote = *(wiimote*)param;

    while(remote.Handle != INVALID_HANDLE_VALUE)
        {
        // try to write the oldest entry in the queue
#ifdef USE_DYNAMIC_HIDQUEUE
        if(!remote.HIDwriteQueue.empty())
#else
        if(!remote.HID.IsEmpty())
#endif
            {
#ifdef BEEP_DEBUG_WRITES
            Beep(1500,1);
#endif
            EnterCriticalSection(&remote.HIDwriteQueueLock);
#ifdef USE_DYNAMIC_HIDQUEUE
             BYTE *buff = remote.HIDwriteQueue.front();
             _ASSERT(buff);
#else
             BYTE *buff = remote.HID.Queue[remote.HID.ReadIndex].Report;
#endif
            LeaveCriticalSection(&remote.HIDwriteQueueLock);

            if(!_HidD_SetOutputReport(remote.Handle, buff, REPORT_LENGTH))
                {
                DWORD err = GetLastError();
if(err==ERROR_BUSY)
TRACE(_T("**** HID WRITE: BUSY ****"));
else if(err == ERROR_NOT_READY)
TRACE(_T("**** HID WRITE: NOT READY ****"));

                if((err != ERROR_BUSY)  &&   // "the requested resource is in use"
                   (err != ERROR_NOT_READY)) // "the device is not ready"
                    {
                    if(err == ERROR_NOT_SUPPORTED) {
                        WARN(_T("BT Stack doesn't suport HID writes!"));
                        goto remove_entry;
                        }
                    else{
                        DEEP_TRACE(_T("HID write failed (err %u)! - "), err);
                        // if this worked previously, the connection was probably lost
                        if(remote.IsConnected())
                            remote.bConnectionLost = true;
                        }
                    //_T("aborting write thread"), err);
                    //return 911;
                    }
                }
            else{
remove_entry:
                EnterCriticalSection(&remote.HIDwriteQueueLock);
#ifdef USE_DYNAMIC_HIDQUEUE
                 remote.HIDwriteQueue.pop();
                 delete[] buff;
#else
                 remote.HID.ReadIndex++;
                 remote.HID.ReadIndex &= (hid::MAX_QUEUE_ENTRIES-1);
#endif
                LeaveCriticalSection(&remote.HIDwriteQueueLock);
                }
            }
        Sleep(1);
        }

    TRACE(_T("ending HID write thread"));
    return 0;
    }
// ------------------------------------------------------------------------------------
bool wiimote::WriteReport (BYTE *buff)
    {
#ifdef BEEP_DEBUG_WRITES
    Beep(2000,1);
#endif

#ifdef _DEBUG
    #define DEEP_TRACE_TYPE(type)   case OUT_##type: DEEP_TRACE(_T("WriteReport: ")\
                                                                _T(#type)); break
    switch(buff[0])
        {
        DEEP_TRACE_TYPE(NONE);
        DEEP_TRACE_TYPE(LEDs);
        DEEP_TRACE_TYPE(TYPE);
        DEEP_TRACE_TYPE(IR);
        DEEP_TRACE_TYPE(SPEAKER_ENABLE);
        DEEP_TRACE_TYPE(STATUS);
        DEEP_TRACE_TYPE(WRITEMEMORY);
        DEEP_TRACE_TYPE(READMEMORY);
        DEEP_TRACE_TYPE(SPEAKER_DATA);
        DEEP_TRACE_TYPE(SPEAKER_MUTE);
        DEEP_TRACE_TYPE(IR2);
        default:
            TRACE(_T("WriteReport: type [%02x][%02x]"), buff[1], buff[2]);
        }
#endif

    if(bUseHIDwrite)
        {
        // HidD_SetOutputReport: +: works on MS Bluetooth stacks (WriteFile doesn't).
        //                       -: is synchronous, so make it async
        if(!HIDwriteThread)
            {
            HIDwriteThread = (HANDLE)_beginthreadex(NULL, 0, HIDwriteThreadfunc,
                                                    this, 0, NULL);
            _ASSERT(HIDwriteThread);
            if(!HIDwriteThread) {
                WARN(_T("couldn't create HID write thread!"));
                return false;
                }
            SetThreadPriority(HIDwriteThread, WORKER_THREAD_PRIORITY);
            }

        // insert the write request into the thread's queue
#ifdef USE_DYNAMIC_HIDQUEUE
        EnterCriticalSection(&HIDwriteQueueLock);
         BYTE *buff_copy = new BYTE[REPORT_LENGTH];
#else
        // allocate the HID write queue once
        if(!HID.Queue && !HID.Allocate())
            return false;

        EnterCriticalSection(&HIDwriteQueueLock);
         BYTE *buff_copy = HID.Queue[HID.WriteIndex].Report;
#endif
         memcpy(buff_copy, buff, REPORT_LENGTH);

#ifdef USE_DYNAMIC_HIDQUEUE
         HIDwriteQueue.push(buff_copy);
#else
         HID.WriteIndex++;
         HID.WriteIndex &= (HID.MAX_QUEUE_ENTRIES-1);

         // check if the fixed report queue has overflown:
         //  if this ASSERT triggers, the HID write queue (that stores reports
         //   for asynchronous output by HIDwriteThreadfunc) has overflown.
         //  this can happen if the connection with the wiimote has been lost
         //   and in that case is harmless.
         //
         //  if it happens during normal operation though you need to increase
         //   hid::MAX_QUEUE_ENTRIES to the next power-of-2 (see comments)
         //   _and_ email me the working setting so I can update the next release
         _ASSERT(HID.WriteIndex != HID.ReadIndex);
#endif
        LeaveCriticalSection(&HIDwriteQueueLock);
        return true;
        }

    // WriteFile:
    DWORD written;
    if(!WriteFile(Handle, buff, REPORT_LENGTH, &written, &Overlapped))
        {
        DWORD error = GetLastError();
        if(error != ERROR_IO_PENDING) {
            TRACE(_T("WriteFile failed, err: %u!"), error);
            // if it worked previously, assume we lost the connection
            if(IsConnected())
                bConnectionLost = true;
#ifndef USE_DYNAMIC_HIDQUEUE
            HID.Deallocate();
#endif
            return false;
            }
        }
    return true;
    }
// ------------------------------------------------------------------------------------
// experimental speaker support:
// ------------------------------------------------------------------------------------
bool wiimote::MuteSpeaker (bool on)
    {
    _ASSERT(IsConnected());
    if(!IsConnected())
        return false;

    if(Internal.Speaker.bMuted == on)
        return true;

    if(on) TRACE(_T("muting speaker."  ));
    else   TRACE(_T("unmuting speaker."));

    BYTE buff [REPORT_LENGTH] = {0};
    buff[0] = OUT_SPEAKER_MUTE;
    buff[1] = (on? 0x04 : 0x00) | GetRumbleBit();
    if(!WriteReport(buff))
        return false;
    Sleep(1);
    Internal.Speaker.bMuted = on;
    return true;
    }
// ------------------------------------------------------------------------------------
bool wiimote::EnableSpeaker (bool on)
    {
    _ASSERT(IsConnected());
    if(!IsConnected())
        return false;

    if(Internal.Speaker.bEnabled == on)
        return true;

    if(on) TRACE(_T("enabling speaker.")); else TRACE(_T("disabling speaker."));

    BYTE buff [REPORT_LENGTH] = {0};
    buff[0] = OUT_SPEAKER_ENABLE;
    buff[1] = (on? 0x04 : 0x00) | GetRumbleBit();
    if(!WriteReport(buff))
        return false;

    if(!on) {
        Internal.Speaker.Freq   = FREQ_NONE;
        Internal.Speaker.Volume = 0;
        MuteSpeaker(true);
        }

    Internal.Speaker.bEnabled = on;
    return true;
    }
// ------------------------------------------------------------------------------------
#ifdef TR4 // TEMP, ignore
 extern int hzinc;
#endif
// ------------------------------------------------------------------------------------
unsigned __stdcall wiimote::SampleStreamThreadfunc (void* param)
    {
    TRACE(_T("(starting sample thread)"));
    // sends a simple square wave sample stream
    wiimote &remote = *(wiimote*)param;
    
    static BYTE squarewave_report[REPORT_LENGTH] =
        { OUT_SPEAKER_DATA, 20<<3, 0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,
                                   0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3, };
    static BYTE sample_report [REPORT_LENGTH] = 
        { OUT_SPEAKER_DATA, 0 };

    bool           last_playing    = false;
    DWORD          frame           = 0;
    DWORD          frame_start     = 0;
    unsigned       total_samples   = 0;
    unsigned       sample_index    = 0;
    wiimote_sample *current_sample = NULL;
    
    // TODO: duration!!
    while(remote.IsConnected())
        {
        bool playing = remote.IsPlayingAudio();
        
        if(!playing)
            Sleep(1);
        else{
            const unsigned freq_hz  = FreqLookup[remote.Internal.Speaker.Freq];
#ifdef TR4
            const float    frame_ms = 1000 / ((freq_hz+hzinc) / 40.f); // 20bytes = 40 samples per write
#else
            const float    frame_ms = 1000 / (freq_hz         / 40.f); // 20bytes = 40 samples per write
#endif

            // has the sample just changed?
            bool sample_changed = (current_sample != remote.CurrentSample);
            current_sample      = (wiimote_sample*)remote.CurrentSample;

// (attempts to minimise glitches, doesn't seem to help though)
//#define FIRSTFRAME_IS_SILENT  // send all-zero for first frame

#ifdef FIRSTFRAME_IS_SILENT
            bool silent_frame = false;
#endif
            if(!last_playing || sample_changed) {
                frame         = 0;
                frame_start   = timeGetTime();
                total_samples = current_sample? current_sample->length : 0;
                sample_index  = 0;
#ifdef FIRSTFRAME_IS_SILENT
                silent_frame  = true;
#endif
                }

            // are we streaming a sample?
            if(current_sample)
                {
                if(sample_index < current_sample->length)
                    {
                    // (remember that samples are 4bit, ie. 2 per byte)
                    unsigned samples_left   = (current_sample->length - sample_index);
                    unsigned report_samples = min(samples_left, (unsigned)40);
                    // round the entries up to the nearest multiple of 2
                    unsigned report_entries = (report_samples+1) >> 1;
                    
                    sample_report[1] = (BYTE)((report_entries<<3) |
                                              remote.GetRumbleBit());
#ifdef FIRSTFRAME_IS_SILENT
                    if(silent_frame) {
                        // send all-zeroes
                        for(unsigned index=0; index<report_entries; index++)
                            sample_report[2+index] = 0;
                        remote.WriteReport(sample_report);
                        }
                    else
#endif
                    {
                        for(unsigned index=0; index<report_entries; index++)
                            sample_report[2+index] =
                                    current_sample->samples[(sample_index>>1)+index];
                        remote.WriteReport(sample_report);
                        sample_index += report_samples;
                        }
                    }
                else{
                    // we reached the sample end
                    remote.CurrentSample           = NULL;
                    current_sample                 = NULL;
                    remote.Internal.Speaker.Freq   = FREQ_NONE;
                    remote.Internal.Speaker.Volume = 0;
                    }
                }
            // no, a squarewave
            else{
                squarewave_report[1] = (20<<3) | remote.GetRumbleBit();
                remote.WriteReport(squarewave_report);
#if 0
                // verify that we're sending at the correct rate (we are)
                DWORD elapsed          = (timeGetTime()-frame_start);
                unsigned total_samples = frame * 40;
                float elapsed_secs     = elapsed / 1000.f;
                float sent_persec      = total_samples / elapsed_secs;
#endif
                }

            frame++;

            // send the first two buffers immediately? (attempts to lessen startup
            //  startup glitches by assuming we're filling a small sample
            //  (or general input) buffer on the wiimote) - doesn't seem to help
//          if(frame > 2) {
                while((timeGetTime()-frame_start) < (unsigned)(frame*frame_ms))
                    Sleep(1);
//              }
            }

        last_playing = playing;
        }
    
    TRACE(_T("(ending sample thread)"));
    return 0;
    }
// ------------------------------------------------------------------------------------
bool wiimote::Load16bitMonoSampleWAV (const TCHAR* filepath, wiimote_sample &out)
    {
    // converts unsigned 16bit mono .wav audio data to the 4bit ADPCM variant
    //  used by the Wiimote (at least the closest match so far), and returns
    //  the data in a BYTE array (caller must delete[] it when no longer needed):
    memset(&out, 0, sizeof(out));

    TRACE(_T("Loading '%s'"), filepath);

    FILE *file;
#if (_MSC_VER >= 1400) // VC 2005+
    _tfopen_s(&file, filepath, _T("rb"));
#else
    file = _tfopen(filepath, _T("rb"));
#endif
    _ASSERT(file);
    if(!file) {
        WARN(_T("Couldn't open '%s"), filepath);
        return false;
        }

    // parse the .wav file
    struct riff_chunkheader {
        char  ckID [4];
        DWORD ckSize;
        char  formType [4];
        };
    struct chunk_header {
        char  ckID [4];
        DWORD ckSize;
        };
    union {
        WAVEFORMATEX         x;
        WAVEFORMATEXTENSIBLE xe;
        } wf = {0};

    riff_chunkheader riff_chunkheader;
    chunk_header     chunk_header;
    speaker_freq     freq = FREQ_NONE;

    #define READ(data)          if(fread(&data, sizeof(data), 1, file) != 1) { \
                                    TRACE(_T(".wav file corrupt"));            \
                                    fclose(file);                              \
                                    return false;                              \
                                    }
    #define READ_SIZE(ptr,size) if(fread(ptr, size, 1, file) != 1) {           \
                                    TRACE(_T(".wav file corrupt"));            \
                                    fclose(file);                              \
                                    return false;                              \
                                    }
    // read the riff chunk header
    READ(riff_chunkheader);

    // valid RIFF file?
    _ASSERT(!strncmp(riff_chunkheader.ckID, "RIFF", 4));
    if(strncmp(riff_chunkheader.ckID, "RIFF", 4))
        goto unsupported; // nope
    // valid WAV variant?
    _ASSERT(!strncmp(riff_chunkheader.formType, "WAVE", 4));
    if(strncmp(riff_chunkheader.formType, "WAVE", 4))
        goto unsupported; // nope

    // find the format & data chunks
    while(1)
        {
        READ(chunk_header);
        
        if(!strncmp(chunk_header.ckID, "fmt ", 4))
            {
            // not a valid .wav file?
            if(chunk_header.ckSize < 16 ||
               chunk_header.ckSize > sizeof(WAVEFORMATEXTENSIBLE))
                goto unsupported;

            READ_SIZE((BYTE*)&wf.x, chunk_header.ckSize);

            // now we know it's true wav file
            bool extensible = (wf.x.wFormatTag == WAVE_FORMAT_EXTENSIBLE);
            int format      = extensible? wf.xe.SubFormat.Data1 :
                                          wf.x .wFormatTag;
            // must be uncompressed PCM (the format comparisons also work on
            //  the 'extensible' header, even though they're named differently)
            if(format != WAVE_FORMAT_PCM) {
                TRACE(_T(".. not uncompressed PCM"));
                goto unsupported;
                }

            // must be mono, 16bit
            if((wf.x.nChannels != 1) || (wf.x.wBitsPerSample != 16)) {
                TRACE(_T(".. %d bit, %d channel%s"), wf.x.wBitsPerSample,
                                                     wf.x.nChannels,
                                                    (wf.x.nChannels>1? _T("s"):_T("")));
                goto unsupported;
                }

            // must be _near_ a supported speaker frequency range (but allow some
            //  tolerance, especially as the speaker freq values aren't final yet):
            unsigned       sample_freq = wf.x.nSamplesPerSec;
            const unsigned epsilon     = 100; // for now
            
            for(unsigned index=1; index<ARRAY_ENTRIES(FreqLookup); index++)
                {
                if((sample_freq+epsilon) >= FreqLookup[index] &&
                   (sample_freq-epsilon) <= FreqLookup[index]) {
                    freq = (speaker_freq)index;
                    TRACE(_T(".. using speaker freq %u"), FreqLookup[index]);
                    break;
                    }
                }
            if(freq == FREQ_NONE) {
                WARN(_T("Couldn't (loosely) match .wav samplerate %u Hz to speaker"),
                     sample_freq);
                goto unsupported;
                }
            }
        else if(!strncmp(chunk_header.ckID, "data", 4))
            {
            // make sure we got a valid fmt chunk first
            if(!wf.x.nBlockAlign)
                goto corrupt_file;

            // grab the data
            unsigned total_samples = chunk_header.ckSize / wf.x.nBlockAlign;
            if(total_samples == 0)
                goto corrupt_file;
            
            short *samples = new short[total_samples];
            size_t read = fread(samples, 2, total_samples, file);
            fclose(file);
            if(read != total_samples)
                {
                if(read == 0) {
                    delete[] samples;
                    goto corrupt_file;
                    }
                // got a different number, but use them anyway
                WARN(_T("found %s .wav audio data than expected (%u/%u samples)"),
                    ((read < total_samples)? _T("less") : _T("more")),
                    read, total_samples);

                total_samples = read;
                }

            // and convert them
            bool res = Convert16bitMonoSamples(samples, true, total_samples, freq,
                                               out);
            delete[] samples;
            return res;
            }
        else{
            // unknown chunk, skip its data
            DWORD chunk_bytes = (chunk_header.ckSize + 1) & ~1L;
            if(fseek(file, chunk_bytes, SEEK_CUR))
                goto corrupt_file;
            }
        }

corrupt_file:
    WARN(_T(".wav file is corrupt"));
    fclose(file);
    return false;

unsupported:
    WARN(_T(".wav file format not supported (must be mono 16bit PCM)"));
    fclose(file);
    return false;
    }
// ------------------------------------------------------------------------------------
bool wiimote::Load16BitMonoSampleRAW (const TCHAR*   filepath,
                                      bool           _signed,
                                      speaker_freq   freq,
                                      wiimote_sample &out)
    {
    // converts (.wav style) unsigned 16bit mono raw data to the 4bit ADPCM variant
    //  used by the Wiimote, and returns the data in a BYTE array (caller must
    //  delete[] it when no longer needed):
    memset(&out, 0, sizeof(out));

    // get the length of the file
    struct _stat file_info;
    if(_tstat(filepath, &file_info)) {
        WARN(_T("couldn't get filesize for '%s'"), filepath);
        return false;
        }
    
    DWORD len = file_info.st_size;
    _ASSERT(len);
    if(!len) {
        WARN(_T("zero-size sample file '%s'"), filepath);
        return false;
        }

    unsigned total_samples = (len+1) / 2; // round up just in case file is corrupt
    // allocate a buffer to hold the samples to convert
    short *samples = new short[total_samples]; 
    _ASSERT(samples);
    if(!samples) {
        TRACE(_T("Couldn't open '%s"), filepath);
        return false;
        }

    // load them
    FILE *file;
    bool res;
#if (_MSC_VER >= 1400) // VC 2005+
    _tfopen_s(&file, filepath, _T("rb"));
#else
    file = _tfopen(filepath, _T("rb"));
#endif
    _ASSERT(file);
    if(!file) {
        TRACE(_T("Couldn't open '%s"), filepath);
        goto error;
        }

    res = (fread(samples, 1, len, file) == len);
    fclose(file);
    if(!res) {
        WARN(_T("Couldn't load file '%s'"), filepath);
        goto error;
        }

    // and convert them
    res = Convert16bitMonoSamples(samples, _signed, total_samples, freq, out);
    delete[] samples;
    return res;

error:
    delete[] samples;
    return false;
    }
// ------------------------------------------------------------------------------------
bool wiimote::Convert16bitMonoSamples (const short*   samples,
                                       bool           _signed,
                                       DWORD          length,
                                       speaker_freq   freq,
                                       wiimote_sample &out)
    {
    // converts 16bit mono sample data to the native 4bit format used by the Wiimote,
    //  and returns the data in a BYTE array (caller must delete[] when no
    //  longer needed):
    memset(&out, 0, sizeof(0));

    _ASSERT(samples && length);
    if(!samples || !length)
        return false;

    // allocate the output buffer
    out.samples = new BYTE[length];
    _ASSERT(out.samples);
    if(!out.samples)
        return false;

    // clear it
    memset(out.samples, 0, length);
    out.length = length;
    out.freq   = freq;

    // ADPCM code, adapted from
    //  http://www.wiindows.org/index.php/Talk:Wiimote#Input.2FOutput_Reports
    static const int index_table[16] = {  -1,  -1,  -1,  -1,   2,   4,   6,   8,
                                          -1,  -1,  -1,  -1,   2,   4,   6,   8 };
    static const int diff_table [16] = {   1,   3,   5,   7,   9,  11,  13,  15,
                                          -1,  -3,  -5,  -7,  -9, -11, -13,  15 };
    static const int step_scale [16] = { 230, 230, 230, 230, 307, 409, 512, 614,
                                         230, 230, 230, 230, 307, 409, 512, 614 };
    // Encode to ADPCM, on initialization set adpcm_prev_value to 0 and adpcm_step
    //  to 127 (these variables must be preserved across reports)
    int adpcm_prev_value = 0;
    int adpcm_step       = 127;

    for(size_t i=0; i<length; i++)
        {
        // convert to 16bit signed
        int value = samples[i];// (8bit) << 8);// | samples[i]; // dither it?
        if(!_signed)
            value -= 32768;
        // encode:
        int  diff = value - adpcm_prev_value;
        BYTE encoded_val = 0;
        if(diff < 0) {
            encoded_val |= 8;
            diff = -diff;
            }
        diff = (diff << 2) / adpcm_step;
        if (diff > 7)
            diff = 7;
        encoded_val |= diff;
        adpcm_prev_value += ((adpcm_step * diff_table[encoded_val]) / 8);
        if(adpcm_prev_value  >  0x7fff)
            adpcm_prev_value =  0x7fff;
        if(adpcm_prev_value  < -0x8000)
            adpcm_prev_value = -0x8000;
        adpcm_step = (adpcm_step * step_scale[encoded_val]) >> 8;
        if(adpcm_step < 127)
            adpcm_step = 127;
        if(adpcm_step > 24567)
            adpcm_step = 24567;
        if(i & 1)
            out.samples[i>>1] |= encoded_val;
        else
            out.samples[i>>1] |= encoded_val << 4;
        }

    return true;
    }
// ------------------------------------------------------------------------------------
bool wiimote::PlaySample (const wiimote_sample &sample, BYTE volume, 
                          speaker_freq freq_override)
    {
    _ASSERT(IsConnected());
    if(!IsConnected())
        return false;

    speaker_freq freq = freq_override? freq_override : sample.freq;

    TRACE(_T("playing sample."));
    EnableSpeaker(true);
    MuteSpeaker  (true);

#if 0
    // combine everything into one write - faster, seems to work?
    BYTE bytes[9] = { 0x00, 0x00, 0x00, 10+freq, vol, 0x00, 0x00, 0x01, 0x01 };
    WriteData(0x04a20001, sizeof(bytes), bytes);
#else
    // Write 0x01 to register 0x04a20009 
    WriteData(0x04a20009, 0x01);
    // Write 0x08 to register 0x04a20001 
    WriteData(0x04a20001, 0x08);
    // Write 7-byte configuration to registers 0x04a20001-0x04a20008 
    BYTE bytes[7] = { 0x00, 0x00, 0x00, 10+(BYTE)freq, volume, 0x00, 0x00 };
    WriteData(0x04a20001, sizeof(bytes), bytes);
    // + Write 0x01 to register 0x04a20008 
    WriteData(0x04a20008, 0x01);
#endif

    Internal.Speaker.Freq   = freq;
    Internal.Speaker.Volume = volume;
    CurrentSample           = &sample;

    MuteSpeaker(false);

    return StartSampleThread();
    }
// ------------------------------------------------------------------------------------
bool wiimote::StartSampleThread ()
    {
    if(SampleThread)
        return true;

    SampleThread = (HANDLE)_beginthreadex(NULL, 0, SampleStreamThreadfunc,
                                          this, 0, NULL);
    _ASSERT(SampleThread);
    if(!SampleThread) {
        WARN(_T("couldn't create sample thread!"));
        MuteSpeaker  (true);
        EnableSpeaker(false);   
        return false;
        }
    SetThreadPriority(SampleThread, WORKER_THREAD_PRIORITY);
    return true;
    }
// ------------------------------------------------------------------------------------
bool wiimote::PlaySquareWave (speaker_freq freq, BYTE volume)
    {
    _ASSERT(IsConnected());
    if(!IsConnected())
        return false;

    // if we're already playing a sample, stop it first
    if(IsPlayingSample())
        CurrentSample = NULL;
    // if we're already playing a square wave at this freq and volume, return
    else if(IsPlayingAudio() && (Internal.Speaker.Freq   == freq) &&
                                (Internal.Speaker.Volume == volume))
        return true;

    TRACE(_T("playing square wave."));
    // stop playing samples
    CurrentSample = 0;

    EnableSpeaker(true);
    MuteSpeaker  (true);

#if 0
    // combined everything into one write - much faster, seems to work?
    BYTE bytes[9] = { 0x00, 0x00, 0x00, freq, volume, 0x00, 0x00, 0x01, 0x1 };
    WriteData(0x04a20001, sizeof(bytes), bytes);
#else
    // write 0x01 to register 0xa20009 
    WriteData(0x04a20009, 0x01);
    // write 0x08 to register 0xa20001 
    WriteData(0x04a20001, 0x08);
    // write default sound mode (4bit ADPCM, we assume) 7-byte configuration
    //  to registers 0xa20001-0xa20008 
    BYTE bytes[7] = { 0x00, 0x00, 0x00, 10+(BYTE)freq, volume, 0x00, 0x00 };
    WriteData(0x04a20001, sizeof(bytes), bytes);
    // write 0x01 to register 0xa20008 
    WriteData(0x04a20008, 0x01);
#endif

    Internal.Speaker.Freq   = freq;
    Internal.Speaker.Volume = volume;

    MuteSpeaker(false);
    return StartSampleThread();
    }
// ------------------------------------------------------------------------------------
void wiimote::RecordState (state_history      &events_out,
                           unsigned           max_time_ms,
                           state_change_flags change_trigger)
    {
    // user being naughty?
    if(Recording.bEnabled)
        StopRecording();

    // clear the list
    if(!events_out.empty())
        events_out.clear();

    // start recording 
    Recording.StateHistory = &events_out;
    Recording.StartTimeMS  = timeGetTime();
    Recording.EndTimeMS    = Recording.StartTimeMS + max_time_ms;
    Recording.TriggerFlags = change_trigger;
    // as this call happens outside the read/parse thread, set the boolean
    //  which will enable reocrding last, so that all params are in place.
    // TODO: * stricly speaking this only works on VC2005+ or better, as it
    //         automatically places a memory barrier on volatile variables - earlier/
    //         other compilers may reorder the assignments!). *
    Recording.bEnabled     = true;
    }
// ------------------------------------------------------------------------------------
void wiimote::StopRecording ()
    {
    if(!Recording.bEnabled)
        return;

    Recording.bEnabled = false;
    // make sure the read/parse thread has time to notice the change (else it might
    //  still write one more state to the list)
    Sleep(10); // too much?
    }
// ------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------
tadas_AT_dailyda_DOT_com	ViewVC Help
Powered by ViewVC 1.1.8