Beispiel #1
0
VOID
ReturnCompletedBuffers(SessionInfo* session_info)
{
    PWAVEHDR header = NULL;

    /* Set the current header and test to ensure it's not NULL */
    while ( ( header = session_info->wave_queue ) )
    {
        if ( header->dwFlags & WHDR_DONE )
        {
            DWORD message;

            /* Mark as done, and unqueued */
            header->dwFlags &= ~WHDR_INQUEUE;
            header->dwFlags |= WHDR_DONE;

            /* Trim it from the start of the queue */
            session_info->wave_queue = header->lpNext;

            /* Choose appropriate notification */
            message = (session_info->device_type == WaveOutDevice) ? WOM_DONE :
                                                                     WIM_DATA;

            DPRINT("Notifying client that buffer 0x%p is done\n", header);

            /* Notify the client */
            NotifyClient(session_info, message, (DWORD_PTR) header, 0);
        }
    }

    /* TODO: Perform I/O as a new buffer may have arrived */
}
void JackEngine::NotifyXRun(int refnum)
{
    if (refnum == ALL_CLIENTS) {
        NotifyClients(kXRunCallback, false, "", 0, 0);
    } else {
        NotifyClient(refnum, kXRunCallback, false, "", 0, 0);
    }
}
// ---------------------------------------------------------
// CWtaiHandler::BrowserTelServiceEvent()
// ---------------------------------------------------------
//
void CWtaiHandler::BrowserTelServiceEvent( TBrowserTelServiceState aEvent )
	{
	CLOG_ENTERFN( "CWtaiHandler::BrowserTelServiceEvent()" );

	if( EIdle == aEvent )
		{
		NotifyClient();
		}
	}
// ---------------------------------------------------------
// CWtaiHandler::HandleUrlEmbeddedL()
// ---------------------------------------------------------
//
void CWtaiHandler::HandleUrlEmbeddedL()
	{
	CLOG_ENTERFN( "CWtaiHandler::HandleUrlEmbeddedL()" );
    TInt err;

	TPtrC library_function;

	iTelService = CBrowserTelService::NewL();
    iTelService->AddObserver(this);

	TRAP( err, library_function.Set( GetWtaiLibraryFunctionL() ) );
	TInt count = GetParameterCountL();
    TBool confirmDtmfValue = ReadSdConfirmDtmfValueL();
	if( ( err == KErrNone ) || ( count <= 0 ) )
		{
		if( 0 == library_function.CompareF( KWPMC ) )
			{
			TPtrC number = GetParameterL( ESchemeWtaiNumber );

			CLOG_WRITE_FORMAT( "CWtaiHandler::GetParameter: number: %S", &number );

            err = iTelService->MakeCall( number, confirmDtmfValue );
			}
		else if( 0 == library_function.CompareF( KWPSD ) )
			{
			TPtrC dtmf = GetParameterL( ESchemeWtaiNumber );

			CLOG_WRITE_FORMAT( "CWtaiHandler::GetParameter: dtmf: %S", &dtmf );

            err = iTelService->SendDTMF(dtmf, confirmDtmfValue);
			}
		else if( 0 == library_function.CompareF( KWPAP ) )
			{
			TPtrC number = GetParameterL( ESchemeWtaiNumber );
			CLOG_WRITE_FORMAT( "CWtaiHandler::GetParameter: number: %S", &number );
			TPtrC name = GetParameterL( ESchemeWtaiName );
			CLOG_WRITE_FORMAT( "CWtaiHandler::GetParameter: name: %S", &name );
			TPtrC email = GetParameterL( ESchemeWtaiEmail );
			CLOG_WRITE_FORMAT( "CWtaiHandler::GetParameter: email: %S", &email );
			err = iTelService->AddPBEntryL( number, name, email );
			}
		}

    NotifyClient();

    ErrorHandlerL( err );

	CLOG_LEAVEFN( "CWtaiHandler::HandleUrlEmbeddedL()" );
	}
