pxjpgff.cpp

linux下的一款播放器

    IHXBuffer *pOpaqueData = NULL;
    retVal = m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void **) &pOpaqueData);
    if (retVal != HXR_OK || pOpaqueData == NULL)
    {
        HX_RELEASE(pHeader);
        HX_RELEASE(pMimeType);
        HX_RELEASE(pIntrinsicDurationType);
        return m_pFormatResponse->StreamHeaderReady(retVal, NULL);
    }

    // Compute the size of the opaque buffer
    UINT32 ulOpaqueSize = 4 + // image width
                          4 + // image height
                          4 + // number of packets
                          4 + // display time
                          1 + // url target (either kTargetBrowser or kTargetPlayer)
                          1 + // url type
                          4 + // seek time
                          2 + // url string length
                          (m_pURL ? m_pURL->GetLength() : 0); // url string

    // Set the opaque data size
    retVal = pOpaqueData->SetSize(ulOpaqueSize);
    if (retVal != HXR_OK)
    {
        HX_RELEASE(pHeader);
        HX_RELEASE(pMimeType);
        HX_RELEASE(pIntrinsicDurationType);
        HX_RELEASE(pOpaqueData);
        return m_pFormatResponse->StreamHeaderReady(retVal, NULL);
    }

    // Set the values of the opaque data
    BYTE *pBuffer = pOpaqueData->GetBuffer();
    Pack32(pBuffer, m_ulImageWidth);           // image width
    Pack32(pBuffer, m_ulImageHeight);          // image height
    Pack32(pBuffer, (m_pPacketInfoList ? m_pPacketInfoList->GetCount() : 0)); // number of packets
    Pack32(pBuffer, m_ulDisplayTime);          // display time
    Pack8(pBuffer,  (BYTE) m_ulTarget);        // target (kTargetBrowser or kTargetPlayer)
    Pack8(pBuffer,  (BYTE) m_ulURLType);       // url type (normal, command-pause, command-play, command-seek)
    Pack32(pBuffer, m_ulSeekTime);             // seek time
    Pack16(pBuffer, (UINT16) (m_pURL ? m_pURL->GetLength() : 0)); // url string length
    if (m_pURL && m_pURL->GetLength() > 0)
    {
        memcpy(pBuffer, (BYTE*) (const char*) *m_pURL, m_pURL->GetLength()); /* Flawfinder: ignore */
    }

    // Initialize the time stamp
    INT32 lTime         = (INT32) TransmissionTime(m_ulTotalBytesToSend, m_ulBitRate);
    m_lCurrentTimeStamp = ((INT32) m_ulDisplayTime) - lTime;

    // Compute min preroll
    UINT32 ulMinPreRoll = (UINT32) (m_lCurrentTimeStamp < 0 ? -m_lCurrentTimeStamp : 0);
    if (m_ulPreroll < ulMinPreRoll)
    {
        m_ulPreroll = ulMinPreRoll;
    }

    // Compute predata bytes
    UINT32 ulPreDataBytes;
    if (m_ulDisplayTime > 0)
    {
        ulPreDataBytes = m_ulBitRate * m_ulPreroll / 8000;
        if (ulPreDataBytes > m_ulTotalBytesToSend)
        {
            ulPreDataBytes = m_ulTotalBytesToSend;
        }
    }
    else
    {
        ulPreDataBytes = m_ulTotalBytesToSend;
    }

     // Create buffer to hold ASM rules
    IHXBuffer *pASMRuleBook = NULL;
    retVal                   = m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void **) &pASMRuleBook);
    if (retVal != HXR_OK)
    {
        HX_RELEASE(pHeader);
        HX_RELEASE(pMimeType);
        HX_RELEASE(pIntrinsicDurationType);
        HX_RELEASE(pOpaqueData);
        return m_pFormatResponse->StreamHeaderReady(retVal, NULL);
    }
    // Generate an ASM rule book
    char szASMRuleBook[256]; /* Flawfinder: ignore */
    if (m_bReliable)
    {
        sprintf(szASMRuleBook, "AverageBandwidth=%ld,Priority=10;", m_ulBitRate); /* Flawfinder: ignore */
    }
    else
    {
        sprintf(szASMRuleBook, /* Flawfinder: ignore */
                "AverageBandwidth=%ld,Priority=5;AverageBandwidth=%ld,Priority=9;",
                m_ulBitRate, 0);
    }
    pASMRuleBook->Set((const BYTE *) szASMRuleBook, strlen(szASMRuleBook) + 1);

    // Now fill in all the standard properties for this stream in the stream header
    pHeader->SetPropertyBuffer ("OpaqueData",       pOpaqueData);
    pHeader->SetPropertyULONG32("StreamNumber",     0);
    pHeader->SetPropertyULONG32("MaxBitRate",       m_ulBitRate);
    pHeader->SetPropertyULONG32("AvgBitRate",       m_ulBitRate);
    pHeader->SetPropertyULONG32("MaxPacketSize",    m_ulMaxPacketSize);
    pHeader->SetPropertyULONG32("AvgPacketSize",    m_ulAvgPacketSize);
    pHeader->SetPropertyULONG32("StartTime",        0);
    pHeader->SetPropertyULONG32("PreDataAtStart",   1);
    pHeader->SetPropertyULONG32("PreRollAtStart",   0);
    pHeader->SetPropertyULONG32("PreDataAfterSeek", 0);
    pHeader->SetPropertyULONG32("PreRollAfterSeek", 1);
    pHeader->SetPropertyULONG32("PreData",          ulPreDataBytes);
    pHeader->SetPropertyULONG32("PreRoll",          m_ulPreroll);
    pHeader->SetPropertyULONG32("Duration",         m_ulDuration);
    pHeader->SetPropertyCString("MimeType",         pMimeType);
    pHeader->SetPropertyULONG32("ContentVersion",   m_ulContentVersion);
    pHeader->SetPropertyCString("ASMRuleBook",      pASMRuleBook);
    // We need to declare that this is a discrete media type so that
    // the SMIL 2.0 renderer can treat it as such.  We don't want to
    // just set the duration to 0 for this as that would break old SMIL 1.0
    // content when someone switched image servers to include a new build
    // of the jpg file format plug-in:
    pHeader->SetPropertyCString("intrinsicDurationType",
                                pIntrinsicDurationType);
    // If any one of the transparency-related parameters has been 
    // specified, then we will bump the stream version.
    UINT32 ulStreamVersion = m_ulStreamVersion;
    if (m_pMediaOpacityStr)
    {
        pHeader->SetPropertyCString("mediaOpacity", m_pMediaOpacityStr);
        ulStreamVersion = OPACITY_JPEGSTREAM_VERSION;
    }
    if (m_pMediaChromaKeyStr)
    {
        pHeader->SetPropertyCString("chromaKey", m_pMediaChromaKeyStr);
        ulStreamVersion = OPACITY_JPEGSTREAM_VERSION;
    }
    if (m_pMediaChromaKeyTolStr)
    {
        pHeader->SetPropertyCString("chromaKeyTolerance", m_pMediaChromaKeyTolStr);
        ulStreamVersion = OPACITY_JPEGSTREAM_VERSION;
    }
    if (m_pMediaChromaKeyOpacityStr)
    {
        pHeader->SetPropertyCString("chromaKeyOpacity", m_pMediaChromaKeyOpacityStr);
        ulStreamVersion = OPACITY_JPEGSTREAM_VERSION;
    }
    // Now set the stream version
    pHeader->SetPropertyULONG32("StreamVersion", ulStreamVersion);

    // Set the new state
    m_ulState = kStateStreamHeaderSent;

    // Pass the stream header back to the server
    retVal = m_pFormatResponse->StreamHeaderReady(HXR_OK, pHeader);

    // Release our references to everything we got from the common class factory above
    pOpaqueData->Release();
    pHeader->Release();
    pMimeType->Release();
    HX_RELEASE(pIntrinsicDurationType);
    pASMRuleBook->Release();

    return retVal;
}

STDMETHODIMP CJPEGFileFormat::GetPacket(UINT16 usStreamNum)
{
    // Check for input error
    if (usStreamNum != 0)
    {
        return HXR_UNEXPECTED;
    }

    // Check the state
    if (m_ulState != kStateStreamHeaderSent)
    {
        return HXR_UNEXPECTED;
    }

    // Are we finished sending packets?
    if (!m_pPacketInfoListItr)
    {
        HX_RELEASE(m_pFileBuffer);
        ClearPacketInfoList();
        return m_pFormatResponse->StreamDone(0);
    }

    // Get the current packet info
    PacketInfo* pInfo = NULL;
    if (m_pPacketInfoList)
    {
        pInfo = (PacketInfo*) m_pPacketInfoList->GetNext(m_pPacketInfoListItr);
    }
    if (!pInfo)
    {
        return m_pFormatResponse->PacketReady(HXR_FAIL, NULL);
    }

    // Create an IHXBuffer
    IHXBuffer *pBuffer = NULL;
    HX_RESULT   retVal  = m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void **) &pBuffer);
    if (retVal != HXR_OK)
    {
        return m_pFormatResponse->PacketReady(retVal, NULL);
    }

    // Create an IHXPacket
    IHXPacket *pPacket = NULL;
    retVal = m_pClassFactory->CreateInstance(CLSID_IHXPacket, (void **) &pPacket);
    if (retVal != HXR_OK)
    {
        HX_RELEASE(pBuffer);
        return m_pFormatResponse->PacketReady(retVal, NULL);
    }

    // Set the buffer size
    retVal = pBuffer->SetSize(pInfo->m_ulSize + kJPEGPacketOverhead);
    if (retVal != HXR_OK)
    {
        HX_RELEASE(pPacket);
        HX_RELEASE(pBuffer);
        return m_pFormatResponse->PacketReady(retVal, NULL);
    }

    // Set the opaque buffer's data
    BYTE *pData = pBuffer->GetBuffer();
    Pack32(pData, 0);                                 // dummy packet type
    Pack32(pData, 0);                                 // dummy image handle
    Pack32(pData, pInfo->m_ulSequenceNumber);         // sequence number
    Pack32(pData, 0);                                 // dummy flags
    Pack16(pData, (UINT16) pInfo->m_ulStartingBlock); // starting block
    Pack16(pData, (UINT16) pInfo->m_ulNumBlocks);     // number of blocks

    // Do the copy of the raw data
    memcpy(pData, pInfo->m_pBuffer, pInfo->m_ulSize); /* Flawfinder: ignore */

    // Get the timestamp
    UINT32 ulTimeStamp;
    if (m_ulDisplayTime > 0)
    {
        if (m_lCurrentTimeStamp >= 0)
        {
            ulTimeStamp = (UINT32) m_lCurrentTimeStamp;
        }
        else
        {
            ulTimeStamp = 0;
        }
    }
    else
    {
        ulTimeStamp = 0;
    }

    // Set the packet parameters
    pPacket->Set(pBuffer,           // opaque data
                 ulTimeStamp,       // time stamp
                 0,                 // stream number
                 HX_ASM_SWITCH_ON, // asm flags
                 0);                // asm rule number

    // Increment the time stamp
    INT32 lDataPacketTime = (INT32) TransmissionTime(pInfo->m_ulSize      +  // raw image data
                                                     kJPEGPacketOverhead,    // jpeg packet overhead
                                                     m_ulBitRate);
    m_lCurrentTimeStamp  += lDataPacketTime;

    retVal = m_pFormatResponse->PacketReady(HXR_OK, pPacket);

    // Release the buffer and packet
    HX_RELEASE(pBuffer);
    HX_RELEASE(pPacket);

    return HXR_OK;
}

