Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

YUVSpatialReductionAdaptor.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       YUVSpatialReductionAdaptor.cpp                                *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         *
 * GNU General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#include "YUVSpatialReductionAdaptor.hpp"
#include "string.h"
#include "math.h"


YUVSpatialReductionAdaptor::YUVSpatialReductionAdaptor(VideoESInfo * pESInfo,
                                                       u32 * puiWidth,
                                                       u32 * puiHeight) {
        es = pESInfo;
        initialized = false;
        muiTargetWidth = *puiWidth;
        muiTargetHeight = *puiHeight;
        strcpy(name,"YUVSpatialReductionAdaptor");
}


void YUVSpatialReductionAdaptor::initialize() {
        if(initialized)
                return;
        
  muiWidth = es->getWidth();
  muiHeight = es->getHeight();
        
  if (muiTargetWidth % 2 == 1)
                muiTargetWidth += 1;
  if (muiTargetHeight % 2 == 1)
                muiTargetHeight += 1;

        // disable upscaling, let the hw do this when rendering to the screen!!!
        // this allows us to reuse the incoming frame, os we don't have to newly
        // allocate memory
        if(muiTargetWidth>muiWidth)
                muiTargetWidth=muiWidth;
        if(muiTargetHeight>muiHeight)
                muiTargetHeight=muiHeight;

  es->setWidth(muiTargetWidth);
  es->setHeight(muiTargetHeight);

  muiScaleFactorWidth = (u32) ((muiTargetWidth * 1000000) / muiWidth) ;
  muiScaleFactorHeight = (u32)((muiTargetHeight* 1000000) / muiHeight) ;
  initialized = true;

  dprintf_full("Scalefactors [w|h]: [%i|%i]\n", muiScaleFactorWidth,
                 muiScaleFactorHeight);
}


YUVSpatialReductionAdaptor::~YUVSpatialReductionAdaptor() {
}


list < Frame * >YUVSpatialReductionAdaptor::adapt(Frame * frm) {
        list < Frame * >retFrameList;
        if (!initialized)
                initialize();
        
        if (!initialized)
                return retFrameList;
        
        u32 h, w, hOrig, wOrig;
        u8 *pOffsetTarget=NULL;
        u8 *pOffsetOrig=NULL;
        
        u8 *origFrame = frm->getAU()->payload;
        pOffsetOrig = origFrame;
        
        // u8 *retFrame = new u8[muiTargetWidth * muiTargetHeight * 3 / 2];
        // memset(retFrame, 128, muiTargetWidth * muiTargetHeight * 3 / 2);
        u8* retFrame=origFrame; // reuse incoming frame
        pOffsetTarget = retFrame;
        
        
        // Y
        for (h = 0; h < muiTargetHeight; h++) {
                for (w = 0; w < muiTargetWidth; w++) {
            // hOrig = (u32) (((float)h)/mfScaleFactorHeight);
            // wOrig = (u32) (((float)w)/mfScaleFactorWidth);
            hOrig = (u32) ((h * 1000000) / muiScaleFactorHeight);
            wOrig = (u32) ((w * 1000000) / muiScaleFactorWidth);
            pOffsetTarget[h * muiTargetWidth + w] =
                                pOffsetOrig[hOrig * muiWidth + wOrig];
                }
        }
        // V
        pOffsetOrig = pOffsetOrig + muiWidth * muiHeight;
        pOffsetTarget = pOffsetTarget + muiTargetWidth * muiTargetHeight;
        for (h = 0; h < muiTargetHeight / 2; h++) {
                for (w = 0; w < muiTargetWidth / 2; w++) {
            // hOrig = (u32) (((float)h)/mfScaleFactorHeight);
            // wOrig = (u32) (((float)w)/mfScaleFactorWidth);
            hOrig = (u32) ((h * 1000000) / muiScaleFactorHeight);
            wOrig = (u32) ((w * 1000000) / muiScaleFactorWidth);
            pOffsetTarget[h * muiTargetWidth / 2 + w] =
                                pOffsetOrig[hOrig * muiWidth / 2 + wOrig];
                }
        }
        // U
        pOffsetOrig = pOffsetOrig + muiWidth * muiHeight / 4;
        pOffsetTarget = pOffsetTarget + muiTargetWidth * muiTargetHeight / 4;
        for (h = 0; h < muiTargetHeight / 2; h++) {
                for (w = 0; w < muiTargetWidth / 2; w++) {
            // hOrig = (u32) (((float)h)/mfScaleFactorHeight);
            // wOrig = (u32) (((float)w)/mfScaleFactorWidth);
            hOrig = (u32) ((h * 1000000) / muiScaleFactorHeight);
            wOrig = (u32) ((w * 1000000) / muiScaleFactorWidth);
            pOffsetTarget[h * muiTargetWidth / 2 + w] =
                                pOffsetOrig[hOrig * muiWidth / 2 + wOrig];
                }
        }
        
        frm->getAU()->payload = retFrame;
        frm->getAU()->size = muiTargetWidth * muiTargetHeight * 3 / 2; // YV12
        retFrameList.push_back(frm);
        return retFrameList;
}


list < Frame * >YUVSpatialReductionAdaptor::close() {
        list < Frame * >retFrameList;
        
        return retFrameList;
}


Adaptor *YUVSpatialReductionAdaptor::clone() {
        u32 w=muiTargetWidth;
        u32 h=muiTargetHeight;
        return new YUVSpatialReductionAdaptor(es,&w,&h);
}

© ViTooKi 2003 :: [Lite version] Created with Doxygen