int JackEngine::ComputeTotalLatencies()
{
    std::vector<jack_int_t> sorted;
    std::vector<jack_int_t>::iterator it;
    std::vector<jack_int_t>::reverse_iterator rit;

    fGraphManager->TopologicalSort(sorted);

    /* iterate over all clients in graph order, and emit
	 * capture latency callback.
	 */

    for (it = sorted.begin(); it != sorted.end(); it++) {
        NotifyClient(*it, kLatencyCallback, true, "", 0, 0);
    }

    /* now issue playback latency callbacks in reverse graph order.
	 */
    for (rit = sorted.rbegin(); rit != sorted.rend(); rit++) {
        NotifyClient(*rit, kLatencyCallback, true, "", 1, 0);
    }

    return 0;
}
Beispiel #6
0
DWORD
OpenDevice(
    DeviceType device_type,
    UINT device_id,
    PVOID open_descriptor,
    DWORD flags,
    DWORD_PTR private_handle)
{
    SessionInfo* session_info;
    MMRESULT result;
    DWORD message;

    /* This will automatically check for duplicate sessions */
    result = CreateSession(device_type, device_id, &session_info);

    if ( result != MMSYSERR_NOERROR )
    {
        DPRINT("Couldn't allocate session info\n");
        return result;
    }

    result = OpenKernelDevice(device_type,
                              device_id,
                              GENERIC_READ,
                              &session_info->kernel_device_handle);

    if ( result != MMSYSERR_NOERROR )
    {
        DPRINT("Failed to open kernel device\n");
        DestroySession(session_info);
        return result;
    }

    /* Set common session data */

    session_info->flags = flags;

    /* Set wave/MIDI specific data */

    if ( IsWaveDevice(device_type) )
    {
        LPWAVEOPENDESC wave_open_desc = (LPWAVEOPENDESC) open_descriptor;
        session_info->callback = wave_open_desc->dwCallback;
        session_info->mme_wave_handle = wave_open_desc->hWave;
        session_info->app_user_data = wave_open_desc->dwInstance;
    }
    else
    {
        DPRINT("Only wave devices are supported at present!\n");
        DestroySession(session_info);
        return MMSYSERR_NOTSUPPORTED;
    }

    /* Start the processing thread */

    result = StartSessionThread(session_info);

    if ( result != MMSYSERR_NOERROR )
    {
        DestroySession(session_info);
        return result;
    }

    /* Store the session info */

    *((SessionInfo**)private_handle) = session_info;

    /* Send the right message */

    message = (device_type == WaveOutDevice) ? WOM_OPEN :
              (device_type == WaveInDevice) ? WIM_OPEN :
              (device_type == MidiOutDevice) ? MOM_OPEN :
              (device_type == MidiInDevice) ? MIM_OPEN : 0xFFFFFFFF;

    NotifyClient(session_info, message, 0, 0);

    return MMSYSERR_NOERROR;
}
void JackEngine::NotifyActivate(int refnum)
{
    NotifyClient(refnum, kActivateClient, true, "", 0, 0);
}
void JackEngine::NotifyClients(int event, int sync, const char* message, int value1, int value2)
{
    for (int i = 0; i < CLIENT_NUM; i++) {
        NotifyClient(i, event, sync, message, value1, value2);
    }
}
Beispiel #9
0
///////////////////////////////////////////////////////////////////////////////
//  SDSetCardFeature       - Set card feature
//  Input:  hDevice        - SD Device Handle
//          CardFeature    - Card Feature to set
//          StructureSize  - size of card feature structure
//  Output: pCardInfo      - Information for the feature
//  Return: SD_API_STATUS code
//  Notes:  This function is provided to set various card features
//          in a thread safe manner.  SDIO cards utilize shared register sets
//          between functions. This requires that the 
//          register state be preserved between functions that can be 
//          controlled in separate thread contexts.
//          This function can potentially block by issuing synchronous bus 
//          request.  This function must not be called from a bus request callback
///////////////////////////////////////////////////////////////////////////////
SD_API_STATUS CSDDevice::SDSetCardFeature_I(SD_SET_FEATURE_TYPE  CardFeature,PVOID pCardInfo,ULONG StructureSize)
{
    SD_API_STATUS               status = SD_API_STATUS_SUCCESS;  // intermediate status
    PSD_DATA_TRANSFER_CLOCKS    pClocks;                         // data transfer clocks variable  

    switch (CardFeature) {

      case SD_IO_FUNCTION_ENABLE:
        if ((sizeof(SD_IO_FUNCTION_ENABLE_INFO) != StructureSize) || (NULL == pCardInfo)) {
            DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: SD_IO_FUNCTION_ENABLE - Invalid params \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }
        if (Device_SD_IO != m_DeviceType) {
            DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: device is not SDIO ! \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }        
        status = SDEnableDisableFunction((PSD_IO_FUNCTION_ENABLE_INFO)pCardInfo, TRUE);
        break;
        
      case SD_IO_FUNCTION_DISABLE:
        if (Device_SD_IO != m_DeviceType) {
            DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: device is not SDIO ! \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }
        status = SDEnableDisableFunction(NULL, FALSE);
        break;
      case SD_IO_FUNCTION_HIGH_POWER:         
        if (Device_SD_IO != m_DeviceType) {
            DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: device is not SDIO ! \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }
        status = SDFunctionSelectPower(FALSE);
        break;

      case SD_IO_FUNCTION_LOW_POWER:
        if (Device_SD_IO != m_DeviceType) {
            DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: device is not SDIO ! \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }
        status = SDFunctionSelectPower(TRUE);
        break;

      case SD_INFO_POWER_CONTROL_STATE:
        if ((sizeof(FUNCTION_POWER_STATE) != StructureSize) || (NULL == pCardInfo)) {
            DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: SD_INFO_POWER_CONTROL_STATE - Invalid params \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }
        if (Device_SD_IO != m_DeviceType) {
            DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: device is not SDIO ! \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }

        status = GetFunctionPowerState((PFUNCTION_POWER_STATE)pCardInfo);
        break;

      case SD_IO_FUNCTION_SET_BLOCK_SIZE:
        if ((sizeof(DWORD) != StructureSize) || (NULL == pCardInfo)) {
            DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: SD_IO_FUNCTION_SET_BLOCK_SIZE - Invalid params \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }
        if (Device_SD_IO != m_DeviceType) {
            DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: device is not SDIO ! \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }
        status = SDSetFunctionBlockSize(*((DWORD *)pCardInfo));
        break;

      case SD_SET_DATA_TRANSFER_CLOCKS:
        if ((sizeof(SD_DATA_TRANSFER_CLOCKS) != StructureSize) || (NULL == pCardInfo)) {
            DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: SD_SET_DATA_TRANSFER_CLOCKS - Invalid params \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }

        pClocks = (PSD_DATA_TRANSFER_CLOCKS)pCardInfo;
        m_SDCardInfo.SDMMCInformation.DataAccessReadClocks = pClocks->ReadClocks;
        m_SDCardInfo.SDMMCInformation.DataAccessWriteClocks = pClocks->WriteClocks;
        status = SD_API_STATUS_SUCCESS;
        break;

      case SD_IS_FAST_PATH_AVAILABLE:
        status = SD_API_STATUS_SUCCESS;
        break;

      case SD_FAST_PATH_DISABLE:
        //  Disable the use of Fast-Path for testing.
        m_SDCardInfo.SDIOInformation.Flags |= FSTPTH_DISABLE;
        status = SD_API_STATUS_SUCCESS;
        break;

      case SD_FAST_PATH_ENABLE:
#ifdef _FASTPATH_ENABLE_
        //  Always use Fast-Path operations.
        m_SDCardInfo.SDIOInformation.Flags &= ~ FSTPTH_DISABLE;
#else
        m_SDCardInfo.SDIOInformation.Flags |= FSTPTH_DISABLE;
#endif
        status = SD_API_STATUS_SUCCESS;
        break;

      case SD_IS_SOFT_BLOCK_AVAILABLE:
        status = SD_API_STATUS_SUCCESS;
        break;

      case SD_SOFT_BLOCK_FORCE_UTILIZATION:
        //  Always use Soft-Block operations.
        m_SDCardInfo.SDIOInformation.Flags |= SFTBLK_USE_ALWAYS;
        status = SD_API_STATUS_SUCCESS;
        break;

      case SD_SOFT_BLOCK_DEFAULT_UTILIZATON:
        //  Use hardware multi-block operations if supported by the card,
        //  otherwise use Soft-Block.
        m_SDCardInfo.SDIOInformation.Flags &= ~ SFTBLK_USE_ALWAYS;
        status = SD_API_STATUS_SUCCESS;
        break;

      case SD_SET_CARD_INTERFACE: {
        if ((sizeof(SD_CARD_INTERFACE) != StructureSize) || (NULL == pCardInfo)) {
                DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: SD_SET_CARD_INTERFACE - Invalid params \n")));
                return SD_API_STATUS_INVALID_PARAMETER;
        }
        PSD_CARD_INTERFACE pCardInterface = (PSD_CARD_INTERFACE) pCardInfo ;
        SD_CARD_INTERFACE_EX sdCardInterfaceEx;
        memset (&sdCardInterfaceEx, 0, sizeof(sdCardInterfaceEx));
        sdCardInterfaceEx.ClockRate = pCardInterface->ClockRate;
        sdCardInterfaceEx.InterfaceModeEx.bit.sdWriteProtected = (pCardInterface->WriteProtected?1:0);
        sdCardInterfaceEx.InterfaceModeEx.bit.sd4Bit = (pCardInterface->InterfaceMode == SD_INTERFACE_SD_4BIT?1:0) ;
        status =SetCardFeature_Interface(sdCardInterfaceEx);
        break;
      }
     case SD_SET_CARD_INTERFACE_EX: {
        if ((sizeof(SD_CARD_INTERFACE_EX) != StructureSize) || (NULL == pCardInfo)) {
                DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDSetCardFeature: SD_SET_CARD_INTERFACE_EX - Invalid params \n")));
                return SD_API_STATUS_INVALID_PARAMETER;
        }
        status = SetCardFeature_Interface(*(PSD_CARD_INTERFACE_EX)pCardInfo);
        break;
      }

      case SD_SET_CLOCK_STATE_DURING_IDLE:
        if ( (sizeof(BOOL) != StructureSize) || (NULL == pCardInfo) ) {
            DEBUGMSG(SDCARD_ZONE_ERROR,(TEXT("SDSetCardFeature: SD_SET_CLOCK_ON_DURING_IDLE - Invalid params \n")));
            return SD_API_STATUS_INVALID_PARAMETER;
        }

        // prompt the host to turn on or off the clock during the idle state based on the client's
        // request.
        status = m_sdSlot.GetHost().SlotOptionHandler(m_sdSlot.GetSlotIndex(), SDHCDSetClockStateDuringIdle, pCardInfo,StructureSize);

        DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("SDSetCardFeature: SDHCDSetClockStateDuringIdle finished with status: %x\n"),
            status));
        break;
      case SD_CARD_FORCE_RESET:
        DbgPrintZo(SDCARD_ZONE_INIT, (TEXT("SDSetCardFeature: call SD_CARD_FORCE_RESET \n")));
        m_sdSlot.PostEvent(SlotResetRequest);
        break;

      case SD_CARD_SELECT_REQUEST:
        // request made by client driver to select the card. The request will not be honored
        // until all client drivers in this slot make such request.
        {
            BOOL bAllFunctionsRequestedCardSelect  = TRUE;;
            DbgPrintZo(SDCARD_ZONE_INIT,(TEXT("SDSetCardFeature: call SD_CARD_SELECT_REQUEST \n")));
            m_bCardSelectRequest = TRUE;
            NotifyClient(SDCardSelectRequest);
            for (DWORD dwIndex = 0; dwIndex < SD_MAXIMUM_DEVICE_PER_SLOT; dwIndex++) {
                CSDDevice * pDevice = m_sdSlot.GetFunctionDevice(dwIndex);
                if (pDevice != NULL) {
                    if (pDevice->m_bCardSelectRequest == FALSE && pDevice->GetDeviceType()!= Device_Unknown ) {
                        bAllFunctionsRequestedCardSelect = FALSE;
                    }
                    pDevice->DeRef();
                }
            }
            if (bAllFunctionsRequestedCardSelect == FALSE) {
                DbgPrintZo(SDCARD_ZONE_INFO, (TEXT("SDSetCardFeature: SD_CARD_SELECT_REQUEST - request is pending\n")));
                return SD_API_STATUS_PENDING;
            }
            DbgPrintZo(SDCARD_ZONE_INIT, (TEXT("SDSetCardFeature: SD_CARD_SELECT_REQUEST - request is processing\n")));
            m_sdSlot.PostEvent(SlotSelectRequest);
        }
        break;
      case SD_CARD_DESELECT_REQUEST:
        {
            BOOL bAllFunctionsRequestedCardDeselect= TRUE;;
            DbgPrintZo(SDCARD_ZONE_INIT, (TEXT("SDSetCardFeature: call SD_CARD_DESELECT_REQUEST \n")));
            if (!m_bCardDeselectRequest) {
                m_bCardDeselectRequest = TRUE;
                NotifyClient(SDCardDeselectRequest);
            }
            for (DWORD dwIndex = 0; dwIndex < SD_MAXIMUM_DEVICE_PER_SLOT; dwIndex++) {
                CSDDevice * pDevice = m_sdSlot.GetFunctionDevice(dwIndex);
                if (pDevice != NULL) {
                    if (pDevice->m_bCardDeselectRequest == FALSE && pDevice->GetDeviceType()!= Device_Unknown) {
                        bAllFunctionsRequestedCardDeselect = FALSE ;
                    }
                    pDevice->DeRef();
                }
            }
            if (bAllFunctionsRequestedCardDeselect == FALSE) {
                DbgPrintZo(SDCARD_ZONE_INFO, (TEXT("SDSetCardFeature: SD_CARD_DESELECT_REQUEST - request is pending\n")));
                return SD_API_STATUS_PENDING;
            }
            DbgPrintZo(SDCARD_ZONE_INIT, (TEXT("SDSetCardFeature: SD_CARD_DESELECT_REQUEST - request is processing\n")));
            m_sdSlot.PostEvent(SlotDeselectRequest);
        }
        break;
      case SD_SET_SWITCH_FUNCTION: {
        if (pCardInfo!=NULL && StructureSize >= sizeof(SD_CARD_SWITCH_FUNCTION)) {
            PSD_CARD_SWITCH_FUNCTION psdSwitchFunction = (PSD_CARD_SWITCH_FUNCTION)pCardInfo;
            status = SwitchFunction((PSD_CARD_SWITCH_FUNCTION)pCardInfo,FALSE);
        }
      }
      break;
      case SD_DMA_ALLOC_PHYS_MEM:
        if (pCardInfo!=NULL && StructureSize >= sizeof(SD_HOST_ALLOC_FREE_DMA_BUFFER)) {
            status = m_sdSlot.GetHost().SlotOptionHandler(m_sdSlot.GetSlotIndex(),SDHCAllocateDMABuffer, pCardInfo,sizeof(SD_HOST_ALLOC_FREE_DMA_BUFFER));                
        }
        break;
      case SD_DMA_FREE_PHYS_MEM:
        if (pCardInfo!=NULL && StructureSize >= sizeof(SD_HOST_ALLOC_FREE_DMA_BUFFER)) {
            status = m_sdSlot.GetHost().SlotOptionHandler(m_sdSlot.GetSlotIndex(),SDHCFreeDMABuffer, pCardInfo,sizeof(SD_HOST_ALLOC_FREE_DMA_BUFFER));                
        }
        break;
    default:
        status = SD_API_STATUS_INVALID_PARAMETER;
        break;
    }

    return status;
}
// ---------------------------------------------------------
// CMailToHandler::HandleUrlEmbeddedL()
// ---------------------------------------------------------
//
void CMailToHandler::HandleUrlEmbeddedL()
	{
	CLOG_ENTERFN( "CMailToHandler::HandleUrlEmbeddedL()" );

    //TPtrC path = iParsedUrl->Des();

	iTelService = CBrowserTelService::NewL();
	iTelService->AddObserver( this );

	TPtrC recipient = GetField( KMailto );
	TPtrC subject = GetField( KSubject );
	TPtrC msgBody = GetField( KBody );
	TPtrC cC = GetField( KCc );
    TPtrC tO = GetField( KTo );
    TPtrC bCC = GetField( KBcc );

    HBufC* rec = ChangeSeparationLC( recipient );
    HBufC* ccrec = ChangeSeparationLC( cC );
    HBufC* torec = ChangeSeparationLC( tO );
    HBufC* bccrec = ChangeSeparationLC( bCC );

    HBufC* allrec = HBufC::NewLC( ccrec->Length() +
                                  torec->Length() +
                                  bccrec->Length() + 3*KComma().Length() );
    if( ccrec->Length() != 0 )
        {
        if( allrec->Length() != 0 )
            {
            allrec->Des().Append( KComma() );
            }
        allrec->Des().Append( ccrec->Des() );
        }
    if( torec->Length() != 0 )
        {
        if( allrec->Length() != 0 )
            {
            allrec->Des().Append( KComma() );
            }
        allrec->Des().Append( torec->Des() );
        }
    if( bccrec->Length() != 0 )
        {
        if( allrec->Length() != 0 )
            {
            allrec->Des().Append( KComma() );
            }
        allrec->Des().Append( bccrec->Des() );
        }

    if( rec->Length() > 0 )
        {
        TChar ch1('?');
        TChar ch2('&');
        TChar recchar((*rec)[ rec->Length() - 1]);
        if( recchar == ch1 )
            {
            rec->Des().SetLength(rec->Length() - 1);
            }
        TChar recchar2((*rec)[ rec->Length() - 1]);
        if( recchar2 == ch2 )
            {
            rec->Des().SetLength(rec->Length() - 1);
            }
        }

    if( allrec->Length() > 0 )
        {
        TChar ch1('?');
        TChar ch2('&');
        TChar allrecchar1( (*allrec)[ allrec->Length() - 1] );
        if( allrecchar1 == ch1 )
            {
            allrec->Des().SetLength(allrec->Length() - 1);
            }
        TChar allrecchar2( (*allrec)[ allrec->Length() - 1] );
        if( allrecchar2 == ch2 )
            {
            allrec->Des().SetLength(allrec->Length() - 1);
            }
        }

 	TRAPD( err, iTelService->SendEmailMessageL( rec->Des(), allrec->Des(), subject, msgBody, ETrue) );

    CleanupStack::PopAndDestroy( 5 ); // rec, ccrec, torec, bccrec, allrec

    NotifyClient();

    ErrorHandlerL( err );

	CLOG_LEAVEFN( "CMailToHandler::HandleUrlEmbeddedL()" );
	}