├── .gitignore
├── CMakeLists.txt
├── README.txt
├── main.cpp
├── spike_code
    ├── AndroidUsbCamera.cpp
    ├── AndroidUsbCamera.h
    ├── databridge.cpp
    └── databridge.h
├── src
    ├── CMakeLists.txt
    ├── androidusbcamera.cpp
    ├── androidusbcamera.h
    ├── frame.cpp
    ├── frame.h
    ├── framesconverter.cpp
    ├── framesconverter.h
    ├── framescreator.cpp
    ├── framescreator.h
    ├── framesdataextractor.cpp
    ├── framesdataextractor.h
    ├── framesfactory.cpp
    ├── framesfactory.h
    ├── qtInterfaces
    │   ├── CMakeLists.txt
    │   ├── socketinterface.cpp
    │   └── socketinterface.h
    ├── socketconnector.cpp
    └── socketconnector.h
└── test
    ├── CMakeLists.txt
    ├── android_usb_camera_test_base.h
    ├── framescreatortest.cpp
    ├── framescreatortest.h
    ├── framesdataextractortest.cpp
    ├── framesdataextractortest.h
    ├── framesfactorytest.cpp
    ├── framesfactorytest.h
    ├── socketconnectortest.cpp
    └── socketconnectortest.h


/.gitignore:
--------------------------------------------------------------------------------
1 | *~
2 | build
3 | *kdev4*
4 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | project(AndroidUsbCamera)
 2 | cmake_minimum_required(VERSION 2.6)
 3 | find_package(Qt4 REQUIRED)
 4 | add_subdirectory(src)
 5 | 
 6 | include_directories(${QT_INCLUDES} ${CMAKE_CURRENT_BINARY_DIR} src)
 7 | 
 8 | set(AndroidUsbCamera_SRCS main.cpp )
 9 | qt4_automoc(${AndroidUsbCamera_SRCS})
10 | add_executable(AndroidUsbCamera ${AndroidUsbCamera_SRCS})
11 | target_link_libraries(AndroidUsbCamera AndroidUsbCameraStaticLib ${QT_QTCORE_LIBRARY} )
12 | 
13 | if( "x${CMAKE_BUILD_TYPE}" STREQUAL "xdebug")
14 |   ENABLE_TESTING()
15 |   add_subdirectory(test)
16 |   ADD_TEST("SocketConnectorTest" "${CMAKE_CURRENT_BINARY_DIR}/test/SocketConnectorTest")
17 |   ADD_TEST("FramesDataExtractorTest" "${CMAKE_CURRENT_BINARY_DIR}/test/FramesDataExtractorTest")
18 |   ADD_TEST("FramesCreatorTest" "${CMAKE_CURRENT_BINARY_DIR}/test/FramesCreatorTest")
19 |   ADD_TEST("FramesFactoryTest" "${CMAKE_CURRENT_BINARY_DIR}/test/FramesFactoryTest")
20 | endif()


--------------------------------------------------------------------------------
/README.txt:
--------------------------------------------------------------------------------
 1 | Prerequisites: 
 2 | - git
 3 | - QT framework (any version above 4.2 should work)
 4 | Only for unit testing(developers):
 5 | - google mock framework: http://code.google.com/p/googlemock/
 6 | 
 7 | Build instructions:
 8 | - Checkout project
 9 | -- git clone git://github.com/marcogulino/AndroidUsbCamera.git
