Home | History | Annotate | Download | only in highgui
      1 /*M///////////////////////////////////////////////////////////////////////////////////////
      2 //
      3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
      4 //
      5 //  By downloading, copying, installing or using the software you agree to this license.
      6 //  If you do not agree to this license, do not download, install,
      7 //  copy or use the software.
      8 //
      9 //
     10 //                        Intel License Agreement
     11 //                For Open Source Computer Vision Library
     12 //
     13 // Copyright (C) 2008, Nils Hasler, all rights reserved.
     14 // Third party copyrights are property of their respective owners.
     15 //
     16 // Redistribution and use in source and binary forms, with or without modification,
     17 // are permitted provided that the following conditions are met:
     18 //
     19 //   * Redistribution's of source code must retain the above copyright notice,
     20 //     this list of conditions and the following disclaimer.
     21 //
     22 //   * Redistribution's in binary form must reproduce the above copyright notice,
     23 //     this list of conditions and the following disclaimer in the documentation
     24 //     and/or other materials provided with the distribution.
     25 //
     26 //   * The name of Intel Corporation may not be used to endorse or promote products
     27 //     derived from this software without specific prior written permission.
     28 //
     29 // This software is provided by the copyright holders and contributors "as is" and
     30 // any express or implied warranties, including, but not limited to, the implied
     31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
     32 // In no event shall the Intel Corporation or contributors be liable for any direct,
     33 // indirect, incidental, special, exemplary, or consequential damages
     34 // (including, but not limited to, procurement of substitute goods or services;
     35 // loss of use, data, or profits; or business interruption) however caused
     36 // and on any theory of liability, whether in contract, strict liability,
     37 // or tort (including negligence or otherwise) arising in any way out of
     38 // the use of this software, even if advised of the possibility of such damage.
     39 //
     40 //M*/
     41 
     42 // Author: Bill McCord
     43 //
     44 //         Intuitive Automata
     45 
     46 //
     47 // capture video from a socket connection
     48 //
     49 
     50 #include "_highgui.h"
     51 #include <android/log.h>
     52 #include <errno.h>
     53 #include <netdb.h>
     54 #include <unistd.h>
     55 
     56 #define LOGV(...) __android_log_print(ANDROID_LOG_SILENT, LOG_TAG, __VA_ARGS__)
     57 #define LOG_TAG "CVJNI"
     58 
     59 #ifdef NDEBUG
     60 #define CV_WARN(message)
     61 #else
     62 #define CV_WARN(message) fprintf(stderr, "warning: %s (%s:%d)\n", message, __FILE__, __LINE__)
     63 #endif
     64 
     65 #define IMAGE( i, x, y, n )   *(( unsigned char * )(( i )->imageData      \
     66                                     + ( x ) * sizeof( unsigned char ) * 3 \
     67                                     + ( y ) * ( i )->widthStep ) + ( n ))
     68 
     69 class CVCapture_Socket : public CvCapture
     70 {
     71 public:
     72     CVCapture_Socket()
     73     {
     74 		pAddrInfo = 0;
     75 		width = 0;
     76 		height = 0;
     77 		readBufSize = 0;
     78 		readBuf = 0;
     79         frame = 0;
     80     }
     81 
     82     virtual ~CVCapture_Socket()
     83     {
     84         close();
     85     }
     86 
     87     virtual bool open(const char* _address, const char* _port, int _width, int _height);
     88     virtual void close();
     89     virtual double getProperty(int);
     90     virtual bool setProperty(int, double);
     91     virtual bool grabFrame();
     92     virtual IplImage* retrieveFrame();
     93 
     94 protected:
     95 	struct addrinfo *pAddrInfo;
     96 	int width; // the width of the images received over the socket
     97 	int height; // the height of the images received over the socket
     98 	long readBufSize; // the length of the read buffer
     99 	char *readBuf; // the read buffer
    100 
    101     IplImage* frame;
    102 };
    103 
    104 // The open method simply initializes some variables we will need later.
    105 bool CVCapture_Socket::open(const char* _address, const char* _port, int _width, int _height)
    106 {
    107 	// Free the addrinfo if it was allocated.
    108 	if (pAddrInfo)
    109 	{
    110 		freeaddrinfo(pAddrInfo);
    111 		pAddrInfo = 0;
    112 	}
    113 
    114 	// Check the easy stuff first.
    115 	width = _width;
    116 	height = _height;
    117 	if (width <= 0 || height <= 0)
    118 	{
    119 		LOGV("Invalid width or height!");
    120 		return false;
    121 	}
    122 
    123 	// Setup a new addrinfo to support a streaming socket at the given address and port.
    124 	struct addrinfo hints;
    125 	memset(&hints, 0, sizeof hints);
    126 	hints.ai_family = AF_UNSPEC;  // use IPv4 or IPv6, whichever
    127 	hints.ai_socktype = SOCK_STREAM;
    128 	hints.ai_flags = AI_NUMERICHOST;
    129 
    130 	int error = getaddrinfo(_address, _port, &hints, &pAddrInfo);
    131 	if (error)
    132 	{
    133 		char buffer[100];
    134 		sprintf(buffer, "getaddrinfo error: %s", gai_strerror(error));
    135 		LOGV("%s", buffer);
    136 		freeaddrinfo(pAddrInfo);
    137 		pAddrInfo = 0;
    138 		return false;
    139 	}
    140 
    141 	readBufSize = width * height * sizeof(int);
    142 	readBuf = (char*)malloc(readBufSize);
    143 	if (!readBuf)
    144 	{
    145 		LOGV("out of memory error");
    146 		freeaddrinfo(pAddrInfo);
    147 		pAddrInfo = 0;
    148 		return false;
    149 	}
    150 
    151 	return true;
    152 }
    153 
    154 // Close cleans up all of our state and cached data.
    155 void CVCapture_Socket::close()
    156 {
    157 	LOGV("Setting simple vars to 0");
    158 	width = 0;
    159 	height = 0;
    160 	readBufSize = 0;
    161 
    162 	LOGV("Freeing Addr Info");
    163 	if (pAddrInfo)
    164 	{
    165 		freeaddrinfo(pAddrInfo);
    166 		pAddrInfo = 0;
    167 	}
    168 
    169 	LOGV("Freeing Buffer");
    170 	if (readBuf)
    171 	{
    172 		free(readBuf);
    173 		readBuf = 0;
    174 	}
    175 
    176 	LOGV("Releasing Image");
    177 	if (frame)
    178 	{
    179 		cvReleaseImage( &frame );
    180 		frame = 0;
    181 	}
    182 
    183 	LOGV("Done closing Capture Socket");
    184 }
    185 
    186 // Helper to load pixels from a byte stream received over a socket.
    187 static IplImage* loadPixels(char* pixels, int width, int height) {
    188 
    189 	int x, y, pos, int_size = sizeof(int);
    190 	IplImage *img = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 3);
    191 
    192 	for ( y = 0; y < height; y++ ) {
    193 		pos = y * width * int_size;
    194         for ( x = 0; x < width; x++, pos += int_size ) {
    195             // blue
    196             IMAGE( img, x, y, 0 ) = pixels[pos + 3] & 0xFF;
    197             // green
    198             IMAGE( img, x, y, 1 ) = pixels[pos + 2] & 0xFF;
    199             // red
    200             IMAGE( img, x, y, 2 ) = pixels[pos + 1] & 0xFF;
    201         }
    202     }
    203 
    204 	return img;
    205 }
    206 
    207 // Grabs a frame (image) from a socket.
    208 bool CVCapture_Socket::grabFrame()
    209 {
    210 	// First ensure that our addrinfo and read buffer are allocated.
    211 	if (pAddrInfo == 0 || readBuf == 0)
    212 	{
    213 		LOGV("You haven't opened the socket capture yet!");
    214 		return false;
    215 	}
    216 
    217 	// Establish the socket.
    218 	int sockd = socket(pAddrInfo->ai_family, pAddrInfo->ai_socktype, pAddrInfo->ai_protocol);
    219 	if (sockd < 0 || errno != 0)
    220 	{
    221 		char buffer[100];
    222 		sprintf(buffer, "Failed to create socket, errno = %d", errno);
    223 		LOGV("%s", buffer);
    224 		::close(sockd);
    225 		return false;
    226 	}
    227 
    228 	// Now connect to the socket.
    229 	if (connect(sockd, pAddrInfo->ai_addr, pAddrInfo->ai_addrlen) < 0 || errno != 0)
    230 	{
    231 		char buffer[100];
    232 		sprintf(buffer, "socket connection errorno = %d", errno);
    233 		LOGV("%s", buffer);
    234 		::close(sockd);
    235 		return false;
    236 	}
    237 
    238 	// Release the image if it hasn't been already because we are going to overwrite it.
    239 	if (frame)
    240 	{
    241 		cvReleaseImage( &frame );
    242 		frame = 0;
    243 	}
    244 
    245 	// Read the socket until we have filled the data with the space allocated OR run
    246 	// out of data which we treat as an error.
    247 	long read_count, total_read = 0;
    248 	while (total_read < readBufSize)
    249 	{
    250 		read_count = read(sockd, &readBuf[total_read], readBufSize);
    251 		if (read_count <= 0 || errno != 0)
    252 		{
    253 			char buffer[100];
    254 			sprintf(buffer, "socket read errorno = %d", errno);
    255 			LOGV("%s", buffer);
    256 			break;
    257 		}
    258 		total_read += read_count;
    259 	}
    260 
    261 	// If we read all of the data we expected, we will load the frame from the pixels.
    262 	if (total_read == readBufSize)
    263 	{
    264 		frame = loadPixels(readBuf, width, height);
    265 	}
    266 	else
    267 	{
    268 		LOGV("full read of pixels failed");
    269 	}
    270 
    271 	// Close the socket and return the frame!
    272 	::close(sockd);
    273 
    274     return frame != 0;
    275 }
    276 
    277 IplImage* CVCapture_Socket::retrieveFrame()
    278 {
    279     return frame;
    280 }
    281 
    282 double CVCapture_Socket::getProperty(int id)
    283 {
    284 	LOGV("unknown/unhandled property");
    285     return 0;
    286 }
    287 
    288 bool CVCapture_Socket::setProperty(int id, double value)
    289 {
    290     LOGV("unknown/unhandled property");
    291     return false;
    292 }
    293 
    294 CvCapture* cvCreateCameraCapture_Socket( const char *address, const char *port, int width, int height )
    295 {
    296 	CVCapture_Socket* capture = new CVCapture_Socket;
    297 	if ( capture-> open(address, port, width, height) )
    298 		return capture;
    299 
    300 	delete capture;
    301 	return 0;
    302 }
    303