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
00023
00024
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
00050 used+=widths[selectedSaveLayer]*heights[selectedSaveLayer]*3;
00051
00052
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
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
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
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
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
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143 return origlen-len;
00144 }
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
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
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195 unsigned char *
00196 InterleavedYUVGenerator::createImageCache(unsigned int layer, unsigned int ) 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
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
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235