10 | OR
11 | -- git clone http://github.com/marcogulino/AndroidUsbCamera.git
12 | 
13 | - create a build directory (can be in any place, let's assume it's in
14 |   AndroidUsbCamera/build):
15 | -- cd AndroidUsbCamera; mkdir build
16 | 
17 | - configure the project with cmake:
18 | -- cd build; cmake ../
19 | - build the project:
20 | -- make
21 | Optional:
22 | - Run the tests (build only if CMAKE_BUILD_TYPE is debug):
23 | -- make test (or just type ctest)
24 | 
25 | to have a better output with failing tests, setting the environment variable:
26 | - CTEST_OUTPUT_ON_FAILURE=1
27 | can greatly help.
28 | 
29 | Usage:
30 | - first of all, start USB Webcamera application on your phone
31 | - forward tcp connections with adb:
32 | -- adb forward tcp:8080 tcp:8080
33 | 
34 | - Load vloopback module (sources and instructions: http://www.lavrsen.dk/twiki/bin/view/Motion/VideoFourLinuxLoopbackDevice)
35 | -- modprobe vloopback
36 | - Find the video output device
37 | -- dmesg | grep vloopback
38 | -- look for a string like "[vloopback_init] : Loopback 0 registered, input: video0, output: video1
39 | -- in this case, /dev/video0 is your video output device
40 | - load AndroidUsbCamera application:
41 | -- AndroidUsbCamera /dev/video0
42 | 
43 | 
44 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <QCoreApplication>
 2 | #include "androidusbcamera.h"
 3 | #include <qstringlist.h>
 4 | #include <qtextstream.h>
 5 | #include <QFileInfo>
 6 | #include <QDebug>
 7 | 
 8 | int main(int argc, char** argv)
 9 | {
10 |     QCoreApplication app(argc, argv);
11 |     app.setApplicationName("AndroidUsbCamera");
12 |     QString filename=app.arguments().first();
13 |     if( app.arguments().size() != 2 || ! QFileInfo(app.arguments()[1]).isWritable()) {
14 |       QTextStream(stdout) << "Usage: " << app.applicationName() << " <video device>\n";
15 |       QTextStream(stdout) << "Usually video device is one of /dev/videoN files\n";
16 |       QTextStream(stdout) << "Best match finding the \"output\" device for vloopback running \"dmesg | grep vloopback\"\n";
17 |       return 1;
18 |     }
19 |     AndroidUsbCamera camera;
20 |     return app.exec();
21 | }
22 | 


--------------------------------------------------------------------------------
/spike_code/AndroidUsbCamera.cpp:
--------------------------------------------------------------------------------
 1 | #include "AndroidUsbCamera.h"
 2 | #include "databridge.h"
 3 | #include <QTcpSocket>
 4 | 
 5 | AndroidUsbCamera::AndroidUsbCamera()
 6 | {
 7 |   QAbstractSocket *socket = new QTcpSocket(this);
 8 |   databridge=new DataBridge(socket, this);
 9 | }
10 | 
11 | void AndroidUsbCamera::stream()
12 | {
13 |   databridge->stream();
14 | }
15 | 
16 | void AndroidUsbCamera::close()
17 | {
18 |   databridge->close();
19 | }
20 | 
21 | AndroidUsbCamera::~AndroidUsbCamera()
22 | {
23 | 
24 | }
25 | 
26 | 
27 | #include "AndroidUsbCamera.moc"
28 | 


--------------------------------------------------------------------------------
/spike_code/AndroidUsbCamera.h:
--------------------------------------------------------------------------------
 1 | #ifndef AndroidUsbCamera_H
 2 | #define AndroidUsbCamera_H
 3 | 
 4 | #include <QtCore/QObject>
 5 | class DataBridge;
 6 | class AndroidUsbCamera : public QObject
 7 | {
 8 | Q_OBJECT
 9 | public:
10 |     AndroidUsbCamera();
11 |     virtual ~AndroidUsbCamera();
12 | 
13 |   public slots:
14 |     void stream();
15 |     void close();
16 |   private:
17 |     DataBridge *databridge;
18 |     
19 | };
20 | 
21 | #endif // AndroidUsbCamera_H
22 | 


--------------------------------------------------------------------------------
/spike_code/databridge.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |     <one line to give the program's name and a brief idea of what it does.>
  3 |     Copyright (C) <year>  <name of author>
  4 | 
  5 |     This program is free software; you can redistribute it and/or modify
  6 |     it under the terms of the GNU General Public License as published by
  7 |     the Free Software Foundation; either version 2 of the License, or
  8 |     (at your option) any later version.
  9 | 
 10 |     This program is distributed in the hope that it will be useful,
 11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 |     GNU General Public License for more details.
 14 | 
 15 |     You should have received a copy of the GNU General Public License along
 16 |     with this program; if not, write to the Free Software Foundation, Inc.,
 17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 18 | 
 19 | */
 20 | 
 21 | #include "databridge.h"
 22 | #include <QDebug>
 23 | // V4l stuff
 24 | #include <linux/videodev2.h>
 25 | #include <linux/videodev.h>
 26 | #include <sys/types.h>
 27 | #include <sys/stat.h>
 28 | #include <fcntl.h>
 29 | #include <unistd.h>
 30 | #include <sys/ioctl.h>
 31 | #include <errno.h>
 32 | 
 33 | 
 34 | extern "C" {
 35 | #include <libavcodec/avcodec.h>
 36 | #include <libavformat/avformat.h>
 37 | #include <libswscale/swscale.h>
 38 | }
 39 | 
 40 | 
 41 | DataBridge::DataBridge ( QAbstractSocket* socket, QObject* parent ) : QObject ( parent )
 42 | {
 43 |   this->socket=socket;
 44 |   videodev.setFileName("/dev/video1");
 45 | }
 46 | 
 47 | void DataBridge::close()
 48 | {
 49 |   qDebug() << "Closing device";
 50 |   videodev.close();
 51 | }
 52 | 
 53 | 
 54 | void DataBridge::stream()
 55 | {
 56 |   av_register_all();
 57 |   bool first_read=true;
 58 | 
 59 |   socket->connectToHost("localhost", 8080, QIODevice::ReadOnly);
 60 |   if( ! socket->waitForConnected()) return;
 61 |   struct video_picture vid_pic;
 62 |   struct video_window vid_win;
 63 |   struct video_capability vid_caps;
 64 | 
 65 |   videodev.open(QIODevice::ReadWrite);
 66 |   int dev=videodev.handle();
 67 | 
 68 |   
 69 | //   int dev=open("/dev/video1", O_SYNC, O_RDWR);
 70 | //   if(dev==-1) perror("error on open: ");
 71 |   if(ioctl(dev, VIDIOCGCAP, &vid_caps)==-1) perror("error on VIDIOCGCAP: ");
 72 |   if(ioctl(dev, VIDIOCGPICT, &vid_pic)==-1) perror("error on VIDIOCGPICT: ");
 73 |   vid_pic.palette=VIDEO_PALETTE_RGB24;
 74 | 
 75 |   if(ioctl(dev, VIDIOCSPICT, &vid_pic)==-1) perror("error on VIDIOCSPICT: ");
 76 |   if(ioctl(dev, VIDIOCGWIN, &vid_win) == -1) perror("error on VIDIOCGWIN: ");
 77 |   vid_win.width=320;
 78 |   vid_win.height=240;
 79 |   if(ioctl(dev, VIDIOCSWIN, &vid_win) == -1) perror("error on VIDIOCSWIN: ");
 80 | 
 81 | //   int winSize=vid_win.width * vid_win.height * 3;
 82 | 
 83 |   int winSize=(vid_win.width*vid_win.height) * 12 / 8;
 84 |   int w = vid_win.width;
 85 |   int h = vid_win.height;
 86 |   int destdata_size = avpicture_get_size(PIX_FMT_RGB24, w, h);
 87 |   uint8_t *dest_data = new uint8_t[destdata_size];
 88 |   uint8_t *src_data = new uint8_t[winSize];
 89 |   QByteArray data;
 90 |   AVFrame         *pFrameRGB;
 91 |   AVFrame         *pFrameNV21;
 92 |   while(socket->waitForReadyRead()) {
 93 |     data.append(socket->readAll());
 94 |     if(first_read) {
 95 |       first_read=false;
 96 | //       qDebug() << "Got first " << data.size() << " bytes";
 97 | //       qDebug() << "Original bytearray: " << data.toHex();
 98 | //       qDebug() << "Stripping header: " << QByteArray(data.data(), 4).toHex();
 99 |       data.remove(0,4);
100 | //       qDebug() << "Remaining: " << data.toHex() << ", " << data.size() << " bytes";
101 |     }
102 |     if(data.size()>=winSize) {
103 |       qDebug() << "Got data size: " << data.size();
104 |       QByteArray tempBA=data.left(winSize);
105 |       
106 |       
107 |       
108 |       static struct SwsContext *img_convert_ctx;
109 | 
110 |       if(img_convert_ctx == NULL) {	      
111 | 	      img_convert_ctx = sws_getContext(w, h, 
112 | 					      PIX_FMT_NV12, 
113 | 					      w, h, PIX_FMT_RGB24, SWS_BICUBIC,
114 | 					      NULL, NULL, NULL);
115 | 	      if(img_convert_ctx == NULL) {
116 | 		      qDebug()<< "Cannot initialize the conversion context!";
117 | 		      return;
118 | 	      }
119 |       }
120 |       pFrameRGB=avcodec_alloc_frame();
121 |       pFrameNV21=avcodec_alloc_frame();
122 |       qDebug() << "fill in pFrameNV21";
123 |       avpicture_fill((AVPicture *)pFrameNV21,  (uint8_t*) data.data(), PIX_FMT_NV21, w, h);
124 |       qDebug() << "fill in pFrameRGB";
125 |       avpicture_fill((AVPicture *)pFrameRGB, dest_data, PIX_FMT_RGB24, w, h);
126 |       qDebug() << "doing sws_scale";
127 |       int ret = sws_scale(img_convert_ctx, pFrameNV21->data, pFrameNV21->linesize, 0, 240, pFrameRGB->data, pFrameRGB->linesize);
128 |       qDebug() << "Ret: " << ret;
129 |       int could_write = videodev.write((char*)dest_data, destdata_size );
130 | //       write(videofile, tempBA.data(), tempBA.size());
131 |       data.remove(0, winSize);
132 |       if(could_write>-1) {
133 | 	qDebug() << "wrote " << could_write << "bytes..";
134 | 	first_read=true;
135 |       }
136 |       else
137 | 	qDebug() << "Error writing "<< tempBA.size() << " bytes of data on file descriptor " << dev << ": " << could_write << " " << strerror(errno);
138 |     }
139 |   }
140 |   videodev.close();
141 | }
142 | 


--------------------------------------------------------------------------------
/spike_code/databridge.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef DATABRIDGE_H
22 | #define DATABRIDGE_H
23 | 
24 | #include <qt4/QtCore/QObject>
25 | #include <QAbstractSocket>
26 | #include <QFile>
27 | 
28 | class DataBridge : public QObject
29 | {
30 |   public:
31 |     DataBridge ( QAbstractSocket * socket, QObject * parent = 0 );
32 |     void stream();
33 |     void close();
34 | 
35 |   private:
36 |     QAbstractSocket *socket;
37 |     QFile videodev;
38 | };
39 | 
40 | #endif // DATABRIDGE_H
41 | 


--------------------------------------------------------------------------------
/src/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | include_directories(${QT_INCLUDES} ${CMAKE_CURRENT_BINARY_DIR})
2 | set(AndroidUsbCameraStaticLib_SRCS framesconverter.cpp androidusbcamera.cpp framesfactory.cpp frame.cpp framescreator.cpp framesdataextractor.cpp socketconnector.cpp )
3 | qt4_automoc(${AndroidUsbCameraStaticLib_SRCS})
4 | add_library( AndroidUsbCameraStaticLib STATIC ${AndroidUsbCameraStaticLib_SRCS})
5 | target_link_libraries(AndroidUsbCameraStaticLib qtInterfaces_lib -lavformat -lswscale ${QT_QTCORE_LIBRARY} ${QT_QTNETWORK_LIBRARY}  )
6 | 
7 | add_subdirectory(qtInterfaces)


--------------------------------------------------------------------------------
/src/androidusbcamera.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #include "androidusbcamera.h"
22 | #include "framesconverter.h"
23 | #include "socketconnector.h"
24 | #include <QTcpSocket>
25 | 
26 | #include <QDebug>
27 | #include <QTimer>
28 | #include <QCoreApplication>
29 | 
30 | AndroidUsbCamera::AndroidUsbCamera(QObject *parent) : QObject(parent) {
31 |   qDebug() << "Initializing objects...";
32 |   socketInterface=new SocketInterface(new QTcpSocket(this), this);
33 |   framesFactory=new FramesFactory(this);
34 |   framesCreator=new FramesCreator(framesFactory, this);
35 |   framesDataExtractor=new FramesDataExtractor(framesCreator, this);
36 |   connector=new SocketConnector(socketInterface, framesDataExtractor, this);
37 |   framesConverter=new FramesConverter(this);
38 |   connect(framesCreator, SIGNAL(frameProcessed(Frame*)), framesConverter, SLOT(gotFrame(Frame*)));
39 |   connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), framesConverter, SLOT(quit()));
40 |   framesConverter->start();
41 |   connector->openConnection();
42 | }
43 | 
44 | #include "androidusbcamera.moc"
45 | 
46 | 


