Homepage Demos Overview Downloads Tutorials Reference
Credits

InterleavedYUVGenerator.cc

Go to the documentation of this file.
00001 #include "InterleavedYUVGenerator.h"
00002 #include "Events/EventRouter.h"
00003 #include "Events/FilterBankEvent.h"
00004 #include "Wireless/Wireless.h"
00005 #include "Shared/WorldState.h"
00006 
00007 #include "Shared/debuget.h"
00008 
00009 InterleavedYUVGenerator::InterleavedYUVGenerator(EventBase::EventGeneratorID_t gid, unsigned int sid, unsigned int mysid)
00010   : FilterBankGenerator("InterleavedYUVGenerator",0,1,gid,sid,EventBase::visInterleaveEGID,mysid), src(NULL), srcYChan(0), srcUChan(1), srcVChan(2)
00011 {
00012   setNumImages(numLayers,numChannels);
00013 }
00014 
00015 InterleavedYUVGenerator::InterleavedYUVGenerator(EventBase::EventGeneratorID_t gid, unsigned int sid, unsigned int mysid, unsigned int syc, unsigned int suc, unsigned int svc)
00016   : FilterBankGenerator("InterleavedYUVGenerator",0,1,gid,sid,EventBase::visInterleaveEGID,mysid), src(NULL), srcYChan(syc), srcUChan(suc), srcVChan(svc)
00017 {
00018   setNumImages(numLayers,numChannels);
00019 }
00020 
00021 /*
00022 InterleavedYUVGenerator::~InterleavedYUVGenerator() {
00023   freeCaches();
00024   destruct();
00025 }
00026 */
00027 
00028 void
00029 InterleavedYUVGenerator::processEvent(const EventBase& event) {
00030   const FilterBankEvent& fbkevent=dynamic_cast<const FilterBankEvent& >(event);
00031   src=fbkevent.getSource();
00032   frameNumber=src->getFrameNumber();
00033   if(src->getNumLayers()!=numLayers || src->getNumChannels()!=numChannels)
00034     setNumImages(src->getNumLayers(),1);
00035   if(src->getWidth(numLayers-1)!=getWidth(numLayers-1)) {
00036     ASSERT(widths[numLayers-1]==0,"Strange, the image width changed after initial setting" << widths[numLayers-1]);
00037     setDimensions();
00038   }
00039 
00040   invalidateCaches();
00041   framesProcessed++;
00042   erouter->postEvent(new FilterBankEvent(this,getGeneratorID(),getSourceID()));
00043 }
00044 
00045 unsigned int
00046 InterleavedYUVGenerator::getBinSize() const {
00047   unsigned int used=FilterBankGenerator::getBinSize();
00048   used+=strlen("InterleavedYUVImage")+LoadSave::stringpad;
00049   //if(selectedSaveChannel==CHAN_YUV)
00050   used+=widths[selectedSaveLayer]*heights[selectedSaveLayer]*3;
00051   //else
00052   //used+=widths[selectedSaveLayer]*heights[selectedSaveLayer];
00053   return used;
00054 }
00055 
00056 unsigned int
00057 InterleavedYUVGenerator::LoadBuffer(const char buf[], unsigned int len) {
00058   unsigned int origlen=len;
00059   unsigned int used;
00060   std::string tmp;
00061   if(0==(used=FilterBankGenerator::LoadBuffer(buf,len))) return 0;
00062   len-=used; buf+=used;
00063   if(0==(used=decode(tmp,buf,len))) return 0;
00064   len-=used; buf+=used;
00065   if(tmp!="InterleavedYUVImage") {
00066     serr->printf("Unhandled image type for InterleavedYUVGenerator: %s",tmp.c_str());
00067     return 0;
00068   } else {
00069     //if(selectedSaveChannel==CHAN_YUV) {
00070     used=widths[selectedSaveLayer]*heights[selectedSaveLayer]*3;
00071     if(used>len)
00072       return 0;
00073     if(images[selectedSaveLayer][selectedSaveChannel]==NULL)
00074       images[selectedSaveLayer][selectedSaveChannel]=createImageCache(selectedSaveLayer,selectedSaveChannel);
00075     unsigned char* img=images[selectedSaveLayer][selectedSaveChannel];
00076     if(img==NULL)
00077       return 0;
00078     memcpy(img,buf,used);
00079     len-=used; buf+=used;
00080     imageValids[selectedSaveLayer][selectedSaveChannel]=true;
00081     /*
00082     } else {
00083       used=widths[selectedSaveLayer]*heights[selectedSaveLayer];
00084       if(used>len)
00085         return 0;
00086       unsigned char* img=getImage(selectedSaveLayer,selectedSaveChannel);
00087       if(img==NULL)
00088         return 0;
00089       unsigned int inc=getIncrement(selectedSaveLayer);
00090       for(unsigned int y=0; y<heights[selectedSaveLayer]; y++) {
00091         unsigned char* const rowend=img+widths[selectedSaveLayer]*inc;
00092         while(img!=rowend) {
00093           *img=*buf++;
00094           img+=inc;
00095         }
00096         img+=getSkip(selectedSaveLayer);
00097       }
00098       len-=used; buf+=used;
00099     }
00100     */
00101     return origlen-len; 
00102   }
00103 }
00104 
00105 unsigned int
00106 InterleavedYUVGenerator::SaveBuffer(char buf[], unsigned int len) const {
00107   unsigned int origlen=len;
00108   unsigned int used;
00109   if(0==(used=FilterBankGenerator::SaveBuffer(buf,len))) return 0;
00110   len-=used; buf+=used;
00111   if(0==(used=encode("InterleavedYUVImage",buf,len))) return 0;
00112   len-=used; buf+=used;
00113   
00114   //if(selectedSaveChannel==CHAN_YUV) {
00115   used=widths[selectedSaveLayer]*heights[selectedSaveLayer]*3;
00116   if(used>len)
00117     return 0;
00118   unsigned char* img=getImage(selectedSaveLayer,selectedSaveChannel);
00119   if(img==NULL)
00120     return 0;
00121   memcpy(buf,img,used);
00122   len-=used;
00123   /*
00124   } else {
00125     used=widths[selectedSaveLayer]*heights[selectedSaveLayer];
00126     if(used>len)
00127       return 0;
00128     unsigned char* img=getImage(selectedSaveLayer,selectedSaveChannel);
00129     if(img==NULL)
00130       return 0;
00131     unsigned int inc=getIncrement(selectedSaveLayer);
00132     for(unsigned int y=0; y<heights[selectedSaveLayer]; y++) {
00133       unsigned char* const rowend=img+widths[selectedSaveLayer]*inc;
00134       while(img!=rowend) {
00135         *buf++=*img;
00136         img+=inc;
00137       }
00138       img+=getSkip(selectedSaveLayer);
00139     }
00140     len-=used; buf+=used;
00141   }
00142   */
00143   return origlen-len;
00144 }
00145 
00146 /*
00147 void 
00148 InterleavedYUVGenerator::freeCaches() {
00149   for(unsigned int i=0; i<numLayers; i++) {
00150     for(unsigned int j=0; j<numChannels-1; j++) {
00151       images[i][j]=NULL;
00152       imageValids[i][j]=false;
00153     }
00154   }
00155   FilterBankGenerator::freeCaches();
00156 }
00157 */
00158 
00159 void
00160 InterleavedYUVGenerator::setDimensions() {
00161   for(unsigned int i=0; i<numLayers; i++) {
00162     widths[i]=src->getWidth(i);
00163     heights[i]=src->getHeight(i);
00164     skips[i]=0;
00165     strides[i]=widths[i]*3;
00166   } 
00167 }
00168 
00169 void
00170 InterleavedYUVGenerator::setNumImages(unsigned int nLayers, unsigned int nChannels) {
00171   ASSERT(nChannels==1,"we can only handle a single channel...");
00172   FilterBankGenerator::setNumImages(nLayers,nChannels);
00173   for(unsigned int res=0; res<numLayers; res++)
00174     increments[res]=3;
00175 }
00176 
00177 /*
00178 unsigned char *
00179 InterleavedYUVGenerator::createImageCache(unsigned int layer, unsigned int chan) const {
00180   unsigned char* yuv=new unsigned char[widths[layer]*heights[layer]*3];
00181   for(unsigned int i=0; i<numChannels-1; i++) {
00182     ASSERT(images[layer][i]==NULL,"memory leak?");
00183     images[layer][i]=yuv+i;
00184   }
00185   ASSERT(images[layer][CHAN_YUV]==NULL,"memory leak?");
00186   images[layer][CHAN_YUV]=yuv;
00187   if(chan==CHAN_YUV) {
00188     return yuv;
00189   } else {
00190     return yuv+chan;
00191   }
00192 }
00193 */
00194 
00195 unsigned char *
00196 InterleavedYUVGenerator::createImageCache(unsigned int layer, unsigned int /*chan*/) const {
00197   return new unsigned char[widths[layer]*heights[layer]*3];
00198 }
00199 
00200 void
00201 InterleavedYUVGenerator::calcImage(unsigned int layer, unsigned int chan) const {
00202   PROFSECTION("InterleavedYUVGenerator::calcImage(...)",state->mainProfile);
00203   unsigned char* dimg=images[layer][chan];
00204   const unsigned char* syimg=src->getImage(layer,srcYChan);
00205   const unsigned char* suimg=src->getImage(layer,srcUChan);
00206   const unsigned char* svimg=src->getImage(layer,srcVChan);
00207   const unsigned int inc=src->getIncrement(layer);
00208   //std::cout << src->getWidth(layer) << " inc=" << inc << " skip=" << src->getSkip(layer) << " stride=" << src->getStride(layer) << std::endl;
00209   for(unsigned int y=0; y<getHeight(layer); y++) {
00210     for(unsigned int x=0; x<getWidth(layer); x++) {
00211       *dimg++=*syimg;
00212       *dimg++=*svimg;
00213       *dimg++=*suimg;
00214       syimg+=inc;
00215       suimg+=inc;
00216       svimg+=inc;
00217     }
00218     syimg+=src->getSkip(layer);
00219     suimg+=src->getSkip(layer);
00220     svimg+=src->getSkip(layer);
00221   }
00222   imageValids[layer][chan]=true;
00223 }
00224 
00225 /*! @file
00226  * @brief Implements InterleavedYUVGenerator, which generates FilterBankEvents containing raw camera images with interleaved pixels (YUVYUVYUV... instead of YYY...UUU...VVV...)
00227  * @author ejt (Creator)
00228  *
00229  * $Author: ejt $
00230  * $Name: tekkotsu-2_0 $
00231  * $Revision: 1.7 $
00232  * $State: Exp $
00233  * $Date: 2004/01/16 07:39:50 $
00234  */
00235 

Tekkotsu v2.0
Generated Wed Jan 21 03:20:28 2004 by Doxygen 1.3.4