Esempio n. 1
0
FB::BrowserStreamPtr FB::BrowserHost::createStream( const std::string& url,
    const PluginEventSinkPtr& callback, bool cache /*= true*/, bool seekable /*= false*/,
    size_t internalBufferSize /*= 128 * 1024 */ ) const
{
    assertMainThread();
    FB::BrowserStreamPtr ptr(_createStream(url, callback, cache, seekable, internalBufferSize));
    if (ptr) {
        m_streamMgr->retainStream(ptr);
    }
    return ptr;
}
Esempio n. 2
0
/*
 *  ======== SCALESOCKET_TI_create ========
 */
RMS_STATUS SCALESOCKET_TI_create(Int argLength, Char * argData,
    IALG_Fxns *algFxns, Int numInStreams, RMS_WORD inDef[], Int numOutStreams,
    RMS_WORD outDef[], NODE_EnvPtr node)
{
    struct SSKT_Obj *dataPtr;
    Int nodePriority;
    Int segId;

    /* Using bitwise OR to prevent compiler warning */
    argLength |= argLength;
    *argData |= *argData;
    numInStreams |= numInStreams;
    numOutStreams |= numOutStreams;

    /* Get the node's external heap segment Id, if it exists */
    segId = NODE_getHeapSeg(node);

    if (segId < 0) {
        /*
         *  Use heap 0 to allocate the node object if no external heap
         *  was defined for the node.
         */
        segId = 0;
    }


    if ((dataPtr = MEM_calloc(segId, sizeof(SSKT_Obj), 0)) != MEM_ILLEGAL) {

        /* attach socket's context structure to the node environment */
        node->moreEnv = dataPtr;

        /* Save the external heap segment for delete phase. */
        dataPtr->segId = segId;


        /* parse stream definition params, create input stream */
        dataPtr->inStream = _createStream((RMS_StrmDef *)inDef[0],
            STRM_INPUT, &dataPtr->inSize, segId);


        /* parse stream definition params, create output stream */
        dataPtr->outStream = _createStream((RMS_StrmDef *)outDef[0],
            STRM_OUTPUT, &dataPtr->outSize, segId);

        /* check for stream creation failure */
        if((dataPtr->inStream == NULL) || (dataPtr->outStream == NULL)) {
            return (RMS_ESTREAM);
        }


        /* allocate data buffers */
        dataPtr->inBuf = STRM_allocateBuffer(dataPtr->inStream,
            dataPtr->inSize);
        dataPtr->outBuf = STRM_allocateBuffer(dataPtr->outStream,
            dataPtr->outSize);

        /* check for buffer allocation failure */
        if((dataPtr->inBuf == NULL) || (dataPtr->outBuf == NULL)) {
            return (RMS_EOUTOFMEMORY);
        }


        /* create an algorithm instance object */
        nodePriority = NODE_getPri(node);

        if (segId > 0) {
            dataPtr->algHandle = DSKT2_createAlg2(nodePriority,
                    (IALG_Fxns *)algFxns, (IALG_Handle)NULL,
                    (IALG_Params *)NULL, segId);
        }
        else {
            dataPtr->algHandle = DSKT2_createAlg(nodePriority,
                    (IALG_Fxns *)algFxns, (IALG_Handle)NULL,
                    (IALG_Params *)NULL);
        }

        /* check for algorithm instance creation failure */
        if (dataPtr->algHandle == NULL) {
            return (RMS_EOUTOFMEMORY);
        }

        /* activation done during exec phase */
        // dataPtr->algHandle->fxns->algActivate(dataPtr->algHandle);

        return (RMS_EOK);
    }
    else {
        return (RMS_EOUTOFMEMORY);
    }
}