Video4Linux1.cpp

Go to the documentation of this file.

/** @file    Video4Linux1.cpp
 *  @author  Alessandro Polo
 *  @version $Id: Video4Linux1.cpp 3775 2011-01-01 16:38:17Z alex $
 *  @brief
 * File containing methods for the Video4Linux1 class.
 * The header for this class can be found in Video4Linux1.h, check that file
 * for class description.
 ****************************************************************************/
/* Copyright (c) 2007-2011, WOSH - Wide Open Smart Home 
 * by Alessandro Polo - OpenSmartHome.com
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the OpenSmartHome.com WOSH nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY Alessandro Polo ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL Alessandro Polo BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ****************************************************************************/
 
 #include "Video4Linux1.h"
 #include <core/FileSystem.h>
 #include <core/Utilities.h>

 #include <fcntl.h>
 #include <sys/ioctl.h>
// #include <unistd.h>
// #include <sys/types.h>
// #include <sys/stat.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <linux/types.h>


using namespace std;
using namespace wosh;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////// CONSTRUCTORS

Video4Linux1::Video4Linux1( BundleGeneric& bundle )
    : Video4LinuxImpl(bundle) {
    this->fd = -1;
    this->videoBuffer = NULL;
    this->videoBufferSize = 0;

    this->src_depth = 0;

    memset(&this->cap, 0, sizeof(this->cap));
    memset(&this->win, 0, sizeof(this->win));
    memset(&this->vpic, 0, sizeof(this->vpic));


 }

Video4Linux1::~Video4Linux1() {
    Log(LOG_VERBOSE, ":~Video4Linux1(): Destroying.." );
    if ( isThreadRunning() )
        quitThread(20000);

    if ( this->videoBuffer != NULL )
        delete [] videoBuffer; this->videoBuffer = NULL;
 }

//////////////////////////////////////////////////////////////////////////////////////////////// CONSTRUCTORS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////// THREAD RUN

bool Video4Linux1::initializingThread() {
    if ( this->fd < 0 ) return false;
    return true;
 }

void Video4Linux1::runThread() {
    Log(LOG_VERBOSE, ":runThread(): Loop Starting.." );

    if ( this->videoListener != NULL )
        this->videoListener->video_device_connection( 1, this );

    while(this->running) {
        setThreadAlive();
        if ( !this->streaming ) {
            ThreadImpl::sleepForMSec( 500 );
         }
        if ( this->rate != 0 )
            Thread::sleepWhile( this,this->rate, 50, &this->running );

        switch(this->vpic.palette) {
            case VIDEO_PALETTE_RGB24:
                if ( this->videoListener != NULL )
                    this->videoListener->video_frame_available( this );
                break;
            case VIDEO_PALETTE_RGB565:
            case VIDEO_PALETTE_RGB555:
            default:
                break;
         }
     }

    Log(LOG_VERBOSE, ":runThread(): Loop Stopped" );
 }

void Video4Linux1::exitingThread() {

    if ( this->videoListener != NULL )
        this->videoListener->video_device_connection( 0, this );

    Log(LOG_INFO, ":disconnect() : Closing input device.." );
    close(this->fd);
    this->fd = -1;

 }

////////////////////////////////////////////////////////////////////////////////////////////////// THREAD RUN
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////// GETTERS/SETTERS
///////////////////////////////////////////////////////////////////////////////////////////////////// SETTERS

WRESULT Video4Linux1::connectDevice( const std::string& device, unsigned long timeout ) {
    if ( this->fd != -1 || isThreadRunning() ) {
        Log(LOG_CRITICAL, ":connect(%s) FAILED : device already opened!", device.c_str() );
        return WRET_ERR_ILLEGAL_USE;
     }
    // Open the video4link device for reading.
    this->fd = open( device.c_str(), O_RDONLY );
    if ( this->fd < 0 ) {
        Log(LOG_CRITICAL, ":connect(%s) FAILED opening device", device.c_str() );
        return WRET_ERR_INTERNAL;
     }
    //Make sure this is a video4linux device
    if ( ioctl(this->fd,VIDIOCGCAP, &this->cap) < 0 ) {
        Log(LOG_CRITICAL, ":connect(%s) FAILED opening device (not VIDEOGCAP device)", device.c_str() );
        close(this->fd);
        this->fd = -1;
        return WRET_ERR_INTERNAL;
     }
    //Get the video overlay window
    if ( ioctl(this->fd,VIDIOCGWIN, &this->win) < 0 ) {
        Log(LOG_CRITICAL, ":connect(%s) FAILED getting video overlay window (VIDIOCGWIN)", device.c_str() );
        close(this->fd);
        this->fd = -1;
        return WRET_ERR_INTERNAL;
     }
    WRESULT ret_res = setupResolution();
    if ( WFAILED(ret_res) ) {
        Log(LOG_CRITICAL, ":connect(%s) FAILED#%d setupResolution()", device.c_str(), ret_res );
        close(this->fd);
        this->fd = -1;
        return WRET_ERR_INTERNAL;
     }
    this->videoDevice = device;
    Log(LOG_VERBOSE, ":connect(%s,%d) : Starting Thread..", device.c_str(), timeout );
    WRESULT ret_thread = startThread(timeout);
    if ( WFAILED(ret_thread) )
        Log(LOG_CRITICAL, ":connect(%s) FAILED#%d starting thread()", device.c_str(), ret_thread );
    return ret_thread;
 }

