satellite/neuromanager/MultiChannelData.cpp

/* --------------------------------------------------------------------- */
/* NeuroManager - A spike train analysis tool                            */
/* Copyright (c) 2005-2006 RIKEN, Japan. All rights reserved.            */
/* http://satellite.sourceforge.jp/                                      */
/* --------------------------------------------------------------------- */
/* This program is free software; you can redistribute it and/or         */
/* modify it under the terms of the GNU General Public License           */
/* as published by the Free Software Foundation; either version 2        */
/* of the License, or (at your option) any later version.                */
/*                                                                       */
/* This program is distributed in the hope that it will be useful,       */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of        */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         */
/* GNU General Public License for more details.                          */
/*                                                                       */
/* You should have received a copy of the GNU General Public License     */
/* along with this program; see the file COPYING.txt. If not, write      */
/* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth      */
/* Floor, Boston, MA 02110-1301, USA.                                    */
/* --------------------------------------------------------------------- */

/* $Id: MultiChannelData.cpp,v 1.12 2006/02/02 07:33:27 orrisroot Exp $ */

// MultiChannelData.cpp : implementation of the CMultiChannelData class
//

#include "stdafx.h"
#include "MultiChannelData.h"

#include <math.h>

#define   MULTICHANNELDATA_MUTEX  "CMultiChannelData_Mutex"


CMultiChannelData::CMultiChannelData()
{
        InitValues();
        // create mutex
        m_pMutex = new CMutex( FALSE, MULTICHANNELDATA_MUTEX );
}

CMultiChannelData::~CMultiChannelData()
{
        if ( m_bIsMapped )
        {
                UnmappingBinaryFile();
        }
        // delete mutex
        delete m_pMutex;
        InitValues();
}

void CMultiChannelData::InitValues()
{
        // user defined value
        m_qwYRangeCalcPoint = 200000;
        // data infomation
        m_strDataFile = _T( "" );
        m_dSamplingRate = 0.0;
        m_uiChannelNumber = 0;
        m_qwLength = 0;
        m_uiBitLength = 0;
        m_bByteSwap = FALSE;
        m_dwaOffset.RemoveAll();
        m_daGain.RemoveAll();
        m_dYAxisRange.RemoveAll();

        // for performance tuning
        m_uiAttachedChannel = 0;
        m_dAttachedGain = 0.0;

        // for file mapping
        m_bIsMapped = FALSE;
        m_dwMapSizeHigh = 0;
        m_dwMapSizeLow = 0;
        m_hDataFile = NULL;
        m_hMapping = NULL;
        m_pMappingView = NULL;
        m_pMutex = NULL;

        m_dwMapViewOffsetHigh = 0;
        m_dwMapViewOffsetLow = 0;
        m_sizetMapViewPageCurrent = 0;
        m_sizetMapViewPageMax = 0;
        m_sizetMapViewSize = 0;
        m_sizetMapViewSizeLastPage = 0;
        m_sizetMapViewSizePage = 0;
        m_sizetMapViewSizeLimit = 134217728; /* max 128MB - 1024*1024*128 */

}

void CMultiChannelData::CalcYAxisRange()
{
        ASSERT( m_bIsMapped );
        double d, max;
        QWORD calclen = ( m_qwYRangeCalcPoint < m_qwLength ) ? m_qwYRangeCalcPoint : m_qwLength ;
        m_dYAxisRange.RemoveAll();
        // lock mutex
        m_pMutex->Lock();
        for ( UINT ch = 0; ch < m_uiChannelNumber; ch++ )
        {
                max = 0.0;
                m_uiAttachedChannel = ch;
                m_dAttachedGain = ( double ) m_daGain.GetAt( ch );
                for ( QWORD i = 0; i < calclen; i++ )
                {
                        d = fabs( _getdata( i ) );
                        if ( max < d )
                                max = d;
                }
                m_dYAxisRange.Add( max );
                m_uiAttachedChannel = 0;
                m_dAttachedGain = 0.0;
        }
        // unlock mutex
        m_pMutex->Unlock();
}

double CMultiChannelData::GetYAxisRange( UINT ch )
{
        ASSERT( m_bIsMapped );
        return ( double ) m_dYAxisRange.GetAt( ch );
}

void CMultiChannelData::SwapData( char *data, int siz )
{
        int i;
        char c;
        int half = siz / 2;
        int j = siz - 1;
        for ( i = 0; i < half; i++ )
        {
                c = data[ i ];
                data[ i ] = data[ j - i ];
                data[ j - i ] = c;
        }
}

