nshxplayer.cpp

linux下的一款播放器

}

nsresult nsHXPlayer::SendBrowserInfo(void)
{
    /* Send the browser's User Agent and JavaScript support level */
    int nLen = 0;
    char *pMsg;
    nsresult result;
    PRBool retval;
    const char* szUserAgent = NPN_UserAgent(m_instance);
    PRBool bHasCallbacks = m_pBackend->AreCallbacksSupported();
    char* szQuotedUserAgent = GetQuotedString(szUserAgent);
    
    nLen = asprintf(&pMsg, "Browser %d %s %d %d\n",
                    m_iPlayerID,
                    szQuotedUserAgent,
                    bHasCallbacks,
                    m_bReceivedXEmbedQuery);

    free(szQuotedUserAgent);
    
    result = m_pBackend->SendMessage(pMsg, nLen);
    free(pMsg);
    if(NS_FAILED(result))
    {
        return NPERR_GENERIC_ERROR;
    }

    result = m_pBackend->ReadGenericResponse(&retval);
    if(NS_FAILED(result))
    {
        return NPERR_GENERIC_ERROR;
    }

    return NPERR_NO_ERROR;    
}    

    
// integration APIs
nsresult nsHXPlayer::Init(nsPluginCreateData * aCreateDataStruct)
{
    int i;
    int nLen = 0;
    char *szEmbedCommand;
    char *pPos;
    char* szEmbed = "Embed ";
    nsresult result;
    char *pMsg;
    PRBool bSrcFound = PR_FALSE;

    int argc = aCreateDataStruct->argc;
    char **argv = aCreateDataStruct->argv;
    char **argn = aCreateDataStruct->argn;

    m_instance = aCreateDataStruct->instance;
    m_bIsInitialized = PR_TRUE;
    
    // See if we were passed a "src" attribute -- if we weren't,
    // we aren't going to get an inital stream
    for(i = 0; i < aCreateDataStruct->argc; i++)
    {
        if(strcasecmp(aCreateDataStruct->argn[i], "src") == 0)
        {
            bSrcFound = PR_TRUE;
        }
    }
    
    if(!bSrcFound)
    {
        m_bIsFirstNewStream = PR_FALSE;
    }
    
    for(i = 0; i < argc; i++)
    {
        // Calculate space for the Embed command
        nLen += strlen(argn[i]) + strlen(argv[i]) + 4; // quotes, equals, and space

        if(strcasecmp(argn[i], "name") == 0)
        {
            if(m_szName)
            {
                free(m_szName);
            }
            m_szName = strdup(argv[i]);
        }
    }

    nLen += strlen(szEmbed) + 2; // '\0', '\n'

    szEmbedCommand = (char*)malloc(nLen);
    pPos = szEmbedCommand; 
    
    pPos += sprintf(pPos, "%s", szEmbed);
    
    for(i = 0; i < argc; i++)
    {
        pPos += sprintf(pPos, "%s='%s' ", argn[i], argv[i]);
    }

    pPos += sprintf(pPos, "\n");
    
    result = m_pBackend->SendMessage(szEmbedCommand, nLen - 1);
    free(szEmbedCommand);
    if(NS_FAILED(result))
    {
        return result;
    }
    
    result = m_pBackend->ReceiveMessage(&pMsg);
    if(NS_FAILED(result))
    {
        return result;
    }

    if(sscanf(pMsg, "%d", &m_iPlayerID) != 1)
    {
        result = NS_ERROR_FAILURE;
    }

    free(pMsg);

    m_pBackend->AddHXPlayer(this);

    return result;
}

nsresult nsHXPlayer::Destroy(void)
{
    SetWindow(NULL);
    m_bIsInitialized = PR_FALSE;
    m_pBackend->RemoveHXPlayer(this);
    
    return NS_OK;
}


NPError nsHXPlayer::SetWindow(NPWindow *aWindow)
{
    char *pMsg;
    PRBool retval;
    int nLen;
    nsresult result;

    if(!m_bSentBrowserInfo)
    {
        /* At this point, XEmbed and Scriptability info should be set */
        SendBrowserInfo();
        m_bSentBrowserInfo = TRUE;
    }
    
    if(aWindow)
    {
        const char *szCommand = (m_bReceivedXEmbedQuery)? "SetWindow": "SetXID";
        
        NPSetWindowCallbackStruct *ws_info = (NPSetWindowCallbackStruct *)aWindow->ws_info;

        // RGG: This XFlush is required by NS4.x, or the display created by
        // hxplay will not see aWindow->window as existing.
        XFlush(ws_info->display);
        
        nLen = asprintf(&pMsg, "%s %d %d %d %d %d %d %d %d %d %d %d\n",
                        szCommand,
                        m_iPlayerID,
                        (int)aWindow->window,
                        aWindow->x,
                        aWindow->y,
                        aWindow->width, 
                        aWindow->height, 
                        aWindow->clipRect.left,
                        aWindow->clipRect.top,
                        aWindow->clipRect.bottom,
                        aWindow->clipRect.right,
                        (int)aWindow->type);
    }
    else
    {
        nLen = asprintf(&pMsg, "UnsetWindow %d\n", m_iPlayerID);
    }

    result = m_pBackend->SendMessage(pMsg, nLen);
    free(pMsg);
    if(NS_FAILED(result))
    {
        return NPERR_GENERIC_ERROR;
    }

    result = m_pBackend->ReadGenericResponse(&retval);
    if(NS_FAILED(result))
    {
        return NPERR_GENERIC_ERROR;
    }

    return NPERR_NO_ERROR;
}

NPError nsHXPlayer::NewStream(NPMIMEType type, NPStream* stream, NPBool /* seekable */, uint16* stype)
{
    char *pMsg;
    int nLen;
    nsresult result;
    PRBool retval;
    unsigned int nStreamLength;
    int nStreamId = 0;

    nStreamLength = ( stream->end > 0 ) ? stream->end : 0; 
    if(nStreamLength > 0)
    {
        const uint32 kMinimumStreamSize = 3; // Enough for the old RA3 header ( ".ra" ).
                
        if( nStreamLength < kMinimumStreamSize )
        {
            return NPERR_NO_DATA;
        }
    }
    
    *stype = NP_NORMAL;

    if(m_bIsFirstNewStream)
    {
        nStreamId = 0;    
    }
    else
    {
        nStreamId = (int)stream;
    }
    
    nLen = asprintf(&pMsg, "NewStream %d %d %s %s %d\n",
                    m_iPlayerID,
                    nStreamId,
                    stream->url,
                    type,
                    nStreamLength);
    
    result = m_pBackend->SendMessage(pMsg, nLen);
    free(pMsg);
    if(NS_FAILED(result))
    {
        return NPERR_GENERIC_ERROR;
    }

    result = m_pBackend->ReadGenericResponse(&retval);
    if(NS_FAILED(result))
    {
        return NPERR_GENERIC_ERROR;
    }

    if(m_bIsFirstNewStream)
    {
        // We return NPERR_NO_DATA so that mozilla doesn't start streaming
        // us the data. We will request this data when the player wishes to start
        // playback. This makes us consistant with the behavior of the Windows
        // plugin, which doesn't start buffering until playback is requested.

        m_bIsFirstNewStream = PR_FALSE;
        
        return NPERR_NO_DATA; // Kevin Foreman wrote this line of code
    }

    return NPERR_NO_ERROR;
}


int32 nsHXPlayer::Write(NPStream *stream, int32 offset, int32 nDataLen, void *pData)
{
    char *pMsg;
    int nLen;
    nsresult result;
    PRBool retval;
    const void *streamID = (void*)stream;
    (void)offset;

    nLen = asprintf(&pMsg, "StreamData %d %d %d\n", m_iPlayerID, (int)streamID, nDataLen);
    result = m_pBackend->SendMessage(pMsg, nLen);
    free(pMsg);
    if(NS_FAILED(result))
    {
        return 0;
    }

    // this is one of the very few commands that is not a single-line
    // the actual stream data follows here...
    result = m_pBackend->SendMessage((const char*)pData, nDataLen);
    if(NS_FAILED(result))
    {
        return 0;
    }

    result = m_pBackend->ReadGenericResponse(&retval);
    if(NS_FAILED(result))
    {
        return 0;
    }

    return nDataLen;
}

NPError nsHXPlayer::DestroyStream(NPStream *stream, NPError /* reason */)
{
    char *pMsg;
    int nLen;
    nsresult result;
    PRBool retval;
    const void *streamID = (void*)stream;
    
    nLen = asprintf(&pMsg, "StreamDone %d %d\n", m_iPlayerID, (int)streamID);
    result = m_pBackend->SendMessage(pMsg, nLen);
    free(pMsg);
    if(NS_FAILED(result))
    {
        return NPERR_GENERIC_ERROR;
    }

    result = m_pBackend->ReadGenericResponse(&retval);
    if(NS_FAILED(result))
    {
        return NPERR_GENERIC_ERROR;
    }

    return NPERR_NO_ERROR;
}

NPError	nsHXPlayer::GetValue(NPPVariable aVariable, void *aValue)
{
    NPError rv = NPERR_NO_ERROR;
    static nsIID scriptableIID = NS_IHXPLAYER_IID;
    nsIID* ptr = NULL;
    
    switch(aVariable)
    {
        case NPPVpluginScriptableInstance:
            // add reference for the caller requesting the object
            m_bReceivedScriptableInstanceQuery = PR_TRUE;
            
            NS_ADDREF(this);
            QueryInterface(NS_GET_IID(nsISupports), (void**)aValue);
            break;
            
        case NPPVpluginScriptableIID:
            ptr = (nsIID *)NPN_MemAlloc(sizeof(nsIID));
            if (ptr)
            {
                *ptr = scriptableIID;
                *(nsIID **)aValue = ptr;
            }
            else
            {
                rv = NPERR_OUT_OF_MEMORY_ERROR;
            }
            break;

        case NPPVpluginNeedsXEmbed:
            *((PRBool *)aValue) = PR_TRUE;
            m_bReceivedXEmbedQuery = PR_TRUE;
            break;

        default:
            break;
    }
    
    return rv;
}

void nsHXPlayer::URLNotify(const char *szUrl, NPReason reason, void * /* pData */ )
{
    switch(reason)
    {            
        case NPRES_DONE:
            printf("Got url %s\n", szUrl);
            break;

        case NPRES_USER_BREAK:
        case NPRES_NETWORK_ERR:
        default:
            printf("Error getting url %s\n", szUrl);
            break;
    }
}

    
nsresult nsHXPlayer::OnGetURL(const char *szUrl, const char *szTarget)
{
    NPError result;
    
    // NULL for the target parameter will tell mozilla to
    // send us the stream starting with NEWStream...
    if(szTarget && *szTarget == '\0')
    {
        szTarget = NULL;
    }

    result = NPN_GetURLNotify(m_instance, szUrl, szTarget, NULL);

    if(result != NPERR_NO_ERROR)
    {
        printf("Error %d invoking GetURL: %d!\n", result, result);
        return NS_ERROR_FAILURE;
    }

    return NS_OK;
}