ramrendr.cpp

linux下的一款播放器

			else
			{
			    memset(pUrl, 0, iLen);
			}			    
		    }

		    char*   pTrack = NULL;
		    char*   pProtocol = NULL;
		    char*   pCursor = NULL;
		    UINT32  ulProtocol = 0;
	    
		    pCursor = strstr(pUrl, ":");
		    if (pCursor)
		    {
			ulProtocol = pCursor - pUrl;

			if (ulProtocol > 0)
			{
			    pProtocol = new char[ulProtocol+1];
			    memset(pProtocol, 0, ulProtocol+1);
			    strncpy(pProtocol, pUrl, ulProtocol); /* Flawfinder: ignore */

                            rc = ProcessURL(pUrl);
                            if (HXR_NOTIMPL == rc)
                            {
                                rc = HXR_OK;
                                if (pValidator->ValidateProtocol(pProtocol))
			        {
				    if (iSize >= 8)
				    {
				        if (!m_pTrackMap)
				        {
					    m_pTrackMap = new CHXMapLongToObj;
				        }

				        CHXString* encodedURL = new CHXString();				    
				        if (strcasecmp(pProtocol, "pnm") == 0)
				        {
					    *encodedURL = pUrl;
				        }
				        else
				        {   
					    CHXURL::encodeURL(pUrl, *encodedURL);
				        }
                                                                                            
				        (*m_pTrackMap)[uTotalTracks] = encodedURL;
				        uTotalTracks++;
				    }
			        }
			        HX_VECTOR_DELETE(pProtocol);
			    }
                        }
		    }
		}
	    }

	    j = 0;
	    HX_DELETE(pString);
	}
	else
	{	
	    j++; 
	}

	i++;
    }

    // version section is not properly ended 
    if (!bRAMVersionSectionEnded)
    {
	rc = HXR_INVALID_METAFILE;
	goto cleanup;
    }

    // add tracks
    if (m_pTrackMap)
    {	
	char*	    pTrack = NULL;
	CHXMapLongToObj::Iterator i;

	for (uTrackIndex = 0; uTrackIndex < uTotalTracks; uTrackIndex++)
	{
	    pTrack = (char*)(const char*)(*(CHXString*)(*m_pTrackMap)[uTrackIndex]);

	    if (m_bFirstTrack)
	    {
		pGroupManager->GetCurrentGroup(m_uGroupIndexWithin);
		pGroupManager->GetGroup(m_uGroupIndexWithin, pGroup);
	    }
	    else
	    {
		pGroupManager->CreateGroup(pGroup);
	    }

	    if (HXR_OK == pGroup->QueryInterface(IID_IHXGroup2, (void**)&pGroup2) &&
		HXR_OK == PrepareGroup(pGroupProperties))
	    {		
		pGroup->SetGroupProperties(pGroupProperties);
		pGroup2->SetPersistentComponentProperties(m_ulPersistentComponentID,
							  pGroupProperties);

		if (HXR_OK == PrepareTrack(pTrack, pTrackProperties))
		{
		    if (!m_bFirstTrack)
		    {
			pGroupManager->AddGroup(pGroup);
		    }
		    m_bFirstTrack = FALSE;

		    pBuffer = new CHXBuffer();
		    pBuffer->AddRef();

		    SafeSprintf(szID, 128, "%lu_%lu", m_ulGroupIndex, uTrackID); 
		    pBuffer->Set((UCHAR*)szID, strlen(szID)+1);
		    pTrackProperties->SetPropertyCString("id", pBuffer);

		    HX_RELEASE(pBuffer);

		    if (m_ulPersistentComponentDelay)
		    {
			pTrackProperties->SetPropertyULONG32("Delay", m_ulPersistentComponentDelay);
		    }

		    if (m_ulPersistentComponentDuration)
		    {
			pTrackProperties->SetPropertyULONG32("Duration", m_ulPersistentComponentDuration);
		    }

		    pGroup->AddTrack(pTrackProperties);
		    uTrackID++;
	    
		    // a metafile consists of sequential groups
		    // so create a group with 1 track in it for evey ram file line
		    if (m_elementWithinTag != WithinSeqInPar)
		    {
			uTrackID = 0;
			m_ulGroupIndex++;

			// check for maximum number of tracks
			if (m_ulGroupIndex > MAX_RAM_URLS)
			{
			    break;
			}
		    }
		    // a meta file consists of sequential tracks
		    // so create the first track and the rest of them will
		    // be added in TrackDurationResolved()
		    else
		    {
			break;
		    }
		}
		HX_RELEASE(pTrackProperties);
	    }
	    HX_RELEASE(pGroupProperties);
	    HX_RELEASE(pGroup2);
	    HX_RELEASE(pGroup);
	}
    }