--------------------------------------------------------------------------------
/src/androidusbcamera.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef ANDROIDUSBCAMERA_H
22 | #define ANDROIDUSBCAMERA_H
23 | 
24 | #include <qt4/QtCore/QObject>
25 | 
26 | class Frame;
27 | class SocketInterface; 
28 | class FramesFactory   ;
29 | class FramesCreator    ;
30 | class FramesDataExtractor;
31 | class SocketConnector     ;
32 | class FramesConverter;
33 | 
34 | class AndroidUsbCamera : public QObject
35 | {
36 |   Q_OBJECT
37 |   public:
38 |     AndroidUsbCamera(QObject *parent=0);
39 |   private:
40 |     SocketInterface *socketInterface;
41 |     FramesFactory *framesFactory;
42 |     FramesCreator *framesCreator;
43 |     FramesDataExtractor *framesDataExtractor;
44 |     SocketConnector *connector;
45 |     FramesConverter *framesConverter;
46 | };
47 | 
48 | #endif // ANDROIDUSBCAMERA_H
49 | 


--------------------------------------------------------------------------------
/src/frame.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #include "frame.h"
22 | 
23 | class FramePrivate {
24 |   public:
25 |     QByteArray frameData;
26 |     quint16 width;
27 |     quint16 height;
28 |     quint16 bitsPerPixel;
29 | };
30 | 
31 | Frame::Frame ( quint16 width, quint16 height, quint16 bitsPerPixel, QObject* parent ) : QObject ( parent )
32 | {
33 |   d=new FramePrivate;
34 |   d->width=width;
35 |   d->height=height;
36 |   d->bitsPerPixel=bitsPerPixel;
37 |   d->frameData.reserve(totalbytes());
38 | }
39 | 
40 | Frame::~Frame()
41 | {
42 |   delete d;
43 | }
44 | 
45 | QByteArray* Frame::frameData()
46 | {
47 |   return &(d->frameData);
48 | }
49 | 
50 | quint64 Frame::totalbytes()
51 | {
52 |   return (d->bitsPerPixel * d->width * d->height) / 8;
53 | }
54 | 
55 | quint16 Frame::height()
56 | {
57 |   return d->height;
58 | }
59 | 
60 | quint16 Frame::width()
61 | {
62 |   return d->width;
63 | }
64 | 
65 | #include "frame.moc"
66 | 
67 | 


--------------------------------------------------------------------------------
/src/frame.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef FRAME_H
22 | #define FRAME_H
23 | 
24 | #include <QObject>
25 | 
26 | class FramePrivate;
27 | class Frame : public QObject
28 | {
29 |   Q_OBJECT
30 |   public:
31 |     Frame(quint16 width, quint16 height, quint16 bitsPerPixel, QObject *parent=0);
32 |     ~Frame();
33 |     virtual quint64 totalbytes();
34 |     virtual quint16 width();
35 |     virtual quint16 height();
36 |     virtual QByteArray *frameData();
37 |   private:
38 |     FramePrivate *d;
39 | };
40 | 
41 | #endif // FRAME_H
42 | 


--------------------------------------------------------------------------------
/src/framesconverter.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |     <one line to give the program's name and a brief idea of what it does.>
  3 |     Copyright (C) <year>  <name of author>
  4 | 
  5 |     This program is free software; you can redistribute it and/or modify
  6 |     it under the terms of the GNU General Public License as published by
  7 |     the Free Software Foundation; either version 2 of the License, or
  8 |     (at your option) any later version.
  9 | 
 10 |     This program is distributed in the hope that it will be useful,
 11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 |     GNU General Public License for more details.
 14 | 
 15 |     You should have received a copy of the GNU General Public License along
 16 |     with this program; if not, write to the Free Software Foundation, Inc.,
 17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 18 | 
 19 | */
 20 | 
 21 | #include "framesconverter.h"
 22 | #include <QFile>
 23 | #include <QDebug>
 24 | 
 25 | #ifdef __linux__
 26 | 
 27 | extern "C" {
 28 | #include <libavcodec/avcodec.h>
 29 | #include <libavformat/avformat.h>
 30 | #include <libswscale/swscale.h>
 31 | }
 32 | #include <linux/videodev.h>
 33 | #include <sys/ioctl.h>
 34 | #include "frame.h"
 35 | #include <QCoreApplication>
 36 | #include <qstringlist.h>
 37 | 
 38 | 
 39 | class VideoConversionData {
 40 |   public:
 41 |     struct video_picture vid_pic;
 42 |     struct video_window vid_win;
 43 |     struct video_capability vid_caps;
 44 | };
 45 | 
 46 | 
 47 | FramesConverter::~FramesConverter()
 48 | {
 49 |   // TODO move these in another slot. Which one?
 50 |   delete videoConversionData;
 51 | 
 52 |   videodev->close();
 53 |   delete videodev;
 54 | }
 55 | 
 56 | 
 57 | void FramesConverter::run()
 58 | {
 59 |   QString filename=QCoreApplication::arguments()[1];
 60 |   videodev=new QFile(filename, 0);
 61 |   if(! videodev->open(QIODevice::ReadWrite)) {
 62 |     qDebug() << "Could not open video device: " << videodev->errorString() << " (" << videodev->error() << ")";
 63 |     QThread::exit(1);
 64 |     return;
 65 |   }
 66 |   av_register_all();
 67 |   videoConversionData=new VideoConversionData;
 68 |   QThread::run();
 69 | }
 70 | 
 71 | #define V4L_DEST_FORMAT VIDEO_PALETTE_YUV420P
 72 | #define LIBAV_DEST_FORMAT PIX_FMT_YUVJ420P
 73 | 
 74 | void FramesConverter::gotFrame(Frame* frame)
 75 | {
 76 |   int dev=videodev->handle();
 77 |   if(ioctl(dev, VIDIOCGCAP, &(videoConversionData->vid_caps ))==-1) reportError("error on VIDIOCGCAP: ");
 78 |   if(ioctl(dev, VIDIOCGPICT, &(videoConversionData->vid_pic))==-1) reportError("error on VIDIOCGPICT: ");
 79 |   (videoConversionData->vid_pic).palette=V4L_DEST_FORMAT;
 80 | 
 81 |   if(ioctl(dev, VIDIOCSPICT, &(videoConversionData->vid_pic))==-1) reportError("error on VIDIOCSPICT: ");
 82 |   if(ioctl(dev, VIDIOCGWIN, &(videoConversionData->vid_win)) == -1) reportError("error on VIDIOCGWIN: ");
 83 |   videoConversionData->vid_win.width=frame->width();
 84 |   videoConversionData->vid_win.height=frame->height();
 85 |   if(ioctl(dev, VIDIOCSWIN, &(videoConversionData->vid_win)) == -1) reportError("error on VIDIOCSWIN: ");
 86 |   
 87 |   int destdata_size = avpicture_get_size(LIBAV_DEST_FORMAT, frame->width(), frame->height());
 88 |   uint8_t *dest_data = new uint8_t[destdata_size];
 89 | //   uint8_t *src_data = new uint8_t[frame->totalbytes()];
 90 |   
 91 |   AVFrame         *pFrameRGB;
 92 |   AVFrame         *pFrameNV21;
 93 |   
 94 |   static struct SwsContext *img_convert_ctx;
 95 | 
 96 |   if(img_convert_ctx == NULL) {       
 97 |       img_convert_ctx = sws_getContext(frame->width(), frame->height(), 
 98 |                       PIX_FMT_NV21, 
 99 |                       frame->width(), frame->height(), LIBAV_DEST_FORMAT, SWS_BICUBIC,
100 |                       NULL, NULL, NULL);
101 |       if(img_convert_ctx == NULL) {
102 |           qDebug()<< "Cannot initialize the conversion context!";
103 |           return;
104 |       }
105 |   }
106 |   pFrameRGB=avcodec_alloc_frame();
107 |   pFrameNV21=avcodec_alloc_frame();
108 |   avpicture_fill((AVPicture *)pFrameNV21,  (uint8_t*) frame->frameData()->data(), PIX_FMT_NV21, frame->width(), frame->height());
109 |   avpicture_fill((AVPicture *)pFrameRGB, dest_data, LIBAV_DEST_FORMAT, frame->width(), frame->height());
110 |   int ret = sws_scale(img_convert_ctx, pFrameNV21->data, pFrameNV21->linesize, 0, frame->height(), pFrameRGB->data, pFrameRGB->linesize);
111 |   int could_write = videodev->write((char*)dest_data, destdata_size );
112 | 
113 |   delete pFrameNV21;
114 |   delete pFrameRGB;
115 | //   delete img_convert_ctx;
116 |   delete [] dest_data;
117 |   delete frame;
118 | //   delete [] src_data;
119 | }
120 | 
121 | void FramesConverter::reportError(const char* errorPrefix)
122 | {
123 |   qDebug() << errorPrefix << strerror(errno);
124 | }
125 | #else
126 | #warning You are compiling an application that will do nothing, since you are not on GNU/Linux
127 | #warning If you are happy with that...
128 | void FramesConverter::gotFrame(Frame* frame)
129 | {
130 |   QTextStream out(stdout);
131 |   out << "Got frame, but can't write it nowhere\n";
132 |   out << "Next time, try me on GNU/Linux :-)\n";
133 | }
134 | void FramesConverter::reportError(const char* errorPrefix)
135 | {
136 | 
137 | }
138 | void FramesConverter::run()
139 | {
140 |     QThread::run();
141 | }
142 | FramesConverter::~FramesConverter()
143 | {
144 | 
145 | }
146 | 
147 | #endif
148 | 
149 | #include "framesconverter.moc"
150 | 
151 | 


--------------------------------------------------------------------------------
/src/framesconverter.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef FRAMESCONVERTER_H
22 | #define FRAMESCONVERTER_H
23 | #include <QThread>
24 | class QFile;
25 | class Frame;
26 | class VideoConversionData;
27 | class FramesConverter : public QThread
28 | {
29 |   Q_OBJECT
30 |   public:
31 |     FramesConverter(QObject* parent = 0) : QThread(parent) {};
32 |     ~FramesConverter();
33 |   public slots:
34 |     void gotFrame(Frame *frame);
35 |   protected:
36 |     virtual void run();
37 |   private:
38 |     QFile *videodev;
39 |     VideoConversionData *videoConversionData;
40 |     void reportError(const char* errorPrefix);
41 | };
42 | 
43 | #endif // FRAMESCONVERTER_H
44 | 


--------------------------------------------------------------------------------
/src/framescreator.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #include "framescreator.h"
22 | FramesCreator::FramesCreator(FramesFactory* framesFactory, QObject *parent): QObject(parent)
23 | {
24 |   this->framesFactory=framesFactory;
25 |   currentFrame=0;
26 | }
27 | 
28 | void FramesCreator::addFramesData ( const QByteArray& data )
29 | {
30 |   currentFrame->frameData()->append(data);
31 |   if(! remainingBytesForCurrentFrame()) {
32 |     emit frameProcessed(currentFrame);
33 |     currentFrame=NULL;
34 |   }
35 | }
36 | 
37 | void FramesCreator::createNewFrame ( const QByteArray& header )
38 | {
39 |   currentFrame=framesFactory->create(header);
40 | }
41 | 
42 | quint64 FramesCreator::remainingBytesForCurrentFrame()
43 | {
44 |   if(! currentFrame) return 0;
45 |   return currentFrame->totalbytes() - currentFrame->frameData()->size();
46 | }
47 | 
48 | #include "framescreator.moc"
49 | 


--------------------------------------------------------------------------------
/src/framescreator.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef FRAMESCREATOR_H
22 | #define FRAMESCREATOR_H
23 | 
24 | #include <qt4/QtCore/QObject>
25 | #define FRAMES_HEADER_LENGTH 4
26 | 
27 | #include "framesfactory.h"
28 | #include "frame.h"
29 | 
30 | class FramesCreator : public QObject
31 | {
32 |   Q_OBJECT
33 |   public:
34 |     FramesCreator(FramesFactory *framesFactory, QObject *parent=0);
35 |     virtual quint64 remainingBytesForCurrentFrame();
36 |     virtual void addFramesData(const QByteArray &data);
37 |     virtual void createNewFrame(const QByteArray &header);
38 |   private:
39 |     FramesFactory *framesFactory;
40 |     Frame *currentFrame;
41 |   signals:
42 |     void frameProcessed(Frame*);
43 | };
44 | 
45 | #endif // FRAMESCREATOR_H
46 | 


--------------------------------------------------------------------------------
/src/framesdataextractor.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #include "framesdataextractor.h"
22 | FramesDataExtractor::FramesDataExtractor ( FramesCreator* framesCreator, QObject* parent ) : QObject ( parent )
23 | {
24 |   this->framesCreator=framesCreator;
25 | }
26 | 
27 | void FramesDataExtractor::gotFramesData(QByteArray data)
28 | {
29 |   quint64 remainingBytes=framesCreator->remainingBytesForCurrentFrame();
30 |   if(!remainingBytes) {
31 |     remainingBytes=createNewFrame(&data);
32 |   }
33 |   if(remainingBytes<data.size()) {
34 |     framesCreator->addFramesData(data.left(remainingBytes));
35 |     data.remove(0, remainingBytes);
36 |     remainingBytes=createNewFrame(&data);
37 |   }
38 |   framesCreator->addFramesData(data);
39 | }
40 | 
41 | quint64 FramesDataExtractor::createNewFrame ( QByteArray *data )
42 | {
43 |     QByteArray header=data->left(FRAMES_HEADER_LENGTH);
44 |     framesCreator->createNewFrame(header);
45 |     data->remove(0, FRAMES_HEADER_LENGTH);
46 |     return framesCreator->remainingBytesForCurrentFrame();
47 | }
48 | 
49 | #include "framesdataextractor.moc"
50 | 


--------------------------------------------------------------------------------
/src/framesdataextractor.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef FRAMESDATAEXTRACTOR_H
22 | #define FRAMESDATAEXTRACTOR_H
23 | 
24 | #include <qt4/QtCore/QObject>
25 | #include "framescreator.h"
26 | 
27 | class FramesDataExtractor : public QObject
28 | {
29 |   Q_OBJECT
30 |   public:
31 |     FramesDataExtractor ( FramesCreator *framesCreator, QObject* parent = 0 );
32 |     virtual void gotFramesData(QByteArray data);
33 |   private:
34 |     FramesCreator *framesCreator;
35 |     quint64 createNewFrame(QByteArray *data);
36 | };
37 | 
38 | #endif // FRAMESDATAEXTRACTOR_H
39 | 


--------------------------------------------------------------------------------
/src/framesfactory.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #include "framesfactory.h"
22 | #include <QDebug>
23 | class FrameInitializationData {
24 |   public:
25 |     FrameInitializationData(quint16 width, quint16 height, quint16 bitsPerPixel) {
26 |       this->width=width;
27 |       this->height=height;
28 |       this->bitsPerPixel=bitsPerPixel;
29 |     }
30 |     quint16 width;
31 |     quint16 height;
32 |     quint16 bitsPerPixel;
33 | };
34 | 
35 | FramesFactory::FramesFactory(QObject* parent): QObject(parent)
36 | {
37 |   frameInitializationDataMap.insert(QByteArray::fromHex("F0000000"), new FrameInitializationData(320, 240, 12));
38 |   frameInitializationDataMap.insert(QByteArray::fromHex("F8000000"), new FrameInitializationData(160, 120, 12));
39 | }
40 | 
41 | FramesFactory::~FramesFactory()
42 | {
43 |   foreach(QByteArray header, frameInitializationDataMap.keys()) {
44 |     delete (frameInitializationDataMap.take(header));
45 |   }
46 | }
47 | 
48 | 
49 | Frame* FramesFactory::create(const QByteArray& headerData)
50 | {
51 |   FrameInitializationData *frameInitializationData = frameInitializationDataMap.value(headerData);
52 |   return frameInitializationData 
53 |     ? new Frame(frameInitializationData->width, frameInitializationData->height, frameInitializationData->bitsPerPixel)
54 |     : NULL;
55 | }
56 | 
57 | 
58 | #include "framesfactory.moc"
59 | 
60 | 


--------------------------------------------------------------------------------
/src/framesfactory.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef FRAMESFACTORY_H
22 | #define FRAMESFACTORY_H
23 | 
24 | #include <QObject>
25 | #include "frame.h"
26 | #include <QMap>
27 | class FrameInitializationData;
28 | class FramesFactory : public QObject
29 | {
30 |   Q_OBJECT
31 |   public:
32 |     FramesFactory(QObject* parent = 0);
33 |     ~FramesFactory();
34 |     virtual Frame *create(const QByteArray &headerData);
35 |   private:
36 |     QMap<QByteArray, FrameInitializationData*> frameInitializationDataMap;
37 | };
38 | 
39 | #endif // FRAMESFACTORY_H
40 | 


--------------------------------------------------------------------------------
/src/qtInterfaces/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | include_directories(${QT_INCLUDES} ${CMAKE_CURRENT_BINARY_DIR})
2 | set(qtInterfaces_SRCS socketinterface.cpp )
3 | qt4_automoc(${qtInterfaces_SRCS})
4 | add_library( qtInterfaces_lib STATIC ${qtInterfaces_SRCS})
5 | target_link_libraries(qtInterfaces_lib ${QT_QTCORE_LIBRARY} ${QT_QTNETWORK_LIBRARY} )
6 | 


--------------------------------------------------------------------------------
/src/qtInterfaces/socketinterface.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #include "socketinterface.h"
22 | #include <QDebug>
23 | 
24 | 
25 | SocketInterface::SocketInterface(QAbstractSocket* socket, QObject* parent): QObject(parent)
26 | {
27 |   this->socket=socket;
28 |   connectSignals();
29 | }
30 | 
31 | void SocketInterface::connectSignals()
32 | {
33 |   connect(socket, SIGNAL(readyRead()), this, SIGNAL(readyRead()));
34 |   connect(socket, SIGNAL(connected()), this, SIGNAL(connected()));
35 |   
36 |   // TODO: move to another object
37 |   connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(error(QAbstractSocket::SocketError)));
38 | }
39 | 
40 | 
41 | void SocketInterface::connectToHost(const QString& hostname, int port)
42 | {
43 |   socket->connectToHost(hostname, port);
44 | }
45 | 
46 | QByteArray SocketInterface::readAll()
47 | {
48 |   return socket->readAll();
49 | }
50 | 
51 | void SocketInterface::error(QAbstractSocket::SocketError socketError)
52 | {
53 |   qDebug() << "Got Socket Error: " << socketError;
54 | }
55 | 
56 | 
57 | QAbstractSocket::SocketState SocketInterface::state()
58 | {
59 |   return socket->state();
60 | }
61 | 
62 | 
63 | #include "socketinterface.moc"
64 | 
65 | 


--------------------------------------------------------------------------------
/src/qtInterfaces/socketinterface.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef ABSTRACTSOCKET_H
22 | #define ABSTRACTSOCKET_H
23 | 
24 | #include <qt4/QtNetwork/QAbstractSocket>
25 | 
26 | class AbstractSocketPrivate;
27 | class SocketInterface : public QObject
28 | {
29 |   Q_OBJECT
30 |   public:
31 |     SocketInterface(QAbstractSocket *socket, QObject *parent = 0);
32 |     virtual void connectToHost(const QString &hostname, int port);
33 |     virtual QByteArray readAll();
34 |     virtual QAbstractSocket::SocketState state ();
35 |   private:
36 |     QAbstractSocket *socket;
37 |   private:
38 |     virtual void connectSignals();
39 |   private slots:
40 |     void error( QAbstractSocket::SocketError socketError );
41 |   signals:
42 |     void readyRead();
43 |     void connected();
44 | };
45 | 
46 | #endif // ABSTRACTSOCKET_H
47 | 


--------------------------------------------------------------------------------
/src/socketconnector.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #include "socketconnector.h"
22 | 
23 | SocketConnector::SocketConnector(SocketInterface *socket, FramesDataExtractor *framesdataextractor , QObject* parent): QObject(parent)
24 | {
25 |   this->socket=socket;
26 |   this->framesdataextractor=framesdataextractor;
27 |   connect(socket, SIGNAL(readyRead()), this, SLOT(gotData()));
28 | }
29 | 
30 | void SocketConnector::openConnection()
31 | {
32 |   qDebug() << "Opening connection..";
33 |   socket->connectToHost("localhost", 8080);
34 | }
35 | 
36 | 
37 | void SocketConnector::gotData()
38 | {
39 |   QByteArray data=socket->readAll();
40 |   if(data.size()>0)
41 |     framesdataextractor->gotFramesData(data);
42 | }
43 | 
44 | 
45 | #include "socketconnector.moc"
46 | 


