예제 #1
0
파일: Device.cpp 프로젝트: uri247/wdk80
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::OnD0Exit
//
// This method is called when a device leaves the system
//
// Parameters: 
//      pWdfDevice - pointer to a device object
//
// 
//
/////////////////////////////////////////////////////////////////////////
HRESULT CMyDevice::OnD0Exit(
        _In_ IWDFDevice* pWdfDevice,
        _In_ WDF_POWER_DEVICE_STATE newState
        )
{
    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Entry");

    UNREFERENCED_PARAMETER(pWdfDevice);
    UNREFERENCED_PARAMETER(newState);

    HRESULT hr = S_OK;

    hr = EnterProcessing(PROCESSING_IPNPCALLBACK);

    if (SUCCEEDED(hr))
    {
        if( SUCCEEDED(hr) && NULL != m_pSensorManager)
        {
            hr = m_pSensorManager->Stop(newState);
        }

    } // processing in progress

    ExitProcessing(PROCESSING_IPNPCALLBACK);

    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Exit, hr = %!HRESULT!", hr);

    return hr;
}
예제 #2
0
 //modify by QP on 2k8-4-7
//add two parameters 
//int dis; int cri; for distance function and criteria function seperately
TRAININGSET CheckParameters(char *TSName, char *CBName, char *PAName, 
char *InName, int Minclus,int Maxclus, int ow) {
  TRAININGSET TS;
  
  /* input training set doesn't exist */
  if (!ExistFile(TSName)) 
  {
    ErrorMessage("\nERROR: Input training set doesn't exist: "
        "%s\n\n", TSName);
    ExitProcessing(FATAL_ERROR);
  }
    
  /* result codebook file exists and we are told not to overwrite */
  if (ExistFile(CBName) && !ow) 
  {
    ErrorMessage("\nERROR: Result codebook already exists: "
        "%s\n\n", CBName);
    ExitProcessing(FATAL_ERROR);
  }

  /* result partitioning file exists and we are told not to overwrite */
  if (*PAName && ExistFile(PAName) && !ow) 
  {
    ErrorMessage("\nERROR: Result partitioning already exists: "
        "%s\n\n", PAName);
    ExitProcessing(FATAL_ERROR);
  }
  
  /* initial codebook / partitioning doesn't exist */
  if (*InName && !DetermineFileName(InName))
  {
    ErrorMessage("\nERROR: Initial codebook/partitioning doesn't exist: %s\n\n", InName);
    ExitProcessing(FATAL_ERROR);
  }
   //add by QP on 2k8-4-7
  //verify whether Max is bigger than min; make sure the range is ok
    if (Maxclus < Minclus ) 
	{
		ErrorMessage("Bad range: %i < %i.\n", Maxclus, Minclus);
		ExitProcessing(FATAL_ERROR);
    } 
  
  ReadTrainingSet(TSName, &TS);

 
  //add by QP on 2k7-11-7  
  //the size of training set should be at least more than min codebook
  /* result codebook cannot contain more vectors than training set */
  if (BookSize(&TS) < Minclus)
  {
    ErrorMessage("\nERROR: Number of vectors in training set ");
    ErrorMessage("(%d) < Min number of clusters ", BookSize(&TS));
    ErrorMessage("(%d%d)!\n\n", Minclus, Maxclus);
    FreeCodebook(&TS);
    ExitProcessing(FATAL_ERROR);
  }
  
  return TS;
}  /* CheckParameters() */
예제 #3
0
char* KMeansInfo(void)
{
  char* p;
  int len;
  
  len = strlen(ProgName)+strlen(VersionNumber)+strlen(LastUpdated)+4;  
  p   = (char*) malloc(len*sizeof(char));
  
  if (!p) 
  {
    ErrorMessage("ERROR: Allocating memory failed!\n");
    ExitProcessing(FATAL_ERROR);
  }
  
  sprintf(p, "%s\t%s\t%s", ProgName, VersionNumber, LastUpdated);
  
  return p;
}  /* KMeansInfo() */
예제 #4
0
파일: Device.cpp 프로젝트: uri247/wdk80
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::OnD0Entry
//
// This method is called after a new device enters the system
//
// Parameters:
//      pWdfDevice - pointer to a device object
// 
//
/////////////////////////////////////////////////////////////////////////
HRESULT CMyDevice::OnD0Entry(
        _In_ IWDFDevice* pWdfDevice,
        _In_ WDF_POWER_DEVICE_STATE previousState
        )
{
    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Entry");
    UNREFERENCED_PARAMETER(pWdfDevice);
    UNREFERENCED_PARAMETER(previousState);

    HRESULT hr = S_OK;

    hr = EnterProcessing(PROCESSING_IPNPCALLBACK);

    if (SUCCEEDED(hr) 
        && (previousState == WdfPowerDeviceD3 || previousState == WdfPowerDeviceD3Final))
    {
        if( NULL != m_pSensorManager 
            && NULL != m_pSensorManager->m_pSensorDDI)
        {
            if (TRUE == m_pSensorManager->m_pSensorDDI->m_fDeviceIdle)
            {
                hr = m_pSensorManager->m_pSensorDDI->InitSensorDevice(m_pSensorManager->m_spWdfDevice);
            }

            if (!SUCCEEDED(hr))
            {
                hr = E_UNEXPECTED;
                Trace(TRACE_LEVEL_ERROR, "Unable to re-initialize sensor device, hr = %!HRESULT!", hr);
            }
            else
            {
                m_pSensorManager->m_pSensorDDI->OnDeviceReconnect();
            }
        }
    } // processing in progress

    ExitProcessing(PROCESSING_IPNPCALLBACK);

    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Exit, hr = %!HRESULT!", hr);

    return hr;
}
예제 #5
0
파일: Queue.cpp 프로젝트: 340211173/Driver
/////////////////////////////////////////////////////////////////////////
//
// CMyQueue::OnDeviceIoControl
//
// This method is called when an IOCTL is sent to the device
//
// Parameters:
//      pQueue            - pointer to an IO queue
//      pRequest          - pointer to an IO request
//      ControlCode       - The IOCTL to process
//      InputBufferSizeInBytes - the size of the input buffer
//      OutputBufferSizeInBytes - the size of the output buffer
//
/////////////////////////////////////////////////////////////////////////
STDMETHODIMP_ (void) CMyQueue::OnDeviceIoControl(
    _In_ IWDFIoQueue*     pQueue,
    _In_ IWDFIoRequest*   pRequest,
    _In_ ULONG            ControlCode,
         SIZE_T           InputBufferSizeInBytes,
         SIZE_T           OutputBufferSizeInBytes
    )
{
    UNREFERENCED_PARAMETER(pQueue);
    UNREFERENCED_PARAMETER(InputBufferSizeInBytes);
    UNREFERENCED_PARAMETER(OutputBufferSizeInBytes);

    //Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Entry");
    
    DWORD dwWritten = 0;

    if( IS_WPD_IOCTL( ControlCode ) )
    {
        if (FAILED(EnterProcessing(PROCESSING_IQUEUECALLBACKDEVICEIOCONTROL)))
        {
            // Unsupported request
            pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
        }
        else
        {
            m_pParentDevice->ProcessIoControl(  pQueue,
                                                pRequest,
                                                ControlCode,
                                                InputBufferSizeInBytes,
                                                OutputBufferSizeInBytes,
                                                &dwWritten);
        } // processing in progress

        ExitProcessing(PROCESSING_IQUEUECALLBACKDEVICEIOCONTROL);
    }
    else
    {
        // Unsupported request
        pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
    }

}
예제 #6
0
파일: Device.cpp 프로젝트: uri247/wdk80
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::OnSelfManagedIoFlush
//
//  Called by UMDF to flush the device for a device's self-managed
//  I/O operations.
//
// Parameters:
//      pWdfDevice - pointer to an IWDFDevice object representing the
//      device
//
// Return Values:
//
/////////////////////////////////////////////////////////////////////////
VOID CMyDevice::OnSelfManagedIoFlush(
        _In_ IWDFDevice* pWdfDevice
        )
{
    UNREFERENCED_PARAMETER(pWdfDevice);
    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Entry");

    HRESULT hr = EnterProcessing(PROCESSING_IPNPCALLBACKSELFMANAGEDIO);

    if (SUCCEEDED(hr))
    {
        if (nullptr != m_spQueue)
        {
            Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Purging queue");
            m_spQueue->PurgeSynchronously();
        }
    }

    ExitProcessing(PROCESSING_IPNPCALLBACKSELFMANAGEDIO);

    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Exit, hr = %!HRESULT!", hr);
}
예제 #7
0
파일: Device.cpp 프로젝트: uri247/wdk80
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::OnCleanupFile
//
// This method is called when the file handle to the device is closed
//
// Parameters:
//      pWdfFile - pointer to a file object
//
/////////////////////////////////////////////////////////////////////////
VOID CMyDevice::OnCleanupFile(
            _In_ IWDFFile* pWdfFile
            )
{
    //Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Entry");
    HRESULT hr = S_OK;

    hr = EnterProcessing(PROCESSING_IFILECALLBACKCLEANUP);

    if (SUCCEEDED(hr))
    {
        if (NULL != m_pSensorManager)
        {
            m_pSensorManager->CleanupFile(pWdfFile);
        }

    } // processing in progress

    ExitProcessing(PROCESSING_IFILECALLBACKCLEANUP);

    return;
}
예제 #8
0
파일: Device.cpp 프로젝트: uri247/wdk80
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::OnSelfManagedIoSuspend
//
//  Called by UMDF to suspend a device's self-managed I/O operations.
//
//  All outstanding I/O must be completed.  The queue is stopped
//  to flush out in progress requests.  The queue is restarted and
//  the driver continues to get I/O, but the m_fDeviceActive flag is
//  set to false so that the hardware will not be accessed.
//
// Parameters:
//      pWdfDevice - pointer to an IWDFDevice object representing the
//      device
//
// Return Values:
//      S_OK: success
//
/////////////////////////////////////////////////////////////////////////
HRESULT CMyDevice::OnSelfManagedIoSuspend(
        _In_ IWDFDevice* pWdfDevice
        )
{
    UNREFERENCED_PARAMETER(pWdfDevice);
    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Entry");

    HRESULT hr = EnterProcessing(PROCESSING_IPNPCALLBACKSELFMANAGEDIO);

    if (SUCCEEDED(hr))
    {
        if (nullptr != m_pSensorManager)
        {
            Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Hardware is now not available");
            m_pSensorManager->m_fDeviceActive = false;
        }

        if (nullptr != m_spQueue)
        {
            Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Flushing queue of running requests");
            // TODO If all hardware requests are not guaranteed to complete within 1 second then
            // the queue should be stopped and all pending hardweare requests canceled
            //m_spQueue->Stop(nullptr); // Uncomment this line if the hardware requests need to be canceled
            // As noted above, cancel all pending hardware requests here to allow all ISensorDriver:: callbacks to complete

            m_spQueue->StopSynchronously();

            // NOTE Any asynchronous work that accesses the hardware should be stopped

            m_spQueue->Start();
        }
    }

    ExitProcessing(PROCESSING_IPNPCALLBACKSELFMANAGEDIO);

    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Exit, hr = %!HRESULT!", hr);
    return hr;
}
예제 #9
0
파일: Device.cpp 프로젝트: uri247/wdk80
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::OnSelfManagedIoRestart
//
//  Called by UMDF to restart a device's self-managed I/O operations.
//
// Parameters:
//      pWdfDevice - pointer to an IWDFDevice object representing the
//      device
//
// Return Values:
//      S_OK: success
//
/////////////////////////////////////////////////////////////////////////
HRESULT CMyDevice::OnSelfManagedIoRestart(
        _In_ IWDFDevice* pWdfDevice
        )
{
    UNREFERENCED_PARAMETER(pWdfDevice);
    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Entry");

    HRESULT hr = EnterProcessing(PROCESSING_IPNPCALLBACKSELFMANAGEDIO);

    if (SUCCEEDED(hr))
    {
        if (nullptr != m_pSensorManager)
        {
            Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Hardware is now available");
            m_pSensorManager->m_fDeviceActive = true;
        }
    }

    ExitProcessing(PROCESSING_IPNPCALLBACKSELFMANAGEDIO);

    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Exit, hr = %!HRESULT!", hr);
    return hr;
}
예제 #10
0
파일: Device.cpp 프로젝트: uri247/wdk80
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::OnPrepareHardware
//
//  Called by UMDF to prepare the hardware for use. In our case
//  we create the SensorDDI object and initialize the Sensor Class Extension
//
// Parameters:
//      pWdfDevice - pointer to an IWDFDevice object representing the
//      device
//
// Return Values:
//      S_OK: success
//
/////////////////////////////////////////////////////////////////////////
HRESULT CMyDevice::OnPrepareHardware(
        _In_ IWDFDevice* pWdfDevice
        )
{
    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Entry");

    HRESULT hr = (NULL != pWdfDevice) ? S_OK : E_UNEXPECTED;


    if (SUCCEEDED(hr))
    {
        hr = EnterProcessing(PROCESSING_IPNPCALLBACKHARDWARE);

        if (SUCCEEDED(hr))
        {
            if( NULL != pWdfDevice )
            {
                // Store the IWDFDevice pointer
                m_spWdfDevice = pWdfDevice;
            }

            // Create & Configure the default IO Queue
            if (SUCCEEDED(hr))
            {
                hr = ConfigureQueue();
            }

            // Create the sensor manager object
            if (SUCCEEDED(hr))
            {
                hr = CComObject<CSensorManager>::CreateInstance(&m_pSensorManager);

                if (nullptr != m_pSensorManager)
                {
                    if ((SUCCEEDED(hr)) && (NULL != m_pSensorManager))
                    {
                        m_pSensorManager->AddRef();
                    }

                    // Initialize the sensor manager object
                    if(SUCCEEDED(hr))
                    {
                        hr = m_pSensorManager->Initialize(m_spWdfDevice, this);
                    }
                }
                else
                {
                    hr = E_POINTER;
                }
            }
    
            if (SUCCEEDED(hr))
            {
                hr = StringCchCopy(m_pSensorManager->m_wszDeviceName, MAX_PATH, DEFAULT_DEVICE_MODEL_VALUE);
    
                if (SUCCEEDED(hr))
                {
                    ULONG ulCchInstanceId = 0;
                    BOOL  fResult = FALSE;
                    WCHAR* wszInstanceId = nullptr;
                    WCHAR* tempStr = nullptr;

                    try 
                    {
                        wszInstanceId = new WCHAR[MAX_PATH];
                    }
                    catch(...)
                    {
                        hr = E_UNEXPECTED;
                        Trace(TRACE_LEVEL_ERROR, "Failed to allocate memory for instance ID string, hr = %!HRESULT!", hr);

                        if (nullptr != wszInstanceId) 
                        {
                            delete[] wszInstanceId;
                        }
                    }

                    try 
                    {
                        tempStr = new WCHAR[MAX_PATH];
                    }
                    catch(...)
                    {
                        hr = E_UNEXPECTED;
                        Trace(TRACE_LEVEL_ERROR, "Failed to allocate memory for instance ID temp string, hr = %!HRESULT!", hr);

                        if (nullptr != tempStr) 
                        {
                            delete[] tempStr;
                        }
                    }

                    if (SUCCEEDED(pWdfDevice->RetrieveDeviceInstanceId(NULL, &ulCchInstanceId)))
                    {
                        if (SUCCEEDED(pWdfDevice->RetrieveDeviceInstanceId(wszInstanceId, &ulCchInstanceId)))
                        {
                            HDEVINFO hDeviceInfo = INVALID_HANDLE_VALUE;

                            if (INVALID_HANDLE_VALUE != (hDeviceInfo = ::SetupDiCreateDeviceInfoList(NULL, NULL)))
                            {
                                SP_DEVINFO_DATA deviceInfo = {sizeof(SP_DEVINFO_DATA)};
                                if (TRUE == ::SetupDiOpenDeviceInfo(hDeviceInfo, wszInstanceId, NULL, 0, &deviceInfo))
                                {
                                    DEVPROPTYPE propType;
                                    ULONG ulSize;

                                    fResult = ::SetupDiGetDeviceProperty(hDeviceInfo, &deviceInfo, &DEVPKEY_Device_DeviceDesc, &propType, (PBYTE)tempStr, MAX_PATH*sizeof(WCHAR), &ulSize, 0);
                                    if (FALSE == fResult)
                                    {
                                        hr = HRESULT_FROM_WIN32(GetLastError());
                                    }

#pragma warning(suppress: 26035) //possible failure to null terminate string
                                    if (SUCCEEDED(hr) && (wcscmp(tempStr, L"") != 0))
                                    {
                                        wcscpy_s(m_pSensorManager->m_wszDeviceName, MAX_PATH, tempStr);
                                    }

                                    ::SetupDiDestroyDeviceInfoList(hDeviceInfo);
                                }
                            }
                        }
                    }

#pragma warning(suppress: 6001) //using unitialized memory
                    if (nullptr != wszInstanceId) 
                    {
                        delete[] wszInstanceId;
                    }

#pragma warning(suppress: 6001) //using unitialized memory
                    if (nullptr != tempStr) 
                    {
                        delete[] tempStr;
                    }
                }
            }

        } // processing in progress

        ExitProcessing(PROCESSING_IPNPCALLBACKHARDWARE);
    }

    if (FAILED(hr))
    {
        Trace(TRACE_LEVEL_CRITICAL, "Abnormal results during hardware initialization, hr = %!HRESULT!", hr);
    }

    Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Exit, hr = %!HRESULT!", hr);

    return hr;
}
예제 #11
0
파일: Queue.cpp 프로젝트: 340211173/Driver
/////////////////////////////////////////////////////////////////////////
//
// CMyQueue::OnDeviceIoControl
//
// This method is called when an IOCTL is sent to the device
//
// Parameters:
//      pQueue            - pointer to an IO queue
//      pRequest          - pointer to an IO request
//      ControlCode       - The IOCTL to process
//      InputBufferSizeInBytes - the size of the input buffer
//      OutputBufferSizeInBytes - the size of the output buffer
//
/////////////////////////////////////////////////////////////////////////
STDMETHODIMP_ (void) CMyQueue::OnDeviceIoControl(
    _In_ IWDFIoQueue*     pQueue,
    _In_ IWDFIoRequest*   pRequest,
    _In_ ULONG            ControlCode,
         SIZE_T           InputBufferSizeInBytes,
         SIZE_T           OutputBufferSizeInBytes
    )
{
    UNREFERENCED_PARAMETER(pQueue);
    UNREFERENCED_PARAMETER(InputBufferSizeInBytes);
    UNREFERENCED_PARAMETER(OutputBufferSizeInBytes);

    //Trace(TRACE_LEVEL_INFORMATION, "%!FUNC! Entry");
    
    DWORD dwWritten = 0;

    if (IOCTL_GPS_RADIO_MANAGEMENT_GET_RADIO_STATE == ControlCode ||
        IOCTL_GPS_RADIO_MANAGEMENT_GET_PREVIOUS_RADIO_STATE == ControlCode ||
        IOCTL_GPS_RADIO_MANAGEMENT_SET_RADIO_STATE == ControlCode ||
        IOCTL_GPS_RADIO_MANAGEMENT_SET_PREVIOUS_RADIO_STATE == ControlCode
        )
    {
#if (NTDDI_VERSION >= NTDDI_WIN8)
        if (FAILED(EnterProcessing(PROCESSING_IQUEUECALLBACKDEVICEIOCONTROL)))
        {
            // Unsupported request
            pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
        }
        else
        {
            HRESULT hr = m_pParentDevice->ProcessIoControlRadioManagement(pRequest, ControlCode);
            pRequest->CompleteWithInformation(hr, sizeof(DEVICE_RADIO_STATE));
        } // processing in progress

        ExitProcessing(PROCESSING_IQUEUECALLBACKDEVICEIOCONTROL);
#endif
    }
    else if( IS_WPD_IOCTL( ControlCode ) )
    {
        if (FAILED(EnterProcessing(PROCESSING_IQUEUECALLBACKDEVICEIOCONTROL)))
        {
            // Unsupported request
            pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
        }
        else
        {
            m_pParentDevice->ProcessIoControl(  pQueue,
                                                pRequest,
                                                ControlCode,
                                                InputBufferSizeInBytes,
                                                OutputBufferSizeInBytes,
                                                &dwWritten);
        } // processing in progress

        ExitProcessing(PROCESSING_IQUEUECALLBACKDEVICEIOCONTROL);
    }
    else
    {
        // Unsupported request
        pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
    }

}
예제 #12
0
//modify by QP on 2k8-4-7 
//change the function ReadInitialCBorPA( )
//add two parameters int Minclus and Maxclus,delete int clus
//Minclus -- Min number of clusters
//Maxclus -- Max number of clusters
int ReadInitialCBorPA(char *InName, int Minclus, int Maxclus, TRAININGSET *pTS, 
CODEBOOK *pCB, PARTITIONING *pP) 
{
  int useInitial = 0;
  
  if (*InName)  /* we use initial codebook/partitioning */
  {
    switch (DetermineCBFileType(InName)) {
      case TSFILE: case CBFILE:
        ReadCodebook(InName, pCB);
        useInitial = 1;
        //modify by QP on 2k8-4-7 
		//If we use initial ones, we just need to judge the size of codebook/
		//training set is in the range: [Minclus, Maxclus]
		if (BookSize(pCB) < Minclus || BookSize(pCB) > Maxclus )
        {
          ErrorMessage("\nERROR: Number of vectors in initial codebook ");
          ErrorMessage("(%d) <> number of clusters ", BookSize(pCB));
          ErrorMessage("(%d)(%d)!\n\n", Minclus, Maxclus);
          FreeCodebook(pTS);
          FreeCodebook(pCB);
          ExitProcessing(FATAL_ERROR);
        }
        
        CreateNewPartitioning(pP, pTS, BookSize(pCB));
        break;
        
      case PAFILE:
        ReadPartitioning(InName, pP, pTS);
        useInitial = 2;
        
        //modify by QP on 2k8-4-7 
		//judge the size of partitioning is in the range: [Minclus, Maxclus]
        if (PartitionCount(pP)<Minclus || PartitionCount(pP) > Maxclus)
        {
          ErrorMessage("\nERROR: Number of partitions in initial partitioning ");
          ErrorMessage("(%d) <> number of clusters ", PartitionCount(pP));
          ErrorMessage("(%d)(%d)!\n\n", Minclus, Maxclus);
          FreeCodebook(pTS);
          FreePartitioning(pP);
          ExitProcessing(FATAL_ERROR);
        }
        
        CreateNewCodebook(pCB, PartitionCount(pP), pTS);
        break;
        
      case NOTFOUND:
        ErrorMessage("\nERROR: Type of initial codebook/partitioning file "
            "%s is unidentified!\n\n", InName);
        FreeCodebook(pTS);
        ExitProcessing(FATAL_ERROR);
        break;
    }      
  }
  else  /* we don't use initial codebook/partitioning */
  {
 //   CreateNewCodebook(pCB, clus, pTS);
 //   CreateNewPartitioning(pP, pTS, clus);
    useInitial = 0;
  }
  
  return useInitial;
}