C++ sp::findPointer方法代码示例

void NuCachedSource2::onRead(const sp<AMessage> &msg) {
    ALOGV("onRead");

    int64_t offset;
    CHECK(msg->findInt64("offset", &offset));

    void *data;
    CHECK(msg->findPointer("data", &data));

    size_t size;
    CHECK(msg->findSize("size", &size));

    ssize_t result = readInternal(offset, data, size);

    if (result == -EAGAIN) {
        msg->post(50000);
        return;
    }

    Mutex::Autolock autoLock(mLock);
    if (mDisconnecting) {
        mCondition.signal();
        return;
    }

    CHECK(mAsyncResult == NULL);

    mAsyncResult = new AMessage;
    mAsyncResult->setInt32("result", result);

    mCondition.signal();
}

void SimpleSoftOMXComponent::onMessageReceived(const sp<AMessage> &msg) {
    Mutex::Autolock autoLock(mLock);
    uint32_t msgType = msg->what();
    ALOGV("msgType = %d", msgType);
    switch (msgType) {
    case kWhatSendCommand:
    {
        int32_t cmd, param;
        CHECK(msg->findInt32("cmd", &cmd));
        CHECK(msg->findInt32("param", &param));

        onSendCommand((OMX_COMMANDTYPE)cmd, (OMX_U32)param);
        break;
    }

    case kWhatEmptyThisBuffer:
    case kWhatFillThisBuffer:
    {
        OMX_BUFFERHEADERTYPE *header;
        CHECK(msg->findPointer("header", (void **)&header));

        CHECK(mState == OMX_StateExecuting && mTargetState == mState);

        bool found = false;
        size_t portIndex = (kWhatEmptyThisBuffer == msgType)?
                           header->nInputPortIndex: header->nOutputPortIndex;
        PortInfo *port = &mPorts.editItemAt(portIndex);

        for (size_t j = 0; j < port->mBuffers.size(); ++j) {
            BufferInfo *buffer = &port->mBuffers.editItemAt(j);

            if (buffer->mHeader == header) {
                CHECK(!buffer->mOwnedByUs);

                buffer->mOwnedByUs = true;

                CHECK((msgType == kWhatEmptyThisBuffer
                       && port->mDef.eDir == OMX_DirInput)
                      || (port->mDef.eDir == OMX_DirOutput));

                port->mQueue.push_back(buffer);
                onQueueFilled(portIndex);

                found = true;
                break;
            }
        }

        CHECK(found);
        break;
    }

    default:
        TRESPASS();
        break;
    }
}

ssize_t Serializer::onAddSource(const sp<AMessage> &msg) {
    void *obj;
    CHECK(msg->findPointer("source", &obj));

    sp<MediaSource> source = static_cast<MediaSource *>(obj);

    sp<Track> track = new Track(source);
    return mTracks.add(track);
}

status_t VideoRecorderCtrl::prepare(const sp<MetaData> &videoMetaData, void *cbData, int remote_port, 
                                    int vRTPSocket, int vRTCPSocket, psdpcb sdpcb){
	F_LOG;
    
    const char *remoteIP ;
    Surface *previewSurface;
    status_t retval ;
    int64_t tmp ;
    
	videoMetaData->findCString(kKeyP2PRemoteIP, (const char**)&remoteIP);
	videoMetaData->findPointer(kKeyP2PPreviewSurface, (void **) &previewSurface);

	CHECK_EQ(m_omxClient.connect(), OK);
	m_IOMX = m_omxClient.interface();
	retval = m_cameraCtrl.setupCamera(videoMetaData, previewSurface);
    if (retval == OK) {
        retval = m_encoderCtrl.setupEncoder(m_IOMX, m_cameraCtrl.GetCameraSource(), videoMetaData);
        if (retval == OK) {
            m_pRTPWriter = new ARTPStreamer(remote_port, vRTPSocket, vRTCPSocket, remoteIP, cbData, sdpcb);
            if (m_pRTPWriter != NULL) {
                retval = m_pRTPWriter->addSource(m_encoderCtrl.GetEncoderMediaSource().get());
                if ( retval != OK) {
                    LOGE("RTPWriter->addSource failed !!!");
                }
            }else {
                LOGE("Unable to allocate ARTPWriter !!!");
                retval = NO_MEMORY;
            }
        }
        else {
            LOGE("m_encoderCtrl.setupEncoder failed !!!");
        }
    } else {
        LOGE("cameraCtrl.setupCamera failed !!!");
    }
    
    if (retval != OK)
        stop();

    return retval;
}

status_t NuPlayerVPPProcessor::setBufferToVPP(const sp<ABuffer> &buffer, const sp<AMessage> &notifyConsumed) {
    if (!mThreadRunning)
        return VPP_OK;

    if (buffer == NULL || notifyConsumed == NULL)
        return VPP_FAIL;

    /*
     * mLastInputTimeUs >= timeBuf, means this incoming buffer is abnormal,
     * so we never send it to VPP, and mark it as notVppInput
     */
    int64_t timeBuf = getBufferTimestamp(buffer);
    if (mLastInputTimeUs >= timeBuf) {
        notifyConsumed->setInt32("notVppInput", true);
        return VPP_OK;
    }

    IOMX::buffer_id bufferID;
    CHECK(notifyConsumed->findPointer("buffer-id", &bufferID));

    ACodec::BufferInfo *info = findBufferByID(bufferID);
    CHECK(info != NULL);
    sp<GraphicBuffer> graphicBuffer = info->mGraphicBuffer;

    mInput[mInputLoadPoint].mFlags = 0;
    mInput[mInputLoadPoint].mGraphicBuffer = graphicBuffer;
    mInput[mInputLoadPoint].mTimeUs = timeBuf;
    notifyConsumed->setInt32("vppInput", true);
    mInput[mInputLoadPoint].mCodecMsg = notifyConsumed;
    mInput[mInputLoadPoint].mStatus = VPP_BUFFER_LOADED;

    mInputLoadPoint = (mInputLoadPoint + 1) % mInputBufferNum;
    mInputCount ++;
    mLastInputTimeUs = timeBuf;

    return VPP_OK;
}