WRESULT Video4Linux1::disconnectDevice( unsigned long timeout ) {
    if ( this->fd == -1 || !isThreadRunning() ) {
        Log(LOG_CRITICAL, ":disconnect() FAILED : device not opened!" );
        return WRET_ERR_ILLEGAL_USE;
     }
    WRESULT ret = quitThread(timeout);
    if ( WFAILED(ret) ) {
        Log(LOG_CRITICAL, ":disconnect(%d) FAILED#%d [TimedOut]!", timeout, ret );
     }
    return ret;
 }

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

WRESULT Video4Linux1::setupResolution() {
    if ( this->fd == -1 ) {
        Log(LOG_CRITICAL, ":setupResolution() FAILED : device not opened!" );
        return WRET_ERR_ILLEGAL_USE;
     }
    Log(LOG_VERBOSE, ":setupResolution() : Setting up resolution.." );
    // get the picture properties
    if ( ioctl(this->fd,VIDIOCGPICT, &this->vpic) < 0 ) {
        Log(LOG_CRITICAL, ":setupResolution() FAILED getting picture properties (VIDIOCGPICT)" );
        return WRET_ERR_INTERNAL;
     }
    // now set the color resolution on the camera
    if ( this->cap.type & VID_TYPE_MONOCHROME ) {
        this->vpic.depth = 8;
        this->vpic.palette = VIDEO_PALETTE_GREY;
        if( ioctl(this->fd,VIDIOCSPICT, &this->vpic) < 0 ) {
            Log(LOG_VERBOSE, ":setupResolution() GREY:8 not supported. Trying GREY:6 .." );
            this->vpic.depth = 6;
            if( ioctl(this->fd,VIDIOCSPICT, &this->vpic) < 0 ) {
                Log(LOG_VERBOSE, ":setupResolution() GREY:6 not supported. Trying GREY:4 .." );
                this->vpic.depth = 4;
                if ( ioctl(this->fd,VIDIOCSPICT, &this->vpic) < 0 ) {
                    Log(LOG_CRITICAL, ":setupResolution() FAILED : Unable to find a supported Capture format" );
                    return WRET_ERR_INTERNAL;
                 }
             }
         }
        Log(LOG_INFO, ":setupResolution() : Resolution: GREY / %d bpp", this->vpic.depth );
     }
    else { // supports colors
        this->vpic.depth = 24;
        this->vpic.palette = VIDEO_PALETTE_RGB24;
        if ( ioctl(this->fd,VIDIOCSPICT, &this->vpic) < 0 ) {
            Log(LOG_VERBOSE, ":setupResolution() RGB24:24 not supported. Trying RGB565:16 .." );
            this->vpic.palette = VIDEO_PALETTE_RGB565;
            this->vpic.depth = 16;
            if( ioctl(this->fd,VIDIOCSPICT, &this->vpic) == -1 ) {
                Log(LOG_VERBOSE, ":setupResolution() RGB565:16 not supported. Trying VIDEO_PALETTE_RGB555:15 .." );
                this->vpic.palette = VIDEO_PALETTE_RGB555;
                this->vpic.depth = 15;
                if( ioctl(this->fd, VIDIOCSPICT, &this->vpic) == -1 ) {
                    Log(LOG_CRITICAL, ":setupResolution() FAILED : Unable to find a supported Capture format" );
                    return WRET_ERR_INTERNAL;
                 }
             }
         }
        Log(LOG_INFO, ":setupResolution() : Resolution: RGB / %d bpp", this->vpic.depth );
     }
    if ( this->win.width <= 0 || this->win.height <= 0 ) {
        Log(LOG_CRITICAL, ":setupResolution() FAILED : Invalid size [%d,%d]", this->win.width, this->win.height );
        return WRET_ERR_INTERNAL;
     }
    if ( this->videoBuffer != NULL )
        delete [] videoBuffer; this->videoBuffer = NULL;

    Log(LOG_DEBUG, ":setupResolution() Allocating buffer [%d,%d] * 3", this->win.width, this->win.height );
    this->videoBufferSize = this->win.width * this->win.height * 3;
    this->videoBuffer = new unsigned char[this->videoBufferSize];
    return WRET_OK;
 }

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

WRESULT Video4Linux1::extractFrame( unsigned char* buffer, long size ) {
    if ( buffer == NULL ) return WRET_ERR_PARAM;
    if ( this->fd == -1 ) return WRET_ERR_ILLEGAL_USE;
    read( this->fd, buffer, size ); //BGR
    return WRET_OK;
 }
/*
WRESULT Video4Linux1::extract__() {
    read( this->fd, this->videoBuffer, this->videoBufferSize ); //BGR
    //vipUtility::conv_bgr_rgb((unsigned char*)img.data[0], videoBuffer, win.width, win.height);
    return WRET_OK;
 }
*/