PARP Research Group University of Murcia, Spain


src/qvio/qvmplayercamera.cpp

Go to the documentation of this file.
00001 /*
00002  *      Copyright (C) 2007, 2008, 2009. PARP Research Group.
00003  *      <http://perception.inf.um.es>
00004  *      University of Murcia, Spain.
00005  *
00006  *      This file is part of the QVision library.
00007  *
00008  *      QVision is free software: you can redistribute it and/or modify
00009  *      it under the terms of the GNU Lesser General Public License as
00010  *      published by the Free Software Foundation, version 3 of the License.
00011  *
00012  *      QVision is distributed in the hope that it will be useful,
00013  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  *      GNU Lesser General Public License for more details.
00016  *
00017  *      You should have received a copy of the GNU Lesser General Public
00018  *      License along with QVision. If not, see <http://www.gnu.org/licenses/>.
00019  */
00020 
00024 
00025 #include <sys/types.h>
00026 #include <sys/stat.h>
00027 #include <unistd.h>
00028 #include <stdlib.h>
00029 #include <fcntl.h>
00030 #include <stdio.h>
00031 
00032 #include <QApplication>
00033 #include <QDebug>
00034 #include <QObject>
00035 #include <QStringList>
00036 #include <QRegExp>
00037 #include <QMutex>
00038 
00039 #include <qvipp.h>
00040 #include <qvio.h>
00041 
00042 #include <QVWorker>
00043 #include <QVMPlayerCamera>
00044 
00045 /***************************** QVMPlayerCamera Class **************************/
00046 QVMPlayerCamera::QVMPlayerCamera(QString name):QVCamera(name), mplayerProxy(name+"peo")
00047         {
00048         qDebug() << "QVMPlayerCamera::QVMPlayerCamera()";
00049         if (qvApp == NULL)
00050                 {
00051                 QString str = "QVWorker::QVWorker(): the QVWorker cannot be created before the QVApplication instance. Aborting now.";
00052                 std::cerr << qPrintable(str) << std::endl;
00053                 exit(1);
00054                 }
00055 
00056         connect(&mplayerProxy, SIGNAL(newGrab()), this, SIGNAL(newGrab()));
00057         connect(&mplayerProxy, SIGNAL(newRead()), this, SIGNAL(newRead()));
00058         connect(&mplayerProxy, SIGNAL(camClosed()), this, SIGNAL(camClosed()));
00059         connect(&mplayerProxy, SIGNAL(camOpened()), this, SIGNAL(camOpened()));
00060         connect(&mplayerProxy, SIGNAL(statusChange(QVCamera::TCameraStatus)), this, SIGNAL(statusChange(QVCamera::TCameraStatus)));
00061 
00062         rgbMode = false;
00063 
00064         // Properties (to allow reading from argc and argv):
00065         addProperty<int>("Rows", inputFlag, 0, "Rows to open the camera");
00066         addProperty<int>("Cols", inputFlag, 0, "Columns to open the camera");
00067         addProperty<bool>("RealTime", inputFlag, FALSE,"If the camera should be opened in real time mode");
00068         addProperty<bool>("Deinterlaced", inputFlag, FALSE,"If the camera should be opened in deinterlaced mode");
00069         addProperty<bool>("NoLoop", inputFlag, FALSE,"If the camera should be opened in no loop mode");
00070         addProperty<QString>("URL", inputFlag, QString(""),"URL of the video source");
00071 
00072         // QVImage's
00073         addProperty< QVImage<uChar,3> >("RGB image", outputFlag, QVImage<uChar,3>(), "Last grabbed RGB image");
00074         addProperty< QVImage<uChar,1> >("Y channel image",outputFlag, QVImage<uChar,1>(), "Last grabbed Y channel image");
00075         addProperty< QVImage<uChar,1> >("U channel image",outputFlag, QVImage<uChar,1>(), "Last grabbed U channel image");
00076         addProperty< QVImage<uChar,1> >("V channel image",outputFlag, QVImage<uChar,1>(), "Last grabbed V channel image");
00077 
00078         qDebug() << "QVMPlayerCamera::QVMPlayerCamera() <- return";
00079         }
00080 
00081 QVMPlayerCamera::~QVMPlayerCamera()
00082         {
00083         qDebug() << "QVMPlayerCamera::~QVMPlayerCamera()";
00084         if (status != Closed) closeCam();
00085         qDebug() << "QVMPlayerCamera::~QVMPlayerCamera() <- deleting image";
00086         qDebug() << "QVMPlayerCamera::~QVMPlayerCamera() <- return";
00087         }
00088 
00089 // (Implicit) default open method for a camera (uses introspection to read 
00090 // parameters, allowing initialization from argc and argv):
00091 bool QVMPlayerCamera::openCam()
00092         {
00093         std::cout << "QVMPlayerCamera::openCam()." << std::endl;
00094         QVMPlayerProxy::OpenOptions optsProp = QVMPlayerProxy::Default;
00095 
00096         readInputProperties();
00097 
00098         if (getPropertyValue<bool>("RealTime"))         optsProp |= QVMPlayerProxy::RealTime;
00099         if (getPropertyValue<bool>("Deinterlaced"))     optsProp |= QVMPlayerProxy::Deinterlaced;
00100         if (getPropertyValue<bool>("NoLoop"))           optsProp |= QVMPlayerProxy::NoLoop;
00101         if (rgbMode)                                    optsProp |= QVMPlayerProxy::RGBMEncoder;
00102 
00103         return mplayerProxy.openCam(getPropertyValue<QString>("URL"), optsProp, getPropertyValue<int>("Rows"), getPropertyValue<int>("Cols"));
00104         }
00105 
00106 // Close camera method:
00107 void QVMPlayerCamera::closeCam()
00108         {
00109         mplayerProxy.closeCam();
00110         }
00111 
00112 bool QVMPlayerCamera::grab()
00113         {
00114         qDebug() << "QVMPlayerCamera::grab()";
00115 
00116         QVImage<uChar> grabbedYImage, grabbedUImage, grabbedVImage;
00117 
00118         if (!mplayerProxy.grab(grabbedYImage, grabbedUImage, grabbedVImage))
00119                 return false;
00120 
00121         setPropertyValue< QVImage<uChar,1> >("Y channel image", grabbedYImage);
00122         setPropertyValue< QVImage<uChar,1> >("U channel image", grabbedUImage);
00123         setPropertyValue< QVImage<uChar,1> >("V channel image", grabbedVImage);
00124 
00125         if (rgbMode)
00126                 {
00127                 QVImage<uChar,3> grabbedRGBImage(grabbedYImage.getCols(),grabbedYImage.getRows());
00128                 YUV420ToRGB(grabbedYImage, grabbedUImage, grabbedVImage, grabbedRGBImage);
00129                 setPropertyValue< QVImage<uChar,3> >("RGB image", grabbedRGBImage);
00130                 }
00131 
00132         writeOutputProperties();
00133 
00134         qDebug() << "QVMPlayerCamera::grab() <~ return";
00135 
00136         return true;
00137         }
00138 
00140 bool QVMPlayerCamera::linkProperty(QString, QVPropertyContainer *destinyContainer, QString destinyPropertyName, LinkType linkType)
00141         {
00142                 std::cerr << "Warning: QVMPlayerCamera::linkProperty(): undefined specific link, the sourcePropertyName will be ignored" << std::endl;
00143                 return linkProperty(destinyContainer, destinyPropertyName, linkType);
00144         }
00145 
00146 bool QVMPlayerCamera::linkProperty(QString sourcePropertyName, QVPropertyContainer &destinyContainer, QString destinyPropertyName, LinkType linkType)
00147         {
00148                 return linkProperty(sourcePropertyName, &destinyContainer, destinyPropertyName, linkType);
00149         }
00150 
00151 bool QVMPlayerCamera::linkProperty(QVPropertyContainer *destinyContainer, QString destinyPropertyName, LinkType linkType)
00152         {
00153         if (linkType == SynchronousLink) {
00154                 std::cerr << "ERROR: QVMPlayerCamera::linkProperty(): the linkType must be AsynchronousLink, the link will not be done" << std::endl;
00155                 return FALSE;
00156         }
00157 
00158         QVWorker* worker;
00159         if((worker = dynamic_cast<QVWorker*>(destinyContainer)) != NULL)
00160                 {
00161                 if(worker->isType<QVImage<uChar,1> >(destinyPropertyName))
00162                         {
00163                         connect(worker, SIGNAL(startIteration()), this, SLOT(grab()));
00164                         return QVPropertyContainer::linkProperty("Y channel image", worker, destinyPropertyName, AsynchronousLink);
00165                         }
00166                 else if(worker->isType<QVImage<uChar,3> >(destinyPropertyName))
00167                         {
00168                         rgbMode = true;
00169                         connect(worker, SIGNAL(startIteration()), this, SLOT(grab()));
00170                         return QVPropertyContainer::linkProperty("RGB image", worker, destinyPropertyName, AsynchronousLink);
00171                         }
00172                 else
00173                         {
00174                         std::cerr << "Warning: QVMPlayerCamera::linkProperty(): unsupported property type: property " << qPrintable(destinyPropertyName)
00175                                 << " in holder " << qPrintable(worker->getName()) << "is not a QVImage<uChar,1> or QVImage<uChar,3>" << std::endl;
00176                         return FALSE; //Should never get here;
00177                         }
00178                 }
00179         else
00180                 {
00181                 std::cerr << "ERROR: QVMPlayerCamera::linkProperty(): the destination container must be a QVWorker, the link will not be done" << std::endl;
00182                 return FALSE;
00183                 }
00184         }
00185 
00186 bool QVMPlayerCamera::linkProperty(QVPropertyContainer &destinyContainer, QString destinyPropertyName, LinkType linkType)
00187         {
00188                 return linkProperty(&destinyContainer, destinyPropertyName, linkType);
00189         }
00190 
00191 bool QVMPlayerCamera::linkProperty(QString, QVPropertyContainer *, LinkType)
00192         {
00193         std::cerr << "ERROR: QVMPlayerCamera::linkProperty(): the destination property name can't be omitted, the link will not be done" << std::endl;
00194         return FALSE;
00195         }
00196 
00197 bool QVMPlayerCamera::linkProperty(QString sourcePropertyName, QVPropertyContainer &destinyContainer, LinkType linkType)
00198         {
00199                 return linkProperty(sourcePropertyName, &destinyContainer, linkType);
00200         }
00201 
00202 void QVMPlayerCamera::linkProperty(QVPropertyContainer *, LinkType)
00203         {
00204         std::cerr << "ERROR: QVMPlayerCamera::linkProperty(): unsopported global link, the link will not be done" << std::endl;
00205         }
00206 
00207 void QVMPlayerCamera::linkProperty(QVPropertyContainer &container, LinkType linkType)
00208         {
00209                 linkProperty(&container, linkType);
00210         }
00211 
00212 bool QVMPlayerCamera::unlinkProperty(QString origName, QVPropertyContainer *destCont, QString destName)
00213         {
00214         QVWorker* worker;
00215         if((worker = dynamic_cast<QVWorker*>(destCont)) != NULL)
00216                 {
00217                 if (origName == "RGB image")
00218                         {
00219                         disconnect(worker, SIGNAL(startIteration()), this, SLOT(grab()));
00220                         return QVPropertyContainer::unlinkProperty(origName, worker, destName);
00221                         }
00222                 else if (origName == "Y channel image")
00223                         {
00224                         disconnect(worker, SIGNAL(startIteration()), this, SLOT(grab()));
00225                         return QVPropertyContainer::unlinkProperty(origName, worker, destName);
00226                         }
00227                 else
00228                         {
00229                         std::cerr << "ERROR: QVMPlayerCamera::unlinkProperty(): invalid source property, the unlink will not be done" << std::endl;
00230                         return FALSE;
00231                         }
00232                 }
00233         else
00234                 {
00235                 std::cerr << "ERROR: QVMPlayerCamera::unlinkProperty(): the destination container must be a QVWorker, the unlink will not be done" << std::endl;
00236                 return FALSE;
00237                 }
00238         }
00239 
00240 bool QVMPlayerCamera::unlinkProperty(QString origName, QVPropertyContainer &destCont, QString destName)
00241         {
00242                 return unlinkProperty(origName, &destCont, destName);
00243         }
00244 
00245 void QVMPlayerCamera::unlink()
00246         {
00248                 QVPropertyContainer::unlink();
00249         }
00250 
00251 bool QVMPlayerCamera::link(QVWorker* worker, const QString imageNameY, const QString imageNameU, const QString imageNameV)
00252         {
00253         if(!worker->isType< QVImage<uChar,1> >(imageNameY))
00254                 {
00255                 std::cerr << "Warning: QVMPlayerCamera::link(): image " << qPrintable(imageNameY) << "is not of type QVImage<uChar,1> in holder "
00256                         << qPrintable(worker->getName()) << std::endl;
00257                 return FALSE;
00258                 }
00259 
00260         if(!worker->isType< QVImage<uChar,1> >(imageNameU))
00261                 {
00262                 std::cerr << "Warning: QVMPlayerCamera::link(): image " << qPrintable(imageNameU) << "is not of type QVImage<uChar,1> in holder "
00263                         << qPrintable(worker->getName()) << std::endl;
00264                 return FALSE;
00265                 }
00266 
00267         if(!worker->isType< QVImage<uChar,1> >(imageNameV))
00268                 {
00269                 std::cerr << "Warning: QVMPlayerCamera::link(): image " << qPrintable(imageNameV) << "is not of type QVImage<uChar,1> in holder "
00270                         << qPrintable(worker->getName()) << std::endl;
00271                 return FALSE;
00272                 }
00273 
00274         connect(worker, SIGNAL(startIteration()), this, SLOT(grab()));
00275         return  this->linkProperty("Y channel image", worker, imageNameY, AsynchronousLink) &&
00276                 this->linkProperty("U channel image", worker, imageNameU, AsynchronousLink) &&
00277                 this->linkProperty("V channel image", worker, imageNameV, AsynchronousLink);
00278         }
00279 
00280 bool QVMPlayerCamera::link(QVWorker &worker, const QString imageNameY, const QString imageNameU, const QString imageNameV)
00281         {
00282                 return link(&worker, imageNameY, imageNameU, imageNameV);
00283         }
00284 
00285 bool QVMPlayerCamera::unlink(QVWorker* worker, const QString imageName)
00286         {
00287                 if (rgbMode) {
00288                         return unlinkProperty("RGB image", worker, imageName);
00289                 }
00290                 else {
00291                         return unlinkProperty("Y channel image", worker, imageName);
00292                 }
00293         }
00294 
00295 bool QVMPlayerCamera::unlink(QVWorker &worker, const QString imageName)
00296         {
00297                 return unlink(&worker, imageName);
00298         }
00299 



QVision framework. PARP research group, copyright 2007, 2008.