Bool_t MVideo::Init ( Int_t  channel )

private

Definition at line 500 of file MVideo.cc.

References buffer, fBuffers, fFileDesc, fPath, gLog, i, Ioctl(), and IsOpen().

Referenced by Open().

{
    if (IsOpen())
    {
        gLog << warn << "WARNING - Device " << fPath << " already open." << endl;
        return kTRUE;
    }

    gLog << all << "Opening " << fPath << "... " << flush;
    do
    {
        fFileDesc = open(fPath, O_RDWR|O_NONBLOCK, 0);
        usleep(1);
    }
    while (errno==19 && fFileDesc==-1);

    if (fFileDesc == -1)
    {
        gLog << err << "ERROR: " << strerror(errno) << endl;
        return kFALSE;
    }

    gLog << "done (" << fFileDesc << ")." << endl;

    // Close device on exit
    if (fcntl(fFileDesc, F_SETFD, FD_CLOEXEC)<0)
    {
        gLog << err << "ERROR - Call to fnctl (F_SETFD, FD_CLOEXEC) failed." << endl;
        return kFALSE;
    }



/*
    if (!Enumerate(fInputs, VIDIOC_ENUMINPUT))
    {
        gLog << err << "ERROR - Could not enumerate inputs." << endl;
        return kFALSE;
    }
    PrintInputs();

    if (!Enumerate(fStandards, VIDIOC_ENUMSTD))
    {
        gLog << err << "ERROR - Could not enumerate inputs." << endl;
        return kFALSE;
    }
    PrintStandards();
   */

    int index = 3;
    if (Ioctl(VIDIOC_S_INPUT, &index)==-1)
    {
        gLog << err << "ERROR - Could not set input." << endl;
        return kFALSE;
    }

    //check the input
    if (Ioctl(VIDIOC_G_INPUT, &index))
    {
        gLog << err << "ERROR - Could not get input." << endl;
        return kFALSE;
    }

    v4l2_input input;
    memset(&input, 0, sizeof (input));
    input.index = index;
    if (Ioctl(VIDIOC_ENUMINPUT, &input))
    {
        gLog << err << "ERROR - Could enum input." << endl;
        return kFALSE;
    }
    gLog << "*** Input: " << input.name << " (" << input.index << ")" << endl;

    v4l2_std_id st = 4;//standard.id;
    if (Ioctl (VIDIOC_S_STD, &st))
    {
        gLog << err << "ERROR - Could not set standard." << endl;
        return kFALSE;
    }

    v4l2_capability cap;
    if (Ioctl(VIDIOC_QUERYCAP, &cap))
    {
        gLog << err << "ERROR - Could not get capabilities." << endl;
        return kFALSE;
    }

    if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
    {
        gLog << err << "ERROR - No capture capabaility." << endl;
        return kFALSE;
    }

    v4l2_cropcap cropcap;
    cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    if (Ioctl(VIDIOC_CROPCAP, &cropcap)==-1)
    {
    }

    v4l2_crop crop;
    crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    crop.c = cropcap.defrect; /* reset to default */

    if (Ioctl(VIDIOC_S_CROP, &crop))
    {
        gLog << err << "Could not reset cropping." << endl;
        return kFALSE;
    }

    v4l2_format fmt;
    fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width       = 768;
    fmt.fmt.pix.height      = 576;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB32;

    if (Ioctl(VIDIOC_S_FMT, &fmt)==-1)
    {
        gLog << err << "ERROR - Could not set format." << endl;
        return kFALSE;
    }
    // The image format must be selected before buffers are allocated,
    // with the VIDIOC_S_FMT ioctl. When no format is selected the driver
    // may use the last, possibly by another application requested format.

    v4l2_requestbuffers reqbuf;
    memset (&reqbuf, 0, sizeof (reqbuf));

    reqbuf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    reqbuf.memory = V4L2_MEMORY_MMAP;
    reqbuf.count  = 4;//125;

    if (Ioctl(VIDIOC_REQBUFS, &reqbuf)==-1)
    {
        gLog << err << "ERROR - Couldn't setup frame buffers." << endl;
        return kFALSE;
    }

    gLog << all << "Allocated " << reqbuf.count << " frame buffers." << endl;

    for (unsigned int i=0; i<reqbuf.count; i++)
    {
        v4l2_buffer buffer;
        memset (&buffer, 0, sizeof (buffer));

        buffer.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buffer.memory = V4L2_MEMORY_MMAP;
        buffer.index  = i;

        if (Ioctl(VIDIOC_QUERYBUF, &buffer))
        {
            gLog << err << "ERROR - Request of frame buffer " << i << " failed." << endl;
            return kFALSE;
        }

        void *ptr = mmap(NULL, buffer.length,
                         PROT_READ | PROT_WRITE,
                         MAP_SHARED,
                         fFileDesc, buffer.m.offset);

        if (MAP_FAILED == ptr)
        {

            gLog << err << "ERROR - Could not allocate shared memory." << endl;
            return kFALSE;
                // If you do not exit here you should unmap() and free()
                // the buffers mapped so far.
                //perror ("mmap");
                //exit (EXIT_FAILURE);
        }

        fBuffers.push_back(make_pair(buffer, ptr));
    }

    return kTRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function: