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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

YUVScalingAdaptor.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: YUVScalingAdaptor.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 "YUVScalingAdaptor.hpp"
#include "UncompressedVideoFrame.hpp"
#include "string.h"
#include "math.h"


/****************************************************/
YUVScalingAdaptor::YUVScalingAdaptor(VideoESInfo * pESInfo,
                                                                                                                                                 u32 width,
                                                                                                                                                 u32 height)
{
        es = pESInfo;
        initialized = false;
        muiTargetWidth = width;
        muiTargetHeight = height;
        strcpy(name,"YUVScalingAdaptor");
        initialize();
}


/****************************************************/
void YUVScalingAdaptor::initialize() {

  muiWidth = es->getWidth();
  muiHeight = es->getHeight();


        //FIXME: this should go into the out_es (all ViTooKi Adaptors should have this....)
        // es->setWidth(muiTargetWidth);
  //es->setHeight(muiTargetHeight);

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

  dprintf_full("YUVScalingAdaptor::initialize %ix%i --> %ix%i Scalefactors [w|h]: [%i|%i]\n", 
                                                         muiWidth,muiHeight,muiTargetWidth,muiTargetHeight,muiScaleFactorWidth, muiScaleFactorHeight);
}



/****************************************************/
YUVScalingAdaptor::~YUVScalingAdaptor() {
}


/****************************************************/
list < Frame * > YUVScalingAdaptor::adapt(Frame * frm) {
        list < Frame * >retFrameList;
        UncompressedVideoFrame* ufrm = (UncompressedVideoFrame*)frm;

        if ( ((u32)ufrm->getWidth() != muiWidth) 
                        || ((u32)ufrm->getHeight() != muiHeight) ) {
                //resolution has changed because of stream switching
                initialize();
        }

        if (ufrm->getType() != Frame::YUV_VOP) {
                dprintf_err("YUVScalingAdaptor::adapt does only support YUV frames!\n");
                ::exit(1);
        }

        //to be save on switching, always set ES dimensions
        //not anymore: FIXME: this should go into the out_es (all ViTooKi Adaptors should have this....)
        // es->setWidth(muiTargetWidth);
  //es->setHeight(muiTargetHeight);

  dprintf_full("YUVScalingAdaptor::adapt %ix%i --> %ix%i\n", muiWidth,muiHeight,muiTargetWidth,muiTargetHeight);

        if ( (muiWidth == muiTargetWidth) && (muiHeight == muiTargetHeight) ) {
                retFrameList.push_back(frm); //same size, so leave untouched
                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);
        pOffsetTarget = retFrame;


        // Y
        for (h = 0; h < muiTargetHeight; h++) {
                for (w = 0; w < muiTargetWidth; w++) {
            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) ((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) ((h * 1000000) / muiScaleFactorHeight);
            wOrig = (u32) ((w * 1000000) / muiScaleFactorWidth);
            pOffsetTarget[h * muiTargetWidth / 2 + w] = pOffsetOrig[hOrig * muiWidth / 2 + wOrig];
                }
        }

  ufrm->setWidth(muiTargetWidth);
  ufrm->setHeight(muiTargetHeight);
        frm->getAU()->payload = retFrame;
        frm->getAU()->size = muiTargetWidth * muiTargetHeight * 3 / 2; // YV12
        retFrameList.push_back(frm);
  delete origFrame; // not needed any more

        return retFrameList;
}


/****************************************************/
list < Frame * >YUVScalingAdaptor::close() {
        list < Frame * >retFrameList;

        return retFrameList;
}



/****************************************************/
Adaptor *YUVScalingAdaptor::clone() {
        return new YUVScalingAdaptor(es,muiTargetWidth,muiTargetHeight);
}

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