rlstate.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 556 行 · 第 1/2 页

    }

    return pOffset;
}

/****************************************************************************
 *  Method:
 *    CASMRuleState::StartSubscribePending
 *
 */
void 
CASMRuleState::StartSubscribePending(UINT16 usRuleNum)
{
    HX_ASSERT(usRuleNum < m_nNumRules);

//printf("%lu\t\tSubscribe Pending:\t%u\n", this, usRuleNum);
    if (m_bUnsubscribePending[usRuleNum])
    {
//printf("%lu\t\tImediate Subscribe (was pending Unsubscribe):\t%u\n", this, usRuleNum);
	m_bUnsubscribePending[usRuleNum] = FALSE;
	m_bSubscribed[usRuleNum] = TRUE;
    }
    else
    {
        m_bSubscribePending[usRuleNum] = TRUE;
    }
}

/****************************************************************************
 *  Method:
 *    CASMRuleState::CanSubscribeNow
 *
 */
BOOL
CASMRuleState::CanSubscribeNow(UINT16 usRuleNum)
{
    // check for OnDepen dependent rules for this rule, if they are all
    // subscribed then this rule can subscribe
    UINT16 idxDepend;
    BOOL bAllDependsSubscribed = TRUE;

    if (m_OnDepends[usRuleNum] != NULL)
    {
	// once we find one depend pending we can stop looking
	for (idxDepend = 0; idxDepend < m_nNumRules && 
		m_OnDepends[usRuleNum][idxDepend] != NO_DEPEND_SET && 
		bAllDependsSubscribed; idxDepend++)
	{
	    // if the dependent rule is not subscribed then we have a
	    // dependPending
	    bAllDependsSubscribed = 
		m_bSubscribed[m_OnDepends[usRuleNum][idxDepend]];
	}
    }

    // we can subscribe as long as all dependent rules are subscribed
    return bAllDependsSubscribed;
}

/****************************************************************************
 *  Method:
 *    CASMRuleState::CompleteSubscribe
 *
 */
void
CASMRuleState::CompleteSubscribe(UINT16 usRuleNum)
{
    HX_ASSERT(usRuleNum < m_nNumRules);
//printf("%lu\t\tSubscribe Complete:\t%u\r\n", this, usRuleNum);
    m_bSubscribePending[usRuleNum] = FALSE;
    m_bSubscribed[usRuleNum] = TRUE;
}

/****************************************************************************
 *  Method:
 *    CASMRuleState::StartUnsubscribePending
 *
 */
void
CASMRuleState::StartUnsubscribePending(UINT16 usRuleNum)
{
    HX_ASSERT(usRuleNum < m_nNumRules);
//printf("%lu\t\tUnsubscribe Pending:\t%u\r\n", this, usRuleNum);
    if (m_bSubscribed[usRuleNum])
    {
	m_bUnsubscribePending[usRuleNum] = TRUE;
    }
    else
    {
	/*
	 * when a client subscribes to a rule and then decides to subscribe to a
	 * mutually exclusive rule (e.g. 8 and then 6), the subscribe to the second
	 * rule calls ASMRuleState::CancelStreamSwitch which clears all pending
	 * subscribes (i.e. the one to 8) and then starts a subscribe pending to 6.
	 * Later the client comes along and decides to explicitly unsubscribe to 8
	 * which causes an assertion failure in the asm rule state.	 
	 */
//	HX_ASSERT(m_bSubscribePending[usRuleNum]);
	/*
	 *  This should be fine since a new subscription state must have been established.
	 */
	 
	// we can cancel this pending subscribe if we are unsubscribing
	m_bSubscribePending[usRuleNum] = FALSE;
    }
}

/****************************************************************************
 *  Method:
 *    CASMRuleState::CanUnsubscribeNow
 *
 */