double CMultiChannelData::_getdata( QWORD pos )
{
        double ret = 0.0;
        QWORD dataOffset = pos * m_uiChannelNumber + m_uiAttachedChannel;
        QWORD rawOffset = dataOffset * m_uiBitLength;
        SIZE_T newPage = ( SIZE_T ) ( rawOffset / m_sizetMapViewSizePage );
        if ( newPage != m_sizetMapViewPageCurrent )
        {
                // move mapping page
                SIZE_T newSize;
                if ( newPage == m_sizetMapViewPageMax )
                        newSize = m_sizetMapViewSizeLastPage;
                else
                        newSize = m_sizetMapViewSizePage;
                SIZE_T newOffset = newPage * m_sizetMapViewSizePage;
                DWORD newOffsetHigh = HIDWORD( newOffset );
                DWORD newOffsetLow = LODWORD( newOffset );
                // close mapping view handle
                ::UnmapViewOfFile( m_pMappingView );
                // map view
                m_pMappingView = ( LPBYTE ) ::MapViewOfFile( m_hMapping, FILE_MAP_READ,
                                 newOffsetHigh, newOffsetLow, newSize );
                if ( m_pMappingView == NULL )
                {
                        CString str;
                        str.Format( "Fatal Error : %s %d", __FILE__, __LINE__ );
                        AfxMessageBox( str, MB_OK );
                        // TODO: exit
                }
                m_dwMapViewOffsetHigh = newOffsetHigh;
                m_dwMapViewOffsetLow = newOffsetLow;
                m_sizetMapViewSize = newSize;
                m_sizetMapViewPageCurrent = newPage;
        }
        if ( m_sizetMapViewPageCurrent != 0 )
        {
                QWORD fix = MAKEQWORD( m_dwMapViewOffsetLow, m_dwMapViewOffsetHigh ) / m_uiBitLength;
                dataOffset -= fix;
        }
        switch ( m_uiBitLength )
        {
        case 2:
                {
                        short * sptr = ( short* ) m_pMappingView;
                        short sd = sptr[ dataOffset ];
                        if ( m_bByteSwap )
                                SwapData( ( char* ) & sd, 2 );
                        ret = m_dAttachedGain * ( double ) sd;
                }
                break;
        case 4:
                {
                        int *iptr = ( int* ) m_pMappingView;
                        int id = iptr[ dataOffset ];
                        if ( m_bByteSwap )
                                SwapData( ( char* ) & id, 4 );
                        ret = m_dAttachedGain * ( double ) id;
                }
                break;
        case 8:
                {
                        double *dptr = ( double* ) m_pMappingView;
                        double dd = dptr[ dataOffset ];
                        if ( m_bByteSwap )
                                SwapData( ( char* ) & dd, 8 );
                        ret = m_dAttachedGain * dd;
                }
                break;
        default:
                break;
        }
        return ret;
}

void CMultiChannelData::AttachData( UINT ch )
{
        // lock mutex
        m_pMutex->Lock();
        m_uiAttachedChannel = ch;
        m_dAttachedGain = ( double ) m_daGain.GetAt( ch );
}

void CMultiChannelData::DetachData()
{
        m_uiAttachedChannel = 0;
        m_dAttachedGain = 0.0;
        // unlock mutex
        m_pMutex->Unlock();
}

double CMultiChannelData::GetData( QWORD pos )
{
        ASSERT( m_bIsMapped );
        return _getdata( pos );
}

double CMultiChannelData::GetPosTime( QWORD pos ) const
{
        ASSERT( m_bIsMapped );
        return ( double ) pos / m_dSamplingRate;
}


void CMultiChannelData::PrintDataInfo()
{
        CString str = FormatDataInfo();
        MessageBox( NULL, str, _T( "data information" ), MB_OK );
}


CString CMultiChannelData::FormatDataInfo()
{
        CString str, tmp;
        tmp.Format( _T( "is Mapped    : %s\n" ), ( m_bIsMapped ? _T( "TRUE" ) : _T( "FALSE" ) ) );
        str = tmp;
        tmp.Format( _T( "Samping Rate : %f\n" ), m_dSamplingRate );
        str += tmp;
        tmp.Format( _T( "Channel No.  : %u\n" ), m_uiChannelNumber );
        str += tmp;
        tmp.Format( _T( "Data Length  : %I64d\n" ), m_qwLength );
        str += tmp;
        INT_PTR size = m_dwaOffset.GetSize();
        for ( INT_PTR i = 0; i < size; i++ )
        {
                tmp.Format( _T( "Data Offset[%d] : %d\n" ), i, m_dwaOffset.GetAt( i ) );
                str += tmp;
        }
        tmp.Format( _T( "Bit Length   : %d\n" ), m_uiBitLength );
        str += tmp;
        tmp.Format( _T( "Byte Swap    : %s\n" ), ( m_bByteSwap ? _T( "TRUE" ) : _T( "FALSE" ) ) );
        str += tmp;
        return str;
}