void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {
    switch (msg->what()) {
        case kWhatSetDataSource:
        {
            ALOGV("kWhatSetDataSource");

            CHECK(mSource == NULL);

            sp<RefBase> obj;
            CHECK(msg->findObject("source", &obj));

            mSource = static_cast<Source *>(obj.get());

            looper()->registerHandler(mSource);

            CHECK(mDriver != NULL);
            sp<NuPlayerDriver> driver = mDriver.promote();
            if (driver != NULL) {
                driver->notifySetDataSourceCompleted(OK);
            }
            break;
        }

        case kWhatPrepare:
        {
            mSource->prepareAsync();
            break;
        }

        case kWhatGetTrackInfo:
        {
            uint32_t replyID;
            CHECK(msg->senderAwaitsResponse(&replyID));

            status_t err = INVALID_OPERATION;
            if (mSource != NULL) {
                Parcel* reply;
                CHECK(msg->findPointer("reply", (void**)&reply));
                err = mSource->getTrackInfo(reply);
            }

            sp<AMessage> response = new AMessage;
            response->setInt32("err", err);

            response->postReply(replyID);
            break;
        }

        case kWhatSelectTrack:
        {
            uint32_t replyID;
            CHECK(msg->senderAwaitsResponse(&replyID));

            status_t err = INVALID_OPERATION;
            if (mSource != NULL) {
                size_t trackIndex;
                int32_t select;
                CHECK(msg->findSize("trackIndex", &trackIndex));
                CHECK(msg->findInt32("select", &select));
                err = mSource->selectTrack(trackIndex, select);
            }

            sp<AMessage> response = new AMessage;
            response->setInt32("err", err);

            response->postReply(replyID);
            break;
        }

        case kWhatPollDuration:
        {
            int32_t generation;
            CHECK(msg->findInt32("generation", &generation));

            if (generation != mPollDurationGeneration) {
                // stale
                break;
            }

            int64_t durationUs;
            if (mDriver != NULL && mSource->getDuration(&durationUs) == OK) {
                sp<NuPlayerDriver> driver = mDriver.promote();
                if (driver != NULL) {
                    driver->notifyDuration(durationUs);
                }
            }

            msg->post(1000000ll);  // poll again in a second.
            break;
        }

        case kWhatSetVideoNativeWindow:
        {
            ALOGV("kWhatSetVideoNativeWindow");

            mDeferredActions.push_back(
                    new ShutdownDecoderAction(
                        false /* audio */, true /* video */));

            sp<RefBase> obj;
//.........这里部分代码省略.........

void SDPLoader::onLoad(const sp<AMessage> &msg) {
    status_t err = OK;
    sp<ASessionDescription> desc = NULL;
    AString url;
    CHECK(msg->findString("url", &url));

    KeyedVector<String8, String8> *headers = NULL;
    msg->findPointer("headers", (void **)&headers);

    if (!(mFlags & kFlagIncognito)) {
        ALOGI("onLoad '%s'", url.c_str());
    } else {
        ALOGI("onLoad <URL suppressed>");
    }

    if (!mCancelled) {
        err = mHTTPDataSource->connect(url.c_str(), headers);

        if (err != OK) {
            ALOGE("connect() returned %d", err);
#ifndef ANDROID_DEFAULT_CODE
            if (err == ERROR_IO) {
                err = ERROR_CANNOT_CONNECT;
                ALOGE("reset err id from %d to %d for connect retry", ERROR_IO, ERROR_CANNOT_CONNECT);
            }	
#endif		
            
        }
    }

    if (headers != NULL) {
        delete headers;
        headers = NULL;
    }

    off64_t sdpSize;
    if (err == OK && !mCancelled) {
        err = mHTTPDataSource->getSize(&sdpSize);

        if (err != OK) {
            //We did not get the size of the sdp file, default to a large value
            sdpSize = DEFAULT_SDP_SIZE;
            err = OK;
        }
    }

    sp<ABuffer> buffer = new ABuffer(sdpSize);

    if (err == OK && !mCancelled) {
        ssize_t readSize = mHTTPDataSource->readAt(0, buffer->data(), sdpSize);

        if (readSize < 0) {
            ALOGE("Failed to read SDP, error code = %ld", readSize);
            err = UNKNOWN_ERROR;
        } else {
            desc = new ASessionDescription;

            if (desc == NULL || !desc->setTo(buffer->data(), (size_t)readSize)) {
                err = UNKNOWN_ERROR;
                ALOGE("Failed to parse SDP");
            }
        }
    }

    mHTTPDataSource.clear();

    sp<AMessage> notify = mNotify->dup();
    notify->setInt32("what", kWhatSDPLoaded);
    notify->setInt32("result", err);
    notify->setObject("description", desc);
    notify->post();
}