--------------------------------------------------------------------------------
/src/socketconnector.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef SOCKETCONNECTOR_H
22 | #define SOCKETCONNECTOR_H
23 | 
24 | #include <qt4/QtCore/QObject>
25 | #include "qtInterfaces/socketinterface.h"
26 | #include "framesdataextractor.h"
27 | 
28 | class SocketConnector : public QObject
29 | {
30 |   Q_OBJECT
31 |   public:
32 |     SocketConnector(SocketInterface *socket, FramesDataExtractor *framesdataextractor , QObject* parent = 0);
33 |     void openConnection();
34 |   private slots:
35 |     void gotData();
36 |   private:
37 |     SocketInterface *socket;
38 |     FramesDataExtractor *framesdataextractor;
39 | };
40 | 
41 | #endif // SOCKETCONNECTOR_H
42 | 


--------------------------------------------------------------------------------
/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | include_directories(${QT_INCLUDES} ${CMAKE_CURRENT_BINARY_DIR} )
 2 | 
 3 | set(SocketConnectorTest_SRCS socketconnectortest.cpp )
 4 | qt4_automoc(${SocketConnectorTest_SRCS})
 5 | add_executable(SocketConnectorTest ${SocketConnectorTest_SRCS})
 6 | target_link_libraries(SocketConnectorTest AndroidUsbCameraStaticLib ${QT_QTCORE_LIBRARY} ${QT_QTTEST_LIBRARY} -lgmock -lgtest )
 7 | 
 8 | set(FramesDataExtractorTest_SRCS framesdataextractortest.cpp )
 9 | qt4_automoc(${FramesDataExtractorTest_SRCS})
10 | add_executable(FramesDataExtractorTest ${FramesDataExtractorTest_SRCS})
11 | target_link_libraries(FramesDataExtractorTest AndroidUsbCameraStaticLib ${QT_QTCORE_LIBRARY} ${QT_QTTEST_LIBRARY} -lgmock -lgtest )
12 | 
13 | set(FramesCreatorTest_SRCS framescreatortest.cpp )
14 | qt4_automoc(${FramesCreatorTest_SRCS})
15 | add_executable(FramesCreatorTest ${FramesCreatorTest_SRCS})
16 | target_link_libraries(FramesCreatorTest AndroidUsbCameraStaticLib ${QT_QTCORE_LIBRARY} ${QT_QTTEST_LIBRARY} -lgmock -lgtest )
17 | 
18 | 
19 | set(FramesFactoryTest_SRCS  framesfactorytest.cpp )
20 | qt4_automoc(${FramesFactoryTest_SRCS})
21 | add_executable(FramesFactoryTest ${FramesFactoryTest_SRCS})
22 | target_link_libraries(FramesFactoryTest AndroidUsbCameraStaticLib ${QT_QTCORE_LIBRARY} ${QT_QTTEST_LIBRARY} -lgmock -lgtest )
23 | 
24 | 


--------------------------------------------------------------------------------
/test/android_usb_camera_test_base.h:
--------------------------------------------------------------------------------
 1 | #ifndef ANDROID_USB_CAMERA_TEST_BASE_H
 2 | #define ANDROID_USB_CAMERA_TEST_BASE_H
 3 | #include <iostream>
 4 | 
 5 | #include <QTest>
 6 | #include <gmock/gmock.h>
 7 | #include <QString>
 8 | #define GQTEST_MAIN(TestObject) \
 9 | int main(int argc, char *argv[]) \
10 | { \
11 |     QCoreApplication app(argc, argv); \
12 |     TestObject tc; \
13 |     testing::InitGoogleMock(&argc, argv); \
14 |     ::testing::TestEventListeners& listeners = ::testing::UnitTest::GetInstance()->listeners(); \
15 |     delete listeners.Release(listeners.default_result_printer()); \
16 |     listeners.Append(new MockReport); \
17 |     return QTest::qExec(&tc, argc, argv); \
18 | }
19 | 
20 | using namespace testing;
21 | 
22 | 
23 | class MockReport : public EmptyTestEventListener {
24 |   virtual void OnTestPartResult(const TestPartResult& test_part_result) {
25 |     if(test_part_result.failed() || test_part_result.fatally_failed() ) {
26 |       QTest::qFail(test_part_result.message(), test_part_result.file_name() , test_part_result.line_number());
27 |     }
28 |   }
29 | };
30 | 
31 | QT_BEGIN_NAMESPACE
32 | void PrintTo(const QString& aQString, ::std::ostream* os) {
33 |   *os << QString("\"%1\"").arg(aQString).toLocal8Bit().data();
34 | }
35 | QT_END_NAMESPACE
36 | #endif
37 | 


--------------------------------------------------------------------------------
/test/framescreatortest.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |     <one line to give the program's name and a brief idea of what it does.>
  3 |     Copyright (C) <year>  <name of author>
  4 | 
  5 |     This program is free software; you can redistribute it and/or modify
  6 |     it under the terms of the GNU General Public License as published by
  7 |     the Free Software Foundation; either version 2 of the License, or
  8 |     (at your option) any later version.
  9 | 
 10 |     This program is distributed in the hope that it will be useful,
 11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 |     GNU General Public License for more details.
 14 | 
 15 |     You should have received a copy of the GNU General Public License along
 16 |     with this program; if not, write to the Free Software Foundation, Inc.,
 17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 18 | 
 19 | */
 20 | 
 21 | #include "framescreatortest.h"
 22 | #include <QSignalSpy>
 23 | 
 24 | GQTEST_MAIN(FramesCreatorTest)
 25 | 
 26 | void FramesCreatorTest::init()
 27 | {
 28 |   mockFramesFactory=new StrictMock<MockFramesFactory>();
 29 |   framesCreator=new FramesCreator(mockFramesFactory);
 30 |   mockFrame=new StrictMock<MockFrame>();
 31 | }
 32 | 
 33 | 
 34 | void FramesCreatorTest::shouldReturn0AsRemainingBytesIfCurrentFrameIsBlank()
 35 | {
 36 |   QCOMPARE(framesCreator->remainingBytesForCurrentFrame(), (quint64)0);
 37 | }
 38 | 
 39 | void FramesCreatorTest::shouldCreateNewFrame()
 40 | {
 41 |   EXPECT_CALL(*mockFramesFactory, create(QByteArray("header data")));
 42 |   framesCreator->createNewFrame(QByteArray("header data"));
 43 | }
 44 | 
 45 | void FramesCreatorTest::shouldReportRemainingBytes()
 46 | {
 47 |   QByteArray data;
 48 |   EXPECT_CALL(*mockFramesFactory, create(QByteArray("header data"))).WillOnce(Return(mockFrame));
 49 |   EXPECT_CALL(*mockFrame, totalbytes()).Times(AnyNumber()).WillRepeatedly(Return(1024));
 50 |   EXPECT_CALL(*mockFrame, frameData()).Times(AnyNumber()).WillRepeatedly(Return(&data));
 51 |   
 52 |   framesCreator->createNewFrame(QByteArray("header data"));
 53 |   
 54 |   QCOMPARE(framesCreator->remainingBytesForCurrentFrame(), (quint64) 1024);
 55 |   data.append("1234567890");
 56 |   QCOMPARE(framesCreator->remainingBytesForCurrentFrame(), (quint64) (1024-10) );
 57 |   data.append("123456789012345");
 58 |   QCOMPARE(framesCreator->remainingBytesForCurrentFrame(), (quint64) (1024-10-15) );
 59 | }
 60 | 
 61 | void FramesCreatorTest::shouldWriteDataToFrame()
 62 | {
 63 |   QByteArray data;
 64 |   EXPECT_CALL(*mockFramesFactory, create(QByteArray("header data"))).WillOnce(Return(mockFrame));
 65 |   EXPECT_CALL(*mockFrame, frameData()).Times(AnyNumber()).WillRepeatedly(Return(&data));
 66 |   EXPECT_CALL(*mockFrame, totalbytes()).Times(AnyNumber()).WillRepeatedly(Return(100));
 67 | 
 68 |   framesCreator->createNewFrame(QByteArray("header data"));
 69 |   framesCreator->addFramesData(QByteArray("Any data to write into the frame"));
 70 |   QCOMPARE(data, QByteArray("Any data to write into the frame"));
 71 | }
 72 | 
 73 | void FramesCreatorTest::shouldEmitProcessedFrameSignalWhenNoMoreBytesAreRemaining()
 74 | {
 75 |   QByteArray data;
 76 |   QSignalSpy spy(framesCreator, SIGNAL(frameProcessed(Frame*)));
 77 | 
 78 |   EXPECT_CALL(*mockFramesFactory, create(QByteArray("header data"))).WillOnce(Return(mockFrame));
 79 |   EXPECT_CALL(*mockFrame, frameData()).Times(AnyNumber()).WillRepeatedly(Return(&data));
 80 |   EXPECT_CALL(*mockFrame, totalbytes()).Times(AnyNumber()).WillRepeatedly(Return(10));
 81 | 
 82 |   framesCreator->createNewFrame(QByteArray("header data"));
 83 |   
 84 |   framesCreator->addFramesData(QByteArray("12345"));
 85 |   QCOMPARE(spy.count(), 0);
 86 |   framesCreator->addFramesData(QByteArray("12345"));
 87 |   QCOMPARE(framesCreator->remainingBytesForCurrentFrame(), (quint64)0);
 88 |   QCOMPARE(spy.count(), 1);
 89 | }
 90 | 
 91 | 
 92 | void FramesCreatorTest::cleanup()
 93 | {
 94 |   delete framesCreator;
 95 |   delete mockFramesFactory;
 96 |   delete mockFrame;
 97 | }
 98 | 
 99 | #include "framescreatortest.moc"