cleanup:

    HX_VECTOR_DELETE(pUrl);

    HX_RELEASE(pTrackProperties);
    HX_RELEASE(pGroupProperties);
    HX_RELEASE(pGroup2);
    HX_RELEASE(pGroup);    
    HX_RELEASE(pGroupManager);
    HX_RELEASE(pValidator);

    m_bRAMProcessed = TRUE;

    if (HXR_OK != rc)
    {
	RemoveTracks();
    }

    return rc;
}

HX_RESULT
CRAMRenderer::PrepareGroup(REF(IHXValues*) pGroupProperties)
{
    HX_RESULT	rc = HXR_OK;

    HX_RELEASE(pGroupProperties);
    
    pGroupProperties = new CHXHeader;
    pGroupProperties->AddRef();

    pGroupProperties->SetPropertyULONG32("PersistentComponentID", m_ulPersistentComponentID);
    pGroupProperties->SetPropertyULONG32("PersistentGroupID", m_ulGroupIndex);

    return rc;
}

HX_RESULT
CRAMRenderer::PrepareTrack(char* pszURL, REF(IHXValues*) pTrackProperties)
{
    HX_RESULT	rc = HXR_OK;
    char	szID[5] = {0}; /* Flawfinder: ignore */
    CHXURL*	pURL = NULL;
    IHXValues*  pURLOptions = NULL;
    CHXString	urlString;
    IHXBuffer* pBuffer = NULL;

    if (!pszURL)
    {
	rc = HXR_INVALID_PARAMETER;
	goto cleanup;
    }

    HX_RELEASE(pTrackProperties);
    
    pTrackProperties = new CHXHeader;
    pTrackProperties->AddRef();

    ConvertURL(pszURL, urlString);

    pBuffer = new CHXBuffer();
    pBuffer->AddRef();

    pBuffer->Set((UCHAR*)(const char*)urlString, strlen((const char*)urlString)+1);
    pTrackProperties->SetPropertyCString("src", pBuffer);

    HX_RELEASE(pBuffer);

    pTrackProperties->SetPropertyULONG32("PersistentComponentID", m_ulPersistentComponentID);
    
    // Get any TAC info in URL parameters
    pURL = new CHXURL(pszURL);

    if (pURL->GetLastError() == HXR_OK &&
	((pURLOptions = pURL->GetOptions()) != NULL))
    {
	if (HXR_OK == 
	    pURLOptions->GetPropertyBuffer("Title", pBuffer))
	{
	    pTrackProperties->SetPropertyBuffer("Title", pBuffer);
	    HX_RELEASE(pBuffer);
	}

	if (HXR_OK == 
	    pURLOptions->GetPropertyBuffer("Author", pBuffer))
	{
	    pTrackProperties->SetPropertyBuffer("Author", pBuffer);
	    HX_RELEASE(pBuffer);
	}

	if (HXR_OK == 
	    pURLOptions->GetPropertyBuffer("Copyright", pBuffer))
	{
	    pTrackProperties->SetPropertyBuffer("Copyright", pBuffer);
	    HX_RELEASE(pBuffer);
	}

	if (HXR_OK == 
	    pURLOptions->GetPropertyBuffer("Abstract", pBuffer))
	{
	    pTrackProperties->SetPropertyBuffer("Abstract", pBuffer);
	    HX_RELEASE(pBuffer);
	}

	if (HXR_OK == 
	    pURLOptions->GetPropertyBuffer("Keywords", pBuffer))
	{
	    pTrackProperties->SetPropertyBuffer("Keywords", pBuffer);
	    HX_RELEASE(pBuffer);
	}
    }

cleanup:

    HX_RELEASE(pURLOptions);    
    HX_DELETE(pURL);

    return rc;
}

void
CRAMRenderer::GeneratePreFix()
{
    IHXStreamSource* pSource = NULL;

    m_pStream->GetSource(pSource);
    
    HX_ASSERT(pSource);
    if (pSource)
    {
	const char* pURL = pSource->GetURL();
	HX_ASSERT(pURL);
    
	// we only set (and use) these for local ram files.
	if (pURL && !strncasecmp(pURL,"file:",5))
	{
	    CHXURL::GeneratePrefixRootFragment(pURL, m_urlPrefix, m_urlRoot, m_pURLFragment);
	}
    }    
    HX_RELEASE(pSource);

    return;
}