BOOL
CASMRuleState::CanUnsubscribeNow(UINT16 usRuleNum)
{
    // check for OffDepen dependent rules for this rule, if any are 
    // subscribed then this rule can't unsubscribe
    UINT16 idxDepend;
    BOOL bAllDependsUnsubscribed = TRUE;

    if (m_OffDepends[usRuleNum] != NULL)
    {
	// once we find one depend pending we can stop looking
	for (idxDepend = 0; idxDepend < m_nNumRules && 
	      m_OffDepends[usRuleNum][idxDepend] != NO_DEPEND_SET && 
	      bAllDependsUnsubscribed; idxDepend++)
	{
	    // if the dependent rule is still subscribed then we have a
	    // dependent rule that's not unsubscribed
	    bAllDependsUnsubscribed = 
		!m_bSubscribed[m_OffDepends[usRuleNum][idxDepend]];
	}
    }

    // we can unsubscribe if there aren't any dependent rules subscribed
    return bAllDependsUnsubscribed;
}

/****************************************************************************
 *  Method:
 *    CASMRuleState::CompleteUnsubscribe
 *
 */
void
CASMRuleState::CompleteUnsubscribe(UINT16 usRuleNum)
{
    HX_ASSERT(usRuleNum < m_nNumRules);
//printf("%lu\t\tUnsubscribe Complete:\t%u\r\n", this, usRuleNum);
    m_bUnsubscribePending[usRuleNum] = FALSE;
    m_bSubscribed[usRuleNum] = FALSE;
}

/****************************************************************************
 *  Method:
 *    CASMRuleState::CanSwitchStreamsNow
 *
 */
BOOL
CASMRuleState::CanSwitchStreamsNow()
{
    UINT16 i = 0;

    // if there are no unsubscribes pending && there are no subscribed
    // rules
    while (i < m_nNumRules && !m_bUnsubscribePending[i] && 
	!m_bSubscribed[i])
    {
	i++;
    }

    return (i == m_nNumRules);
}

/****************************************************************************
 *  Method:
 *    CASMRuleState::CompleteStreamSwitch
 *
 */
void
CASMRuleState::CompleteStreamSwitch()
{
//printf("%lu\t\t--->Compete Stream Switch\r\n", this);

    // mark all of the pending rules subscribed to
    for (UINT16 usRuleNumber = 0; usRuleNumber < m_nNumRules;
	usRuleNumber++)
    {
	if (IsSubscribePending(usRuleNumber))
	{
	    CompleteSubscribe(usRuleNumber);
	}
    }
//printf("%lu\t\t<---Stream Switch Completed\r\n", this);
}

/****************************************************************************
 *  Method:
 *    CASMRuleState::CancelStreamSwitch
 *
 */
void
CASMRuleState::CancelStreamSwitch()
{
//printf("%lu\t\tCancel Stream Switch\r\n", this);

    // mark all of the pending rules subscribed to
    for (UINT16 usRuleNumber = 0; usRuleNumber < m_nNumRules;
	usRuleNumber++)
    {
	m_bSubscribePending[usRuleNumber] = FALSE;
    }
}

/****************************************************************************
 *  Method:
 *    CASMRuleState::CompleteAllUnsubscribes
 *
 */
void
CASMRuleState::CompleteAllUnsubscribes()
{
//printf("%lu\t\t--->Compete Unsubscribe All Rules\r\n", this);
    for (UINT16 usRuleNumber = 0; usRuleNumber < m_nNumRules;
	usRuleNumber++)
    {
	if (IsUnsubscribePending(usRuleNumber))
	{
	    CompleteUnsubscribe(usRuleNumber);
	}
    }
//printf("%lu\t\t<---All Rules Unsubscribe Complete\r\n", this);
}


/****************************************************************************
 *  Method:
 *    CASMRuleState::AnyPendingUnsubscribes
 *
 */
BOOL 
CASMRuleState::AnyPendingUnsubscribes()
{
    UINT16 usRuleNumber;
    for (usRuleNumber = 0; usRuleNumber < m_nNumRules;
	usRuleNumber++)
    {
	if (IsUnsubscribePending(usRuleNumber))
	{
	    break;
	}
    }

    return usRuleNumber < m_nNumRules;
}


/****************************************************************************
 *  Method:
 *    CASMRuleState::GetNextPendingUnsubscribe
 *
 */
UINT16 
CASMRuleState::GetNextPendingUnsubscribe()
{
    UINT16 usRuleNumber;
    for (usRuleNumber = 0; usRuleNumber < m_nNumRules;
	usRuleNumber++)
    {
	if (IsUnsubscribePending(usRuleNumber))
	{
	    break;
	}
    }

    HX_ASSERT(usRuleNumber < m_nNumRules);
    return usRuleNumber;
}