phNetSource.cpp

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
    Phission : 
        Realtime Vision Processing System
    
    Copyright (C) 2003 Philip D.S. Thoren (pthoren@cs.uml.edu)
    University of Massachusetts at Lowell,
    Laboratory for Artificial Intelligence and Robotics
    
    This file is part of Phission.

 ---------------------------------------------------------------------------*/
#ifdef HAVE_CONFIG_H
    #include <phissionconfig.h>
#endif

#define PRINT_IMAGE_SIZE() 0

/* ---------------------------------------------------------------------- */
#define QUIET_CHECK_RC(rc,perr,fmt,...) if (rc < 0) goto error;
#define TXRX_CHECK_RC(rc,perr,fmt,...) \
{ \
    if (rc == -2) goto error; /* other side disconnected, don't print */ \
    phCHECK_RC(rc,perr,fmt,## __VA_ARGS__); \
}

/* ---------------------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* ---------------------------------------------------------------------- */
#include <ImageConversions.h>
#include <phTimeInterval.h>
#include <phSocket.h>
#include <phNetSource.h>

#include <phbase.h>

/* ---------------------------------------------------------------------- */
/* TODO:  */
struct phNetSourceInfo_t
{
    phSocket    *m_comms;
    char        *m_host;
    uint32_t    m_port;
    uint32_t    m_width;
    uint32_t    m_height;
    uint32_t    m_format;
    char        *m_title;

};

/* ---------------------------------------------------------------------- */
phNetSource::phNetSource(char *path)
{
    phFUNCTION("phNetSource::phNetSource")
    
    rc = this->lock();
    phPRINT_RC(rc,NULL,"this->lock()");
   
    this->setName("phNetSource");
   
    this->m_info = (struct phNetSourceInfo_t *)phCalloc(1,
                        sizeof(struct phNetSourceInfo_t));
    phPRINT_PTR(this->m_info,"phCalloc",
              "phCalloc failed to alloc phNetSourceInfo");
    this->m_info->m_host        = NULL;
    this->m_info->m_port        = 0;
    this->m_info->m_comms       = NULL;
    this->m_info->m_width       = 0;
    this->m_info->m_height      = 0;
    this->m_info->m_format      = phImageNOFORMAT;
    this->m_info->m_title       = NULL;
    
    this->m_orig_format = phImageNOFORMAT;
    this->m_orig_height = 0;
    this->m_orig_width  = 0;
    this->m_orig_size   = 0;

    this->m_is_open     = 0;
    
    this->m_type        = phNetTypeTCP;
    this->m_temp_path   = NULL;
   
    this->m_connected_type = phNetTypeUNKNOWN;
    this->m_user_dimensions = 0;
    
    this->m_reconnect   = 1;
    this->m_server_wait = 1;
        
    if (path != NULL)
    {
        this->setPath(path);
    }
    else
    {
        this->setPath("tcp://localhost:22345");
    }

    /* This applies the default (1) picture/image settings[w,h,format,etc.]
     * (2) channel settings  */
    this->applySettings();
    
    /* opening the device must be explicitly done */
    /* capturing must be explicitly done. */
error:
    rc = this->unlock();
    phPRINT_RC(rc,NULL,"this->unlock()");
    
    return;
}

/* ---------------------------------------------------------------------- */
phNetSource::~phNetSource ()
{
    phFUNCTION("phNetSource::~phNetSource")
  
    rc = this->lock();
    phPRINT_RC(rc,NULL,"this->lock()");

    if (this->isRunning())
    {
        rc = this->stop();
        phPRINT_RC(rc,NULL,"this->stop()");
    }
   
    if (this->isOpen())
    {
        rc = this->close();
        phPRINT_RC(rc,NULL,"this->close()");
    }
 
    phFree(this->m_info);
    
    rc = this->unlock();
    phPRINT_RC(rc,NULL,"this->unlock()");
}

/* ---------------------------------------------------------------------- */
int phNetSource::parsePath( const char  *path,
                            char        **host_ptr,
                            uint32_t    *port_ptr,
                            uint32_t    *type_ptr   )
{
    phFUNCTION("phNetSource::parsePath")
    
    int32_t  i = 0;
    uint32_t type = phNetTypeTCP;
    uint32_t port = 22345;
    char    *host = NULL;
    int32_t  host_start = 0;
    int32_t  host_length = 0;
    int32_t  host_ptr_length = 0;
    int32_t length = (path != NULL) ? strlen(path) : 0;
    
    /* Find the first ':' */
    for (i = 0; ((i < length) && (path[i] != ':')); i++ );

    if (i >= length)
    {
        phCHECK_RC(-1,NULL,"Invalid path string: %s", path);
    }

    if (strncmp("tcp",&(path[0]),i) == 0)
    {
        type = phNetTypeTCP;
    }
    else
    {
        type = phNetTypeUNKNOWN;
    }

    /* Go past the "//" to the host */
    for (i++; ((i < length) && (path[i] != '/')); i++ );
    for (i++; ((i < length) && (path[i] != '/')); i++ );
    
    if (i >= length)
    {
        phCHECK_RC(-1,NULL,"Invalid path string: %s", path);
    }

    /* Parse out the host */
    for (i++, host_start = i, host_length = 0;
         ((i < length) && (path[(i > 0) ? i - 1 : 0] != ':')); 
         i++, host_length++ );

    if ((i >= length) || (host_length <= 0))
    {
        phCHECK_RC(-1,NULL,"Invalid path string: %s", path);
    }

    host = (char *)phCalloc((host_length + 1),sizeof(char));
    phCHECK_PTR(host,"phCalloc",
              "phCalloc failed to allocate host string buffer of length %d",
              host_length );
    
    snprintf(host,host_length+1,"%s",&(path[host_start]));

    /* Get the port from the end of the line */
    port = atoi(&(path[i]));
    
    if (host_ptr != NULL)
    {
        /* Figure out the path length */
        host_ptr_length = (*host_ptr) != NULL ? strlen(*host_ptr) : 0;
    
        /* allocate enough space for the path */
        phDALLOC((*host_ptr),host_ptr_length,(host_length+1),char);

        snprintf(*host_ptr,host_length+1,"%s",host);
    }

    /* Assign the values through the return pointers */
    if (type_ptr != NULL)
        *type_ptr = type;
    if (port_ptr != NULL)
        *port_ptr = port;
    
    phFree(host);

    //phPRINT("-%s:%d-\n",(*host_ptr),(*port_ptr));

    return phSUCCESS;
error:
    phFree(host);
    
    return phFAIL;
}

/* ---------------------------------------------------------------------- */
/* makePath : 
 *
 * This function allocates space to *path, be sure to free it */
/* ---------------------------------------------------------------------- */
int phNetSource::makePath( const char  *host, 
                           uint32_t    port,
                           uint32_t    type,
                           char        **path )
{
    phFUNCTION("phNetSource::makePath")

    uint32_t pathLength     = 0;
    uint32_t length         = 0;
    uint32_t host_length    = 0;
    uint32_t type_length    = 0;
    char *   type_string    = NULL;

    if (path == NULL) return phFAIL;
  
    /* Default to the local machine */
    if (host == NULL)
    {
        host = "localhost";
    }
    host_length = strlen(host);
    
    /* make sure the path is valid */
    port = (port != 0) ? ((port < 65535) ? port : 22345) : 22345;
   
    /* Set up the type string */
    switch (type)
    {
        case phNetTypeTCP:
        default:
            type_string = "tcp://";
            break;
    }
    type_length = strlen(type_string);

    length = type_length + host_length + 1 + 7;
    
    /* Figure out the path length */
    pathLength = (*path) != NULL ? strlen(*path) : 0;
    
    /* allocate enough space for the path */
    phDALLOC((*path),pathLength,length,char);

    sprintf(*path,"%s%s:%u",
            type_string,
            host,
            port );
    return phSUCCESS;
error:
    return phFAIL;
}
/* ---------------------------------------------------------------------- */
int phNetSource::setHost( const char *host )
{
    phFUNCTION("phNetSource::setHost")
    int locked = 0;
   
    phTHIS_LOCK(locked);

    rc = phNetSource::makePath( host,
                                this->m_info->m_port,
                                this->m_type,
                                &this->m_temp_path);
    phCHECK_RC(rc,NULL,"phNetSource::makePath");

    rc = this->setPath(this->m_temp_path);
    phCHECK_RC(rc,NULL,"this->setPath(%s)",this->m_temp_path);

    phTHIS_UNLOCK_RET(locked,phSUCCESS,phFAIL);
}

/* ---------------------------------------------------------------------- */
const char *phNetSource::getHost( )
{
    phFUNCTION("phNetSource::getHost")
    int locked = 0;
    char *retval = NULL;
   
    phTHIS_LOCK(locked);

    retval = this->m_info->m_host;
    
    phTHIS_UNLOCK_RET(locked,((const char *)retval),NULL);
}

/* ---------------------------------------------------------------------- */
int phNetSource::setPort( uint32_t port )
{
    phFUNCTION("phNetSource::setPort")
    int locked = 0;
   
    phTHIS_LOCK(locked);

    rc = phNetSource::makePath( this->m_info->m_host,
                                port,
                                this->m_type,
                                &this->m_temp_path);
    phCHECK_RC(rc,NULL,"phNetSource::makePath");

    rc = this->setPath(this->m_temp_path);
    phCHECK_RC(rc,NULL,"this->setPath(%s)",this->m_temp_path);

    phTHIS_UNLOCK_RET(locked,phSUCCESS,phFAIL);
}

/* ---------------------------------------------------------------------- */
uint32_t phNetSource::getPort( )
{
    phFUNCTION("phNetSource::getPort")
    int locked = 0;
    uint32_t retval = 0;
   
    phTHIS_LOCK(locked);

    retval = this->m_info->m_port;
    
    phTHIS_UNLOCK_RET(locked,retval,0);
}

/* ---------------------------------------------------------------------- */
int phNetSource::setReconnect( int reconnect )
{
    phFUNCTION("phNetSource::setReconnect")
    int locked = 0;
   
    phTHIS_LOCK(locked);

    this->m_reconnect = reconnect;
    
    phTHIS_UNLOCK_RET(locked,phSUCCESS,phFAIL);
}

/* ---------------------------------------------------------------------- */
int phNetSource::getReconnect( )
{
    phFUNCTION("phNetSource::getReconnect")
    int locked = 0;
    int retval = 0;
   
    phTHIS_LOCK(locked);

    retval = this->m_reconnect;
    
    phTHIS_UNLOCK_RET(locked,retval,0);
}

/* ---------------------------------------------------------------------- */
int phNetSource::setServerWait( int wait )
{
    phFUNCTION("phNetSource::setServerWait")
    int locked = 0;
   
    phTHIS_LOCK(locked);

    this->m_server_wait = wait;
    
    phTHIS_UNLOCK_RET(locked,phSUCCESS,phFAIL);
}

/* ---------------------------------------------------------------------- */
int phNetSource::getServerWait( )
{
    phFUNCTION("phNetSource::getServerWait")
    int locked = 0;
    int retval = 0;
   
    phTHIS_LOCK(locked);

    retval = this->m_server_wait;
    
    phTHIS_UNLOCK_RET(locked,retval,0);
}

/* ---------------------------------------------------------------------- */
int phNetSource::getOriginal(   uint32_t *format, 
                                uint32_t *height,
                                uint32_t *width,
                                uint32_t *size )
{
    phFUNCTION("phNetSource::getOriginal")
    int locked = 0;
   
    phMUTEX_LOCK(this->m_orig_lock,locked);

    if (format != NULL)
        *format = this->m_orig_format;
    if (height != NULL)
        *height = this->m_orig_height;
    if (width != NULL)
        *width = this->m_orig_width;
    if (size != NULL)
        *size = this->m_orig_size;
    
    phMUTEX_UNLOCK_RET(this->m_orig_lock,locked,phSUCCESS,phFAIL);
}

/* ---------------------------------------------------------------------- */
uint32_t phNetSource::getOriginalFormat()
{
    phFUNCTION("phNetSource::getOriginalFormat")
    int locked = 0;
    uint32_t retval = 0;
   
    phMUTEX_LOCK(this->m_orig_lock,locked);

    retval = this->m_orig_format;
    
    phMUTEX_UNLOCK_RET(this->m_orig_lock,locked,retval,0);
}

/* ---------------------------------------------------------------------- */
uint32_t phNetSource::getOriginalHeight()
{
    phFUNCTION("phNetSource::getOriginalHeight")
    int locked = 0;
    uint32_t retval = 0;
   
    phMUTEX_LOCK(this->m_orig_lock,locked);

    retval = this->m_orig_height;
    
    phMUTEX_UNLOCK_RET(this->m_orig_lock,locked,retval,0);
}

/* ---------------------------------------------------------------------- */
uint32_t phNetSource::getOriginalWidth()
{
    phFUNCTION("phNetSource::getOriginalWidth")
    int locked = 0;
    uint32_t retval = 0;
   
    phMUTEX_LOCK(this->m_orig_lock,locked);

    retval = this->m_orig_width;
    
    phMUTEX_UNLOCK_RET(this->m_orig_lock,locked,retval,0);
}

/* ---------------------------------------------------------------------- */
uint32_t phNetSource::getOriginalSize()
{
    phFUNCTION("phNetSource::getOriginalSize")
    int locked = 0;
    uint32_t retval = 0;
   
    phMUTEX_LOCK(this->m_orig_lock,locked);

    retval = this->m_orig_size;
    
    phMUTEX_UNLOCK_RET(this->m_orig_lock,locked,retval,0);
}

/* ---------------------------------------------------------------------- */
const char *phNetSource::getTitle()
{
    return (const char *)this->m_info->m_title;
}

/* ---------------------------------------------------------------------- */
int phNetSource::resetDimensions( )
{
    phFUNCTION("phNetSource::resetDimensions")
    int locked  = 0;
    int mlocked = 0;
   
    phTHIS_LOCK(locked);
    phMUTEX_LOCK(this->m_orig_lock,mlocked);

    rc = this->set( this->m_orig_width,
                    this->m_orig_height,
                    NULL,-1,-1,-1,-1,-1,-1,
                    this->m_orig_format);
    phCHECK_RC(rc,NULL,"this->set(%d,%d,NULL,-1,-1,-1,-1,-1,-1,%s)",
             this->m_orig_width,this->m_orig_height,
             phImageFormatToString(this->m_orig_format));

    phMUTEX_UNLOCK(this->m_orig_lock,mlocked);
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:
    phMUTEX_ERROR_UNLOCK(this->m_orig_lock,mlocked);
    phTHIS_ERROR_UNLOCK(locked);

    return phFAIL;
}

/* ---------------------------------------------------------------------- */
int phNetSource::onApplySettings()
{
    phFUNCTION("phNetSource::onApplySettings")
    int retrc = phSUCCESS;

    uint32_t i = 0;

    int ch_init = 0;
    int ch_b = 0;
    int ch_hue = 0;
    int ch_color = 0;
    int ch_con = 0;
    int ch_white = 0;
    int ch_channel = 0;
    int ch_h = 0;
    int ch_w = 0;
    int ch_f = 0;
    int ch_p = 0;
    
    ch_init = ph_int32_array_find(this->m_changed_array, phCHANGE_INIT,NULL);
    /* 
     * this->m_changed_array contains the list of changes that are to 
     *  be applied.
     *
     * This method will call phImageCapture::onApplySettings which will empty
     * the array so that settings are applied only once.
     */
    
#if 0
    /* Copy the image settings into the V4L structure */
    ch_b = ph_int32_array_find(this->m_changed_array,       phCHANGE_BRIGHTNESS,
                            NULL);
    ch_hue = ph_int32_array_find(this->m_changed_array,     phCHANGE_HUE,
                            NULL);
    ch_color = ph_int32_array_find(this->m_changed_array,   phCHANGE_COLOR,
                            NULL);
    ch_con = ph_int32_array_find(this->m_changed_array,     phCHANGE_CONTRAST,
                            NULL);
    ch_white = ph_int32_array_find(this->m_changed_array,   phCHANGE_WHITENESS,
                            NULL);
    if (ch_init > 0) ch_b = ch_hue = ch_color = ch_con = ch_white = 1;
    if ((ch_b > 0) || (ch_hue > 0) || (ch_color > 0) || 
        (ch_con > 0) || (ch_white > 0))
    {
    }
    
    /*--------------------------------------------------------------------*
     * From linux/Documentation/video4linux/API.html:
     *
     * "Each channel can be queries with the VIDIOCGCHAN ioctl call. 
     * Before invoking this function the caller must set the channel 
     * field to the channel that is being queried. On return the 
     * struct video_channel is filled in with information about the 
     * nature of the channel itself."
     *--------------------------------------------------------------------*/
    ch_channel = ph_int32_array_find(this->m_changed_array,phCHANGE_CHANNEL,
                                    NULL);
    if ((ch_channel > 0) || (ch_init > 0))
    {
    }
    /* else, the channel is < 0 or the current chn # */
#endif
    
    /* settings that require the capture to not be in progress for the 
     * phNetSource settings changes to be applied */
    ch_h = ph_int32_array_find(this->m_changed_array, phCHANGE_HEIGHT, NULL);
    ch_w = ph_int32_array_find(this->m_changed_array, phCHANGE_WIDTH, NULL);
    ch_f = ph_int32_array_find(this->m_changed_array, phCHANGE_FORMAT, NULL);

    if (ch_init > 0) ch_h = ch_w = ch_f = 1;

    if ((ch_h > 0) || (ch_w > 0) || (ch_f > 0))
    {
        this->m_user_dimensions = 1;
    }
    
    /* update internal information when the path is given */
    /* Only do this when the thread isn't running and the stream isn't open */
    ch_p = ph_int32_array_find(this->m_changed_array, phCHANGE_PATH, NULL);
    /*
    i = ph_int32_array_get_length(this->m_changed_array);
    phPROGRESS("ch_p:%d ch_init:%d running:%d open:%d length:%u\n",
            ch_p,ch_init,this->isRunning(),this->m_is_open,i);
    */
    if ((ch_init) && (!this->isRunning()))
    {
        this->m_user_dimensions = 0;
    }

    /* These checks prevent changing the path while the thread is active */
    if (((ch_p > 0) || (ch_init > 0)) && 
        ((!(this->isRunning())) && (!(this->m_is_open))))
    {
        retrc = 1;
    }

    rc = this->phImageCapture::onApplySettings();
    phCHECK_RC(rc,NULL,"this->phImageCapture::onApplySettings() failed.");
 
    return retrc;
error:

    return phFAIL;
}

/* ---------------------------------------------------------------------- */
int phNetSource::open(char *path)
{
    phFUNCTION("phNetSource::open")
    
    int locked = 0;

    phTHIS_LOCK(locked);
   
    /* device is already open, close it */
    if (this->isOpen())
    {
        rc = this->close();
        phPRINT_RC(rc,NULL,"this->close()");
    }
  
    if (path != NULL)
    {
        rc = this->setPath( path );
        phPRINT_RC(rc,NULL,"this->setPath( path:%s )",path);
    }
 
    if (!this->isOpen())
    {
        rc = phNetSource::parsePath(path == NULL ? this->getPath() : path,
                                    &this->m_info->m_host,
                                    &this->m_info->m_port,
                                    &this->m_type);
        phPRINT_RC(rc,NULL,"phNetSource::parsePath");
               /* Try to apply all the settings to the V4L device */
        ph_int32_array_append(this->m_changed_array,phCHANGE_INIT);
        this->applySettings();
        
        this->m_is_open = 1;

        this->connect( false );
    }

    phTHIS_UNLOCK(locked);
    
    return phSUCCESS;
error:
    
    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;
}

/* ---------------------------------------------------------------------- */
int phNetSource::isOpen() 
{ 
    return ((this->m_is_open > 0) ? 1 : 0); 
}    

/* ---------------------------------------------------------------------- */
int phNetSource::isConnected() 
{ 
    phFUNCTION("phNetSource::isConnected")
    int locked = 0;
    int retrc = 0;

    phTHIS_LOCK(locked);

    if (this->m_info != NULL)
    {
        if (this->m_connected_type == phNetTypeTCP)
        {
            if (this->m_info->m_comms->isConnected()) retrc = 1;
        }
    }
    
    phTHIS_UNLOCK_RET(locked,retrc,phFAIL);
}    


/* ---------------------------------------------------------------------- */
int phNetSource::close()
{
    phFUNCTION("phNetSource::close")
    int locked = 0;

    phTHIS_LOCK(locked);

    if (this->isRunning())
    {
        rc = this->stop();
        phPRINT_RC(rc,NULL,"this->stop()");
    }

    if (this->m_is_open)
    {
        rc = this->disconnect();
        phCHECK_RC(rc,NULL,"this->disconnect");

        this->m_is_open = 0;
    }

    phTHIS_UNLOCK_RET(locked,phSUCCESS,phFAIL);
}

/* ---------------------------------------------------------------------- */
int phNetSource::connect( bool poll )
{
    phFUNCTION("phNetSource::connect")
    int locked = 0;
    int retrc = phSUCCESS;

    phTHIS_LOCK(locked);
 
    if (this->m_is_open && (!this->isConnected()))
    {
        if (this->m_type == phNetTypeTCP)
        {
            this->m_connected_type = phNetTypeTCP;
            
            if (this->m_info->m_comms != NULL)
            {
                phDelete(this->m_info->m_comms);
            }
            this->m_info->m_comms = new phSocket();
            this->m_info->m_comms->setWarningLevel(0);

            rc = this->tcp_connect(this->m_info->m_comms,
                                   poll,
                                   this->m_info->m_host,
                                   this->m_info->m_port,
                                   &(this->m_info->m_width),
                                   &(this->m_info->m_height),
                                   &(this->m_info->m_format),
                                   &(this->m_info->m_title)
                                   );
            retrc = rc;
            /*phCHECK_RC(rc,NULL,"this->tcp_connect()");*/
        }
    }

    phTHIS_UNLOCK_RET(locked,retrc,phFAIL);
}

/* ---------------------------------------------------------------------- */
int phNetSource::recv(phImage  *image,
                      uint8_t  **image_buf,
                      uint32_t *image_size )
{
    phFUNCTION("phNetSource::recv")
    int locked = 0;

    phTHIS_LOCK(locked);

    if (this->m_is_open && (this->isConnected()))
    {
        if (this->m_connected_type == phNetTypeTCP)
        {
            /* Get the next buffer */
            /* Get next frame */
            rc = this->tcp_recv(this->m_info->m_comms,
                                image,
                                &this->m_info->m_width,
                                &this->m_info->m_height,
                                &this->m_info->m_format,
                                image_buf,
                                image_size);
            TXRX_CHECK_RC(rc,NULL,"this->tcp_recv");
        }
    }
    phTHIS_UNLOCK_RET(locked,phSUCCESS,rc);
}
/* ---------------------------------------------------------------------- */
int phNetSource::disconnect( )
{
    phFUNCTION("phNetSource::disconnect")
    int locked = 0;
    int retrc = phSUCCESS;

    phTHIS_LOCK(locked);
 
    if (this->m_is_open && (this->isConnected()))
    {
        if (this->m_connected_type == phNetTypeTCP)
        {
            rc = this->tcp_disconnect( this->m_info->m_comms );
            phCHECK_RC(rc,NULL,"this->tcp_disconnect()");
        }

        this->m_connected_type = phNetTypeUNKNOWN;
    }

    phTHIS_UNLOCK_RET(locked,retrc,phFAIL);
}

/* ------------------------------------------------------------------------- */
int phNetSource::tcp_connect( phSocket  *comms,
                              bool      poll,
                              char      *host,
                              uint32_t  port,
                              uint32_t  *w,
                              uint32_t  *h,
                              uint32_t  *f,
                              char      **title )
{
    phFUNCTION("phNetSource::tcp_connect")
    int failrc = phFAIL;
  
    char *serverTitle = NULL;
    
    /*
    phPROGRESS("Attempting to connect to server - %s:%d\n",
             host,port );
    */
    /* connect to the server */
    rc = comms->connect(host, port, poll);
    if (!comms->isConnected() || (rc != 0))
    {
        failrc = rc;
        goto error;
    }
    /*phCHECK_RC(rc,NULL,"Failed to connect to %s\n\n", host);*/
    
    /*
    phPROGRESS("Connected to server (rc:%d connected:%d)- %s:%d\n",
             rc,comms->isConnected(),host,port );
     */
    rc = this->tcp_init(comms,&serverTitle,w,h,f);
    phCHECK_RC(rc,NULL,"recv_init");
    
    phFree(*title);
    
    (*title) = (char *)phCalloc(strlen(serverTitle) + 
                                strlen(host) +
                                255,
                                sizeof(char));
    phCHECK_NULLPTR(title,"phCalloc","phCalloc failed to allocate title.");

    sprintf((*title),"%s:%d - %s",
            host,
            port,
            serverTitle );
    
    phFree(serverTitle);

    return phSUCCESS;
error:
    phFree(serverTitle);
    return failrc;
}

/* ------------------------------------------------------------------------- */
int phNetSource::tcp_init( phSocket     *comms,
                           char         **title, 
                           uint32_t     *w, 
                           uint32_t     *h, 
                           uint32_t     *f )
{
    phFUNCTION("phNetSource::tcp_init")

    uint32_t width = 0;
    uint32_t height = 0;
    uint32_t format = phImageNOFORMAT;
    uint32_t titleSize = 0;
    
    rc = comms->recv(&titleSize, sizeof(uint32_t));
    TXRX_CHECK_RC(rc,NULL,"Failed to receive title size\n\n");
    titleSize = phSocket::ntoh32(titleSize);
    DEBUG_PRINT("titleSize:%d\n",titleSize);

    phFree(*title);
    
    *title = (char *)phMalloc(titleSize+5);
    phCHECK_NULLPTR(*title,"phMalloc","phMalloc failed to allocate the title space.");
    memset(*title,0,titleSize+5);
    
    rc = comms->recv(*title, titleSize);
    DEBUG_PRINT("title:%s\n",*title);
    TXRX_CHECK_RC(rc,NULL,"Failed to receive title size\n\n");

    /* receive image dimensions from server */
    rc = comms->recv(&width, sizeof(uint32_t));
    TXRX_CHECK_RC(rc,NULL,"Failed to receive image dimensions(width)\n\n");
    width = phSocket::ntoh32(width);
    DEBUG_PRINT("width:%d\n",width);            

    rc = comms->recv(&height, sizeof(uint32_t));
    TXRX_CHECK_RC(rc,NULL,"Failed to receive image dimensions(height)\n\n");
    height = phSocket::ntoh32(height);
    DEBUG_PRINT("height:%d\n",height);

    rc = comms->recv(&format, sizeof(uint32_t));
    TXRX_CHECK_RC(rc,NULL,"Failed to receive image format \n\n");
    format = phSocket::ntoh32(format);
    DEBUG_PRINT("format:0x%08x\n",format);

    *w = width;
    *h = height;
    *f = format;
    
    return phSUCCESS;
    
error:
    return rc;
}

/* ------------------------------------------------------------------------- */
int phNetSource::tcp_recv(  phSocket     *comms,
                            phImage      *inputImage,
                            uint32_t     *w, 
                            uint32_t     *h, 
                            uint32_t     *f,
                            uint8_t      **data,
                            uint32_t     *data_size
                          )
{
    phFUNCTION("phNetSource::tcp_recv")

    uint32_t    width   = 0;
    uint32_t    height  = 0;
    uint32_t    format  = (uint32_t)phImageNOFORMAT;
    uint32_t    size    = 0;
    
    /* receive image dimensions from server */
    rc = comms->recv(&width, sizeof(uint32_t));
    TXRX_CHECK_RC(rc,NULL,"Failed to receive image dimensions(width)\n\n");
    width = phSocket::ntoh32(width);
    DEBUG_PRINT("width:%d\n",width);            

    rc = comms->recv(&height, sizeof(uint32_t));
    TXRX_CHECK_RC(rc,NULL,"Failed to receive image dimensions(height)\n\n");
    height = phSocket::ntoh32(height);
    DEBUG_PRINT("height:%d\n",height);

    rc = comms->recv(&format, sizeof(uint32_t));
    TXRX_CHECK_RC(rc,NULL,"Failed to receive image format \n\n");
    format = phSocket::ntoh32(format);
    DEBUG_PRINT("format:0x%08x %s\n",format,phImageFormatToString(format));

    rc = comms->recv(&size, sizeof(uint32_t));
    TXRX_CHECK_RC(rc,NULL,"Failed to receive image size \n\n");
    size = phSocket::ntoh32(size);
    DEBUG_PRINT("size:%d\n",size);

    /* receive a image from the server */
    DEBUG_PRINT("receiving image data\n");

    if (size == 0) /* Try to calculate it */
    {
        size = phIMAGE_SIZE(width,height,format);
    }
    
    /* allocate data if it hasn't been initialized yet */
    if (((*data_size) == 0) || (*data == NULL))
    {
        (*data) = (uint8_t *)phMalloc(size);
        phCHECK_NULLPTR(*data,"phMalloc","phMalloc failed to allocate data.");
    }
    /* reallocate the data if the size changes */
    else if (((*data_size) != size) && (*data != NULL))
    {
        (*data) = (uint8_t *)phRealloc((*data),size);
        phCHECK_NULLPTR(*data,"phRealloc","phRealloc failed to allocate data.");
    }
       
    /* Always set this */
    *data_size = size;
    
    /* Get the data from the server */
    rc = comms->recv(*data, *data_size);
    TXRX_CHECK_RC(rc,NULL,"recv for image data failed.");

#if PRINT_IMAGE_SIZE()
    phPROGRESS("format:%s\n",
             phImageFormatToString(format));
    phPROGRESS("recv:%lu\tactual:%lu\n",
             (long unsigned)*data_size,
             (long unsigned)phIMAGE_SIZE(width,height,format));
#endif

    /* allocate space for the image */
    inputImage->setImage(width,height,format,
                        *data_size,
                        *data);
    
    /* keep track */
    *w = width;
    *h = height;
    *f = format;
    
    return phSUCCESS;
error:
    /* might as well... */
    phFree(*data);
    
    *data_size = 0;
    
    return rc;
}

/* ------------------------------------------------------------------------- */
int phNetSource::tcp_disconnect( phSocket  *comms )
{
    phFUNCTION("phNetSource::tcp_disconnect")
  
    /* connect to the server */
    comms->disconnect();
    
    return phSUCCESS;
error:
    return phFAIL;
}

/* ---------------------------------------------------------------------- */
int phNetSource::wakeup()
{
    phFUNCTION("phNetSource::wakeup")

    if (this->m_info != NULL)
    {
        if (this->m_info->m_comms != NULL)
        {
            this->m_info->m_comms->wakeup();
        }
    }

    rc = phImageCapture::wakeup();
    phPRINT_RC(rc,NULL,"phImageCapture::wakeup");

    return phSUCCESS;
}

/* ---------------------------------------------------------------------- */
int phNetSource::cleanup()
{
    phFUNCTION("phNetSource::cleanup")
    int locked = 0;
   
    phTHIS_LOOSE_LOCK(locked);
   
    rc = this->close();
    phPRINT_RC(rc,NULL,"this->close()");
    
    rc = this->phImageCapture::cleanup();
    phPRINT_RC(rc,NULL,"this->phImageCapture::cleanup()");
    
    phTHIS_LOOSE_UNLOCK(locked);
    
    return phSUCCESS;
}

/* ---------------------------------------------------------------------- */
int phNetSource::run()
{
    phFUNCTION("phNetSource::run")
    int i = 0;
    int foo = 0;
    int orig_locked = 0;
        
    /* Returned value from GetNextFrame and a loop count */

    phImage         *output_buffer  = this->getImage();
    
    /* local copies of phNetSource object's member vars */
    phImage  image;
    uint8_t *image_buf  = NULL;
    uint32_t image_size = 0;
    int32_t  cur_format = 0;
    uint32_t cur_width  = 0;
    uint32_t cur_height = 0;
    int      cur_use_user_dimensions = 0;
    
    /* Setup */
    cur_format      = this->m_format;
    cur_width       = this->m_width;
    cur_height      = this->m_height;
    cur_use_user_dimensions = this->m_user_dimensions;
   
    /* Release the thread that spawned this one */
    /* Everything has been copied and everything is ready to start */
    rc = this->signal_running();
    phPRINT_RC(rc,NULL,"this->signal_running");

    /* if we haven't connected by now and we want to wait, then wait */
    while (this->m_server_wait && 
           (!this->isConnected()) &&
           (this->isRunning()))
    {
        rc = this->connect( false );
        
        if ((rc != -5) && (rc < 0)) this->setRunning(0);

        if (!(foo = this->isConnected()))
        {
            phYield();
        }
    }
    
    DEBUG_PRINT("Thread Started\n");
    DEBUG_PRINT("output_buffer: %p\n",output_buffer);
    
    while (this->isRunning() && 
           (this->isConnected() || (this->m_reconnect)))
    {
        /* Get the current width/height/format settings to resize the 
         * input to for output to connected objects */
        rc = this->m_settings_lock.trylock();
        phPRINT_RC(rc,NULL,"this->m_settings_lock.trylock();");

        if (rc == phSUCCESS)
        {
            cur_width = this->m_width;
            cur_height = this->m_height;
            cur_format = this->m_format;
            cur_use_user_dimensions = this->m_user_dimensions;

            rc = this->m_settings_lock.unlock();
            phPRINT_RC(rc,NULL,"this->m_settings_lock.unlock()");
        }
                
        if (!this->isConnected())
        {
            if (this->m_reconnect)
            {
                rc = this->connect(false);

                if (!this->isConnected())
                {
                    phYield();
                }
                
                continue;
            }
            else 
            {
                continue;
            }
        }
        
        if (!this->isRunning()) 
        {
            continue;
        }

        rc = this->recv(&image,&image_buf,&image_size);
        phPRINT_RC(rc,NULL,"this->recv()");

        /* If the recv failed, then disconnect;
         * this->m_reconnect above will try to reconnect*/
        if (rc < 0)
        {
            this->disconnect();
            continue;
        }
        
        /* If there's an error, then go to the beginning
         * of the loop. There's a potential we can reset ourselves */
        if (rc != phSUCCESS) continue;

        /* If we're using user defined size/format settings, then
         * resize and convert */
        if (cur_use_user_dimensions)
        {
            /* Convert to the output format */
            /* Setup the image according to desired output format */
            rc = image.resize(cur_width,cur_height);
            phPRINT_RC(rc,NULL,"image.resize(%d,%d)",
                cur_width,cur_height);

            rc = image.convert(cur_format);
            phPRINT_RC(rc,NULL,"image.convert(%s)",
                    phImageFormatToString(cur_format));
        }
        
        /* if (output_buffer->tryWritelock() == 0) */
        if (output_buffer->writeLock() == 0)
        {
            rc = output_buffer->swapImage(image);
            phCHECK_RC(rc,NULL,"output_buffer->swapImage(image)");
     
            /* Save the current frame's original settings */
            phMUTEX_LOOSE_LOCK(this->m_orig_lock,orig_locked);
            /* \/ ORIGINAL CODE \/ */
            this->m_orig_width  = this->m_info->m_width;
            this->m_orig_height = this->m_info->m_height;
            this->m_orig_format = this->m_info->m_format;
            this->m_orig_size   = image_size;
            phMUTEX_LOOSE_UNLOCK(this->m_orig_lock,orig_locked);
       
            output_buffer->rwUnlock();
        }
        phYield();
    }
        
    phFree(image_buf);
    image_size = 0;
    
    DEBUG_PRINT("Thread returning cleanly\n");
   
    return phSUCCESS;
    
error:
    phPROGRESS("Thread returning with error\n");
    
    phFree(image_buf);
    image_size = 0;

    rc = this->signal_error();
    phPRINT_RC(rc,NULL,"this->signal_error");
    
    return phFAIL;
}

Copyright (C) 2002 - 2007

Philip D.S. Thoren ( pthoren@users.sourceforge.net ) University Of Massachusetts at Lowell Robotics Lab

---