HX_RESULT 
CRAMRenderer::ConvertURL(const char* pURL, CHXString& newURL)
{
    HX_RESULT	retVal = HXR_OK;
    BOOL	bPartial = FALSE;
    const char*	pszCursor = NULL;

    pszCursor = pURL;

#if defined(_CARBON) || defined(_MAC_UNIX)
    const char *pLochost = "file://localhost/";
    if (!strncasecmp(pszCursor, pLochost, strlen(pLochost)))
    {
    	// it's already a valid URL; don't continue else it would be
    	// misconstrued as a relative URL
    	newURL = pURL;
    	goto cleanup;
    }
#endif

    /* so how do we tell if a full or partial path was specified?
       for now, if 'file:' or 'file://' then assume partial path
       'file:///' or 'file:/' for full path. However file://E: works
       as a full path. 
       file://E:\rmfiles\test.rm - full path
       file:test.rm - look for it in same dir as .rtsl file
       file://hxfiles/test.ra - we assume there is a hxfiles dir in 
       the same dir as the .rtsl file and just prepend full path
     */
    if (!m_urlPrefix.IsEmpty() && !strncasecmp(pszCursor,"file:",5))
    {
	if (!strncasecmp(pszCursor,"file:///",8))
	{    
    	    bPartial = FALSE;
	}
	else if (!strncasecmp(pszCursor,"file://",7))
	{ 	    
    	    bPartial = TRUE;
    	    pszCursor += 7;    	    
	}
	else if (!strncasecmp(pszCursor,"file:/",6))
	{
    	    bPartial = FALSE;
	}
	else
	{    
    	    bPartial = TRUE;
    	    pszCursor += 5;
	}
    }


    if (bPartial)
    {
#ifndef _MACINTOSH
    	//check if its a windows full path
    	const char* pVolumeSep = pszCursor + 1;
	/* There are valid full paths:
	 * file://e:\foo...
	 * file://e|foo...
	 * file://\\oprah\...
	 */
    	if (*pszCursor	    != '\\' && 
	    *pVolumeSep != ':'  && 
	    *pVolumeSep != '\\' &&
	    *pVolumeSep != '|' ) 
#endif
    	{
    	    newURL = m_urlPrefix + pszCursor;
	    goto cleanup;
    	}
    }

    newURL = pURL;

cleanup:

#ifdef _CARBON
    // At this point, we supposedly have a good URL
    //
    // On Mac OS X, this may have failed in assuming that file:/ and file:/// are followed
    // by valid full URLs, which is untrue, so we need to turn the path that follows those
    // into a real URL
    
    int numSlashes = 0;
    
    pszCursor = (const char *) newURL;
    if (!strncasecmp(pszCursor,"file:///", 8)) 		numSlashes = 3;
    else if (!strncasecmp(pszCursor,"file://", 7)) 	numSlashes = 2;
    else if (!strncasecmp(pszCursor,"file:/", 6)) 	numSlashes = 1;
    
    if (numSlashes == 1 || numSlashes == 3)
    {
    	CHXString hfsPath, macURL, params;
    	BOOL kReplaceAll = TRUE;
    	
    	// the path starts after the "file:" and slashes
    	hfsPath = (pszCursor + strlen("file:") + numSlashes);
    	
    	// don't include any parameters in the path
    	INT32 paramsOffset = hfsPath.Find('?');
    	if (paramsOffset != -1)
    	{
    	    params = hfsPath.Mid( paramsOffset );    	    
    	    hfsPath = hfsPath.Left( paramsOffset );
    	}
    	
    	// make slashes into colons like an HFS path
    	hfsPath.FindAndReplace("/", ":", kReplaceAll);
    	
    	OSStatus err = URLFromHFSPath((const char *) hfsPath, macURL);
    	if (err == noErr)
    	{
    	    newURL = macURL;
    	    newURL += params;
    	}
    }
#endif

    return retVal;
    
}

ElementWithinTag
CRAMRenderer::AdjustElementWithinTag(ElementWithinTag elementWithinTag)
{
    switch (elementWithinTag)
    {
    case WithinUnknown:
    case WithinSeq:
	return WithinSeq;
    case WithinPar:
    case WithinSeqInPar:
	return WithinSeqInPar;
    default:
	return elementWithinTag;
    }
}

BOOL
CRAMRenderer::IsNestedMetaSupported(void)
{
    BOOL	    bResult = TRUE;    
    UINT32	    ulParentPersistentVersion = 0;
    UINT32	    ulParentPersistentMajorVersion = 0;
    UINT32	    ulPersistentMajorVersion = 0;
    UINT32	    ulParentPersistentType = PersistentUnknown;
    IHXValues*	    pProperties = NULL;

    HX_ASSERT(m_pPersistentParentRenderer);

    if (HXR_OK == m_pPersistentParentRenderer->GetPersistentProperties(pProperties))
    {
	pProperties->GetPropertyULONG32("PersistentType", ulParentPersistentType);
	pProperties->GetPropertyULONG32("PersistentVersion", ulParentPersistentVersion);

	ulParentPersistentMajorVersion = HX_GET_MAJOR_VERSION(ulParentPersistentVersion);
	ulPersistentMajorVersion = HX_GET_MAJOR_VERSION(m_ulPersistentVersion);

	switch (ulParentPersistentType)
	{
	case PersistentUnknown:
	    bResult = FALSE;
	    break;
	case PersistentSMIL:
	    if (ulParentPersistentMajorVersion == 1)
	    {
		bResult = FALSE;
	    }
	    break;
	default:
	    break;
	}
    }
    HX_RELEASE(pProperties);
    
    return bResult;
}
		
RAMPlayToAssoc*
CRAMRenderer::GetPlayToAssoc(UINT16 uGroupIndex, 
			     UINT16 uTrackIndex)
{
    RAMPlayToAssoc* pPlayToAssoc = NULL;

    if(m_pPlayToAssocList)
    {
	CHXSimpleList::Iterator i;
	for(i=m_pPlayToAssocList->Begin();i!=m_pPlayToAssocList->End();++i)
	{
	    RAMPlayToAssoc* pThisAssoc = (RAMPlayToAssoc*)(*i);
	    if((pThisAssoc->m_uGroupIndex == uGroupIndex) &&
	       (pThisAssoc->m_uTrackIndex == uTrackIndex))
	    {
		pPlayToAssoc = pThisAssoc;
		break;
	    }
	}
    }

    return pPlayToAssoc;
}

RAMPlayToAssoc* 
CRAMRenderer::GetPlayToAssocByMedia(const char* pszMediaID)
{
    RAMPlayToAssoc* pPlayToAssoc = NULL;

    if (pszMediaID && m_pPlayToAssocList)
    {
        LISTPOSITION pos = m_pPlayToAssocList->GetHeadPosition();
        while (pos)
        {
            RAMPlayToAssoc* pListMember =
                (RAMPlayToAssoc*) m_pPlayToAssocList->GetNext(pos);
            if (pListMember && pListMember->m_id == pszMediaID)
            {
                pPlayToAssoc = pListMember;
                break;
            }
        }
     }
 
     return pPlayToAssoc;
}

void
CRAMRenderer::RemoveTracks()
{
    if (m_pTrackMap)
    {
	CHXMapLongToObj::Iterator i;
	for(i = m_pTrackMap->Begin(); i != m_pTrackMap->End();++i)
	{
	    CHXString* pTrack = (CHXString*)(*i);
	    HX_DELETE(pTrack);
	}
	HX_DELETE(m_pTrackMap);
    }
}

void
CRAMRenderer::RemoveAllPlayToAssoc()
{
    if(m_pPlayToAssocList)
    {
	CHXSimpleList::Iterator i = m_pPlayToAssocList->Begin();
	for(; i != m_pPlayToAssocList->End(); ++i)
	{
	    RAMPlayToAssoc* pPlayToAssoc = (RAMPlayToAssoc*)(*i);
	    HX_DELETE(pPlayToAssoc);
	}
    }
    HX_DELETE(m_pPlayToAssocList);
}

void
CRAMRenderer::Cleanup(void)
{
    RemoveTracks();
    RemoveAllPlayToAssoc();
    
    HX_RELEASE(m_pPersistentProperties);
    HX_RELEASE(m_pStreamProperties);
    HX_RELEASE(m_pPersistentParentRenderer);
    HX_RELEASE(m_pPersistentComponentManager);
    HX_RELEASE(m_pStream);
    HX_RELEASE(m_pPlayer);
    
    return;
}