“Introduction To EVS”的版本间的差异 Introduction To EVS 0

EvsResult EvsV4lCamera::startVideoStream(IEvsCameraStream stream)  {
    mStream = stream;
    mVideo.startStream(forwardFrame());
    ...
}
bool VideoCapture::startStream( callback) {
{
    memset(&mBufferInfo, 0, sizeof(mBufferInfo));
    mBufferInfo.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    mBufferInfo.memory   = V4L2_MEMORY_MMAP;
    mBufferInfo.index    = 0;
    ioctl(mDeviceFd, VIDIOC_QUERYBUF, &mBufferInfo);
    //向 V4L2 driver询问buffer info 并要求queue 一块capture buffer
    mPixelBuffer = mmap(NULL, mBufferInfo.length, PROT_READ | PROT_WRITE,
           MAP_SHARED, mDeviceFd, mBufferInfo.m.offset);
    memset(mPixelBuffer, 0, mBufferInfo.length);
    //Queue the first capture buffer
    ioctl(mDeviceFd, VIDIOC_QBUF, &mBufferInfo);
 
    // Start the video stream
    int type = mBufferInfo.type;
    ioctl(mDeviceFd, VIDIOC_STREAMON, &type);
 
    mCallback = callback;
    create_thread( collectFrames());          
}

void VideoCapture::collectFrames() {
    while (mRunMode == RUN) {
        // Wait for a buffer to be ready
        if (ioctl(mDeviceFd, VIDIOC_DQBUF, &mBufferInfo) < 0) {
            break;
        }
        mFrameReady = true;
        if (mCallback) {
            mCallback(&mBufferInfo, mPixelBuffer);
        }
   }
}
 
// This is the async callback from the video camera that tells us a frame is ready
void EvsV4lCamera::forwardFrame(imageBuffer* /*pV4lBuff*/, void* pData) {
    bool readyForFrame = false;
    size_t idx = 0;
 
    // Identify an available buffer to fill
    for (idx = 0; idx < mBuffers.size(); idx++) {
        if (!mBuffers[idx].inUse) {
            // We're going to make the frame busy
            mBuffers[idx].inUse = true;
            mFramesInUse++;
            readyForFrame = true;
        }
    }
 
    if (!readyForFrame) {
        // We need to return the vide buffer so it can capture a new frame
        mVideo.markFrameConsumed();
    } else {
        // Assemble the buffer description we'll transmit below
        BufferDesc buff = {};
        buff.width      = mVideo.getWidth();
        buff.height     = mVideo.getHeight();
        buff.stride     = mStride;
        buff.format     = mFormat;
        buff.usage      = mUsage;
        buff.bufferId   = idx;
        buff.memHandle  = mBuffers[idx].handle;
        // Lock our output buffer for writing
        void *targetPixels = nullptr;
        GraphicBufferMapper &mapper = GraphicBufferMapper::get();
        mapper.lock(buff.memHandle,
                GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_NEVER,
                android::Rect(buff.width, buff.height),
               (void **) &targetPixels);
 
        // Transfer the video image into the output buffer, making any needed
        // format conversion along the way
        // 把V4L2 buffer 复制到GraphicBuffer 并做格式转换
        mFillBufferFromVideo(buff, (uint8_t*)targetPixels, pData, mVideo.getStride());
 
        // Give the video frame back to the underlying device for reuse
        // Note that we do this before making the client callback to give the underlying
        // camera more time to capture the next frame.
        mVideo.markFrameConsumed();
 
        // Issue the (asynchronous) callback to the client -- can't be holding the lock
        auto result = mStream->deliverFrame(buff);
    }
}