BOOL CMultiChannelData::MappingBinaryFile()
{
        // lock mutex
        m_pMutex->Lock();
        // error check
        if ( m_strDataFile.IsEmpty() )
        {
                m_pMutex->Unlock();
                return FALSE;
        }
        if ( m_bIsMapped )
        {
                // unlock mutex
                m_pMutex->Unlock();
                return FALSE;
        }
        if ( m_uiBitLength == 0 )
        {
                // unlock mutex
                m_pMutex->Unlock();
                return FALSE;
        }
        // file open
        m_hDataFile = ::CreateFile( m_strDataFile, GENERIC_READ,
                                    0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
        if ( m_hDataFile == INVALID_HANDLE_VALUE )
        {
                m_hDataFile = NULL;
                // unlock mutex
                m_pMutex->Unlock();
                return FALSE;
        }
        BY_HANDLE_FILE_INFORMATION bhfi;
        if ( !GetFileInformationByHandle( m_hDataFile, &bhfi ) )
        {
                ::CloseHandle( m_hDataFile );
                m_hDataFile = NULL;
                // unlock mutex
                m_pMutex->Unlock();
                return FALSE;
        }
        m_dwMapSizeHigh = bhfi.nFileSizeHigh;
        m_dwMapSizeLow = bhfi.nFileSizeLow;
        // create file mapping object
        m_hMapping = ::CreateFileMapping( m_hDataFile, NULL, PAGE_READONLY,
                                          m_dwMapSizeHigh, m_dwMapSizeLow, NULL );
        if ( m_hMapping == NULL )
        {
                ::CloseHandle( m_hDataFile );
                m_hDataFile = NULL;
                // unlock mutex
                m_pMutex->Unlock();
                return FALSE;
        }
        // calcurate block size of mapping view memory
        SIZE_T nFileSize = ( ( SIZE_T ) m_dwMapSizeHigh << 32 ) + m_dwMapSizeLow;
        m_sizetMapViewPageMax = nFileSize / m_sizetMapViewSizeLimit;
        m_sizetMapViewSizeLastPage = nFileSize % m_sizetMapViewSizeLimit;
        if ( m_sizetMapViewPageMax == 0 )
                m_sizetMapViewSizePage = m_dwMapSizeLow;
        else
                m_sizetMapViewSizePage = m_sizetMapViewSizeLimit;
        m_sizetMapViewPageCurrent = 0;

        // map file
        m_pMappingView = ( LPBYTE ) ::MapViewOfFile( m_hMapping, FILE_MAP_READ,
                         m_dwMapViewOffsetHigh, m_dwMapViewOffsetLow, m_sizetMapViewSizePage );
        if ( m_pMappingView == NULL )
        {
                ::UnmapViewOfFile( m_hMapping );
                m_hMapping = NULL;
                m_dwMapSizeHigh = 0;
                m_dwMapSizeLow = 0;
                m_dwMapViewOffsetHigh = 0;
                m_dwMapViewOffsetLow = 0;
                m_sizetMapViewPageCurrent = 0;
                m_sizetMapViewPageMax = 0;
                m_sizetMapViewSize = 0;
                m_sizetMapViewSizeLastPage = 0;
                m_sizetMapViewSizePage = 0;
                ::CloseHandle( m_hDataFile );
                m_hDataFile = NULL;
                // unlock mutex
                m_pMutex->Unlock();
                return FALSE;
        }
        // set mapping status
        m_bIsMapped = TRUE;
        // unlock mutex
        m_pMutex->Unlock();
        return TRUE;
}

BOOL CMultiChannelData::UnmappingBinaryFile()
{
        // lock mutex
        m_pMutex->Lock();
        if ( !m_bIsMapped )
        {
                // unlock mutex
                m_pMutex->Unlock();
                return FALSE;
        }
        // unmap file
        ::UnmapViewOfFile( m_pMappingView );
        m_pMappingView = NULL;
        // close file mapping object
        ::CloseHandle( m_hMapping );
        m_hMapping = NULL;
        m_dwMapSizeHigh = 0;
        m_dwMapSizeLow = 0;
        m_dwMapViewOffsetHigh = 0;
        m_dwMapViewOffsetLow = 0;
        m_sizetMapViewPageCurrent = 0;
        m_sizetMapViewPageMax = 0;
        m_sizetMapViewSize = 0;
        m_sizetMapViewSizeLastPage = 0;
        m_sizetMapViewSizePage = 0;
        // close file
        ::CloseHandle( m_hDataFile );
        m_hDataFile = NULL;
        // unset mapping status
        m_bIsMapped = FALSE;
        // unlock mutex
        m_pMutex->Unlock();
        return TRUE;
}