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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

FrameRotate.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: FrameRotate.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 "FrameRotate.hpp"


void FrameRotate::setESInfo(ESInfo * esi)
{
    es = (VideoESInfo*)esi;
                // FIXME???
        //      initialized=false;
}


ESInfo *FrameRotate::getESInfo()
{
    return es;
}

/***********************************************/
FrameRotate::FrameRotate(VideoESInfo * pESInfo, u32 degrees)
{
        es = pESInfo;
        strcpy(name,"FrameRotate");
        initialized = false;
        this->degrees = degrees;
        switch (degrees) {
        case 90: 
        case 270:
                muiTargetWidth = es->getHeight();
                muiTargetHeight = es->getWidth();
                break;
        case 180:  //mirror
        case 360:  //ignore and bypass
                muiTargetWidth = es->getWidth();
                muiTargetHeight = es->getHeight();
                break;
        default:
                dprintf_full("FrameRotate: rotating %i degrees is not supported!\n",degrees);
                ::exit(1);
                break;
        }

        //      initialize();
}



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

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

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

  initialized = true;

  dprintf_full("FrameRotate::initialize %ix%i --> %ix%i rotate %i degrees\n", 
                                                         muiWidth, muiHeight, muiTargetWidth, muiTargetHeight, degrees);
}



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


/***********************************************/
list < Frame * > FrameRotate::adapt(Frame * frm) {
        list < Frame * >retFrameList;
        
        UncompressedVideoFrame* ufrm = (UncompressedVideoFrame*)frm;
  dprintf_full("FrameRotate::adapt frame %ix%i\n",(u32)ufrm->getWidth(),(u32)ufrm->getHeight()  );
        if ( !initialized ||  ((u32)ufrm->getWidth() != muiWidth) 
                         || ((u32)ufrm->getHeight() != muiHeight) ) {
                //resolution has changed because of stream switching
                initialize();
        }

        //to be save on switching, always set ES dimensions
  es->setWidth(muiTargetWidth);
  es->setHeight(muiTargetHeight);

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

        if ( degrees == 360 ) {
                retFrameList.push_back(frm); //same size, so leave untouched
                return retFrameList;            
        }


        register u8 *origFrame = frm->getAU()->payload;
        register u8 *retFrame = new u8[frm->getAU()->size];
        register int w = ufrm->getWidth();
        register int h = ufrm->getHeight();
        register int w2 = muiTargetWidth;
        register int h2 = muiTargetHeight;
        register int x=0,y=0;
        register u8 *p = retFrame;
        register u8 bpp = UncompressedVideoFrame::mapColorSpaceToBitDepth(ufrm->getColorSpace())/8;
        register u32 value;
        register u32 pitch = w*bpp;
        register u32 pitch2 = w2*bpp;

        //      memset(retFrame,0,frm->getAU()->size);
        //      assert(ufrm->getAU()->size == w * h * bpp);
        switch (degrees) {
        case 90: // 90 degrees ////////////////////////////////////////////
                for (x=0; x < w; x++) {
                        for (y=h-1; y >= 0; y--) {
                                value = *(u32*)((u8*)(origFrame)+y*pitch + x*bpp);

                                switch (ufrm->getColorSpace()) {
                                case UncompressedVideoFrame::ColorSpaceGRAY8:  //1 byte
                                        *(u8*)p = value;
                                        break;
                                case UncompressedVideoFrame::ColorSpaceRGB565: //2 byte
                                //assume little endian
                                        p[0] = value & 0xff;
                                        p[1] = (value >> 8) & 0xff;
                                        break;
                                case UncompressedVideoFrame::ColorSpaceRGB24:  //3 byte
                                        //assume little endian
                                        p[0] = value & 0xff;
                                        p[1] = (value >> 8) & 0xff;
                                        p[2] = (value >> 16) & 0xff;
                                        break;
                                case UncompressedVideoFrame::ColorSpaceRGB32:  //4 byte
                                        *(u32*)p = value;
                                        break;
                                case UncompressedVideoFrame::ColorSpaceYV12:
                                case UncompressedVideoFrame::ColorSpaceI420:
                                        *(u8*)p = value; // Y component
                                        break;
                                default:
                                        dprintf_err("FrameRotate::adapt: invalid color space: %d\n", ufrm->getColorSpace());
                                        ::exit(1);
                                }
                                p++;
                        }
                }
                
                //for YUV, write U and V component
                if ( (ufrm->getColorSpace() == UncompressedVideoFrame::ColorSpaceYV12) || 
                                 (ufrm->getColorSpace() ==  UncompressedVideoFrame::ColorSpaceI420) ) {
                                         u8 *ofrm = origFrame;
                                         u8 *rfrm = retFrame;
                                         ofrm += pitch*h;
                                         rfrm += pitch2*h2;
                                         p = rfrm;
                                         pitch /= 2;
                                         pitch2 /= 2;
                                         for (int i=0; i<2; i++) { // U or V component
                                                 for (x=0; x < w/2; x++) {
                                                         for (y=(h/2)-1; y >= 0; y--) {
                                                                 value = *(u32*)((u8*)(ofrm)+y*pitch + x);
                                                                 *(u8*)p++ = value;
                                                         }
                                                 }
                                                 ofrm += (pitch*h)/2;
                                                 rfrm += (pitch2*h2)/2;

                                         }
                                 }

                break;
        case 180: // 180 degrees ////////////////////////////////////////////
        case 270: // 270 degrees ////////////////////////////////////////////
                //      case 360: //catched above!
        default:
                dprintf_err("Sorry, rotating by %i degrees not (yet) supported....\n",degrees);
                ::exit(1);
                break;
        }



        
 
 frm->getAU()->payload = retFrame;
 frm->getAU()->size = frm->getAU()->size;
 retFrameList.push_back(frm);
 delete origFrame; // not needed any more
 
 return retFrameList;
}


Adaptor *FrameRotate::clone() {
        return new FrameRotate(es, degrees);
}

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