STDMETHODIMP CJPEGFileFormat::SeekDone(HX_RESULT status)
{
    return HXR_UNEXPECTED;
}

STDMETHODIMP CJPEGFileFormat::Seek(UINT32 ulOffset)
{
    if (m_pFormatResponse)
    {
        return m_pFormatResponse->SeekDone(HXR_OK);
    }
    else
    {
        return HXR_UNEXPECTED;
    }
}

STDMETHODIMP CJPEGFileFormat::Close()
{
    HX_RELEASE(m_pContext);
    if (m_pFileObject)
    {
	m_pFileObject->Close();
	HX_RELEASE(m_pFileObject);
    }
    HX_RELEASE(m_pFormatResponse);
    HX_RELEASE(m_pClassFactory);
    HX_RELEASE(m_pRequest);
    HX_RELEASE(m_pError);
    HX_RELEASE(m_pFileStat);
    HX_RELEASE(m_pFileBuffer);
    ClearPacketInfoList();
    HX_DELETE(m_pPacketInfoList);
    HX_DELETE(m_pURL);
    HX_RELEASE(m_pMediaOpacityStr);
    HX_RELEASE(m_pMediaChromaKeyStr);
    HX_RELEASE(m_pMediaChromaKeyTolStr);
    HX_RELEASE(m_pMediaChromaKeyOpacityStr);

    return HXR_OK;
}

STDMETHODIMP CJPEGFileFormat::CloseDone(HX_RESULT status)
{
    return HXR_OK;
}

STDMETHODIMP CJPEGFileFormat::WriteDone(HX_RESULT status)
{
    // We don't ever write, so we don't expect to get this...
    return HXR_UNEXPECTED;
}

STDMETHODIMP CJPEGFileFormat::PacketReady(IHXPacket *pPacket)
{
    return HXR_OK;
}

STDMETHODIMP CJPEGFileFormat::Subscribe(UINT16 usStreamNumber, UINT16 usRuleNumber)
{
    return HXR_OK;
}

STDMETHODIMP CJPEGFileFormat::Unsubscribe(UINT16 usStreamNumber, UINT16 usRuleNumber)
{
    return HXR_OK;
}

HX_RESULT STDAPICALLTYPE CJPEGFileFormat::HXCreateInstance(IUnknown** ppIUnknown)
{
    HX_RESULT retVal = HXR_OK;

    if (ppIUnknown)
    {
        // Set default
        *ppIUnknown = NULL;
        // Create the object
        CJPEGFileFormat *pObj = new CJPEGFileFormat();
        if (pObj)
        {
            // QI for IUnknown
            retVal = pObj->QueryInterface(IID_IUnknown, (void**) ppIUnknown);
        }
        else
        {
            retVal = HXR_OUTOFMEMORY;
        }
        if (FAILED(retVal))
        {
            HX_DELETE(pObj);
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return HXR_OK;
}

void CJPEGFileFormat::ClearPacketInfoList()
{
    if (m_pPacketInfoList)