100 | 


--------------------------------------------------------------------------------
/test/framescreatortest.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef FRAMESCREATORTEST_H
22 | #define FRAMESCREATORTEST_H
23 | 
24 | #include <qt4/QtCore/QObject>
25 | #include "android_usb_camera_test_base.h"
26 | #include "framescreator.h"
27 | class MockFramesFactory;
28 | class MockFrame;
29 | 
30 | class FramesCreatorTest : public QObject
31 | {
32 |   Q_OBJECT
33 |   private:
34 |     FramesCreator *framesCreator;
35 |     MockFramesFactory *mockFramesFactory;
36 |     MockFrame *mockFrame;
37 |   private slots:
38 |     void init();
39 |     void shouldReturn0AsRemainingBytesIfCurrentFrameIsBlank();
40 |     void shouldCreateNewFrame();
41 |     void shouldWriteDataToFrame();
42 |     void shouldReportRemainingBytes();
43 |     void shouldEmitProcessedFrameSignalWhenNoMoreBytesAreRemaining();
44 |     void cleanup();
45 | };
46 | 
47 | 
48 | class MockFramesFactory : public FramesFactory {
49 |   public:
50 |     MOCK_METHOD1(create, Frame*(const QByteArray&));
51 | };
52 | 
53 | class MockFrame : public Frame {
54 |   public:
55 |     MockFrame() : Frame(0, 0, 0) {};
56 |     MOCK_METHOD0(totalbytes, quint64());
57 |     MOCK_METHOD0(frameData, QByteArray*());
58 | };
59 | #endif // FRAMESCREATORTEST_H
60 | 


--------------------------------------------------------------------------------
/test/framesdataextractortest.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #include "framesdataextractortest.h"
22 | #include "framesdataextractor.h"
23 | GQTEST_MAIN(FramesDataExtractorTest)
24 | 
25 | void FramesDataExtractorTest::init()
26 | {
27 |   mockFramesCreator=new StrictMock<MockFramesCreator>();
28 |   framesDataExtractor=new FramesDataExtractor(mockFramesCreator, this);
29 | }
30 | 
31 | void FramesDataExtractorTest::shouldAskForRemainingBytesOnNewData()
32 | {
33 |   EXPECT_CALL(*mockFramesCreator, remainingBytesForCurrentFrame()).WillOnce(Return(19));
34 |   EXPECT_CALL(*mockFramesCreator, addFramesData(_));
35 | 
36 |   framesDataExtractor->gotFramesData(QByteArray("any qbytearray"));
37 | }
38 | 
39 | void FramesDataExtractorTest::shouldAppendRemainingBytesToExistingFrame()
40 | {
41 |   QByteArray data("Frames Data");
42 | 
43 |   EXPECT_CALL(*mockFramesCreator, remainingBytesForCurrentFrame()).WillOnce(Return(19));
44 |   EXPECT_CALL(*mockFramesCreator, addFramesData(data));
45 |   framesDataExtractor->gotFramesData(data);
46 | }
47 | 
48 | void FramesDataExtractorTest::shouldCreateNewFrameOnNoRemainingBytesAndStripHeader()
49 | {
50 |   InSequence seq;
51 |   EXPECT_CALL(*mockFramesCreator, remainingBytesForCurrentFrame()).WillRepeatedly(Return(0));
52 |   EXPECT_CALL(*mockFramesCreator, createNewFrame(QByteArray("1234")));
53 |   EXPECT_CALL(*mockFramesCreator, remainingBytesForCurrentFrame()).WillRepeatedly(Return(250));
54 |   
55 |   EXPECT_CALL(*mockFramesCreator, addFramesData(QByteArray(" other bytes data to be added to frame")));
56 |   framesDataExtractor->gotFramesData(QByteArray("1234 other bytes data to be added to frame"));
57 | }
58 | 
59 | void FramesDataExtractorTest::shouldSplitDataOnOverlappingData()
60 | {
61 |   InSequence seq;
62 |   Expectation firstFrameRemainingBytes=EXPECT_CALL(*mockFramesCreator, remainingBytesForCurrentFrame()).WillRepeatedly(Return(4));
63 |   Expectation lastData=EXPECT_CALL(*mockFramesCreator, addFramesData(QByteArray("4321"))).After(firstFrameRemainingBytes);
64 |   
65 |   Expectation newFrameHeader=EXPECT_CALL(*mockFramesCreator, createNewFrame(QByteArray("1234"))).After(lastData);
66 |   Expectation nextFrameRemainingBytes=EXPECT_CALL(*mockFramesCreator, remainingBytesForCurrentFrame()).WillRepeatedly(Return(256));
67 | 
68 |   EXPECT_CALL(*mockFramesCreator, addFramesData(QByteArray(" other bytes data to be added to frame"))).After(newFrameHeader);
69 | 
70 |   framesDataExtractor->gotFramesData(QByteArray("43211234 other bytes data to be added to frame"));
71 | }
72 | 
73 | void FramesDataExtractorTest::cleanup()
74 | {
75 |   delete framesDataExtractor;
76 |   delete mockFramesCreator;
77 | }
78 | 
79 | #include "framesdataextractortest.moc"
80 | 
81 | 


--------------------------------------------------------------------------------
/test/framesdataextractortest.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef FRAMESDATAEXTRACTORTEST_H
22 | #define FRAMESDATAEXTRACTORTEST_H
23 | 
24 | #include <qt4/QtCore/QObject>
25 | #include "android_usb_camera_test_base.h"
26 | #include "framescreator.h"
27 | class MockFramesCreator;
28 | class FramesDataExtractor;
29 | class FramesDataExtractorTest : public QObject
30 | {
31 |   Q_OBJECT
32 |   private:
33 |     MockFramesCreator *mockFramesCreator;
34 |     FramesDataExtractor *framesDataExtractor;
35 |     
36 |   private slots:
37 |     void init();
38 |     void shouldAskForRemainingBytesOnNewData();
39 |     void shouldCreateNewFrameOnNoRemainingBytesAndStripHeader();
40 |     void shouldAppendRemainingBytesToExistingFrame();
41 |     void shouldSplitDataOnOverlappingData();
42 |     void cleanup();
43 | };
44 | 
45 | class MockFramesCreator : public FramesCreator {
46 |   public:
47 |     MockFramesCreator() : FramesCreator(NULL) {};
48 |     MOCK_METHOD0(remainingBytesForCurrentFrame, quint64());
49 |     MOCK_METHOD1(addFramesData, void(const QByteArray &));
50 |     MOCK_METHOD1(createNewFrame, void(const QByteArray&));
51 | };
52 | #endif // FRAMESDATAEXTRACTORTEST_H
53 | 


--------------------------------------------------------------------------------
/test/framesfactorytest.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #include "framesfactorytest.h"
22 | #include "framesfactory.h"
23 | 
24 | GQTEST_MAIN(FramesFactoryTest)
25 | 
26 | void FramesFactoryTest::frameTotalBytesCalculationTest()
27 | {
28 |   Frame frame(640, 480, 12);
29 |   QCOMPARE(frame.totalbytes(), (quint64)460800);
30 | }
31 | 
32 | 
33 | void FramesFactoryTest::shouldCreate320x240NV12Frame()
34 | {
35 |   FramesFactory factory;
36 |   Frame *createdFrame = factory.create(QByteArray::fromHex("F0000000"));
37 |   QCOMPARE(createdFrame->width(), (quint16)320);
38 |   QCOMPARE(createdFrame->height(), (quint16)240);
39 |   QCOMPARE(createdFrame->totalbytes(), (quint64)115200); 
40 | }
41 | 
42 | void FramesFactoryTest::shouldCreate160x120NV12Frame()
43 | {
44 |   FramesFactory factory;
45 |   Frame *createdFrame = factory.create(QByteArray::fromHex("F8000000"));
46 |   QCOMPARE(createdFrame->width(), (quint16)160);
47 |   QCOMPARE(createdFrame->height(), (quint16)120);
48 |   QCOMPARE(createdFrame->totalbytes(), (quint64)28800); 
49 | }
50 | 
51 | void FramesFactoryTest::shouldReturnNullForInvalidHeader()
52 | {
53 |   FramesFactory factory;
54 |   QCOMPARE(factory.create(QByteArray::fromHex("any invalid header")), (Frame*)NULL);
55 | }
56 | 
57 | 
58 | 
59 | #include "framesfactorytest.moc"


--------------------------------------------------------------------------------
/test/framesfactorytest.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef FRAMESFACTORYTEST_H
22 | #define FRAMESFACTORYTEST_H
23 | 
24 | #include <qt4/QtCore/QObject>
25 | #include "android_usb_camera_test_base.h"
26 | 
27 | class FramesFactoryTest : public QObject
28 | {
29 |   Q_OBJECT
30 |   private slots:
31 |     void frameTotalBytesCalculationTest();
32 |     void shouldCreate320x240NV12Frame();
33 |     void shouldCreate160x120NV12Frame();
34 |     void shouldReturnNullForInvalidHeader();
35 | };
36 | 
37 | #endif // FRAMESFACTORYTEST_H
38 | 


--------------------------------------------------------------------------------
/test/socketconnectortest.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #include "socketconnectortest.h"
22 | #include "socketconnector.h"
23 | 
24 | GQTEST_MAIN(SocketConnectorTest)
25 | 
26 | void SocketConnectorTest::init()
27 | {
28 |   mocksocket=new StrictMock<MockSocket>();
29 |   mockframesdataextractor=new StrictMock<MockFramesDataExtractor>();
30 |   socketConnector= new SocketConnector(mocksocket, mockframesdataextractor, this);
31 | }
32 | 
33 | 
34 | void SocketConnectorTest::shouldConnectToLocalhost()
35 | {
36 |   Expectation shouldConnectFirst = EXPECT_CALL(*mocksocket, connectToHost(QString("localhost"), 8080) );
37 |   
38 |   socketConnector->openConnection();
39 | }
40 | 
41 | void SocketConnectorTest::shouldReadDataOnSocketSignalAndDoNothingOnNoData()
42 | {
43 |   EXPECT_CALL(*mocksocket, readAll()).WillOnce(Return(QByteArray()));
44 |   EXPECT_CALL(*mockframesdataextractor, gotFramesData(_)).Times(0);
45 |   mocksocket->emitReadyRead();
46 | }
47 | 
48 | void SocketConnectorTest::shouldReadDataOnSocketSignalAndPassDataToFramesExtractor()
49 | {
50 |   QByteArray data("any not empty QByteArray");
51 |   EXPECT_CALL(*mocksocket, readAll()).WillOnce(Return(data));
52 |   EXPECT_CALL(*mockframesdataextractor, gotFramesData(data));
53 |   mocksocket->emitReadyRead();
54 | }
55 | 
56 | 
57 | 
58 | 
59 | void SocketConnectorTest::cleanup()
60 | {
61 |   delete mocksocket;
62 |   delete mockframesdataextractor;
63 | }
64 | 
65 | #include "socketconnectortest.moc"
66 | 
67 | 


--------------------------------------------------------------------------------
/test/socketconnectortest.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     <one line to give the program's name and a brief idea of what it does.>
 3 |     Copyright (C) <year>  <name of author>
 4 | 
 5 |     This program is free software; you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation; either version 2 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License along
16 |     with this program; if not, write to the Free Software Foundation, Inc.,
17 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 | 
19 | */
20 | 
21 | #ifndef SOCKETCONNECTORINTEGRATIONTEST_H
22 | #define SOCKETCONNECTORINTEGRATIONTEST_H
23 | 
24 | #include <qt4/QtCore/QObject>
25 | #include "android_usb_camera_test_base.h"
26 | 
27 | #include "qtInterfaces/socketinterface.h"
28 | #include "framesdataextractor.h"
29 | class MockSocket;
30 | class MockFramesDataExtractor;
31 | class SocketConnector;
32 | 
33 | class SocketConnectorTest : public QObject
34 | {
35 | Q_OBJECT
36 |   private slots:
37 |     void init();
38 |     void shouldConnectToLocalhost();
39 |     void shouldReadDataOnSocketSignalAndDoNothingOnNoData();
40 |     void shouldReadDataOnSocketSignalAndPassDataToFramesExtractor();
41 |     void cleanup();
42 |   private:
43 |     MockSocket *mocksocket;
44 |     MockFramesDataExtractor *mockframesdataextractor;
45 |     SocketConnector *socketConnector;
46 |   };
47 | 
48 | 
49 |   class VoidSocket : public QAbstractSocket {
50 |     public:
51 |       VoidSocket() : QAbstractSocket(UnknownSocketType, NULL) {};
52 |   };
53 | 
54 | class MockSocket : public SocketInterface {
55 |   public:
56 |     MockSocket() : SocketInterface(new VoidSocket(), NULL) {};
57 |     MOCK_METHOD2(connectToHost, void(const QString &, int) );
58 |     MOCK_METHOD0(readAll, QByteArray());
59 |     void emitReadyRead() { emit readyRead() ;}
60 | };
61 | 
62 | class MockFramesDataExtractor : public FramesDataExtractor {
63 |   public:
64 |     MockFramesDataExtractor() : FramesDataExtractor(NULL) {};
65 |     MOCK_METHOD1(gotFramesData, void(QByteArray));
66 | };
67 | 
68 | #endif // SOCKETCONNECTORINTEGRATIONTEST_H
69 | 


--------------------------------------------------------------------------------