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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

UncompressedVideoFrame.cpp

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


UncompressedVideoFrame::UncompressedVideoFrame(FrameType t, int w, int h) : VideoFrame(t,w,h)
{
  this->psnr = ERR_PSNR;

        setType(t);

        if (getType() == YUV_VOP)
                colorSpace = ColorSpaceYV12;
        else 
                if (getType() == RGB_VOP)
                        colorSpace = ColorSpaceRGB24;
                else
                        colorSpace = ColorSpaceUNKNOWN;
        
}



UncompressedVideoFrame::~UncompressedVideoFrame() {
}


/* set to I-frames so that seekToIFrame works on YUVStreams */
Frame::FrameType UncompressedVideoFrame::detectFrameType() {

#ifndef WINCE
        if (!(accessUnit && accessUnit->payload)) {
                return ERROR_VOP;
        }
#endif

        //we detect if it is YUV_VOP or RGB_VOP by comparing the payload size
        if (accessUnit->size == width * height * 1.5)
                setType( YUV_VOP );
        else
                setType( RGB_VOP );

        
        return getType();
};


Frame::FrameType UncompressedVideoFrame::detectFrameType(AU* accessUnit) {
        Frame::FrameType type=Frame::ERROR_VOP;
        
        if (!(accessUnit && accessUnit->payload)) {
                return type;
        }

        //problem: there is no way to detect YUV! make it an "important" frame :)
        type = Frame::HEADER_VOP;
        return type;
}


int UncompressedVideoFrame::mapColorSpaceToBitDepth(ColorSpace colorspace) {
        switch (colorspace) {
                case ColorSpaceRGB32:
                        return 32;
                        break;
                case ColorSpaceRGB24:
                        return 24;
                        break;
                case ColorSpaceRGB565:
                        return 16;
                        break;
                case ColorSpaceGRAY8:
                        return 8;
                        break;
                case ColorSpaceYV12: // FIXME: not perfect, but 8 is well-used for adaptors/FrameRotate...
                case ColorSpaceI420:
                        return 8;
                        break;
                default:
                        dprintf_err("MP4Decoder::mapColorSpaceToBitDepth: Unknown colorspace\n");
                        exit(-1);
        }
}


/* should transcode a single frame to another colorspace */
UncompressedVideoFrame* UncompressedVideoFrame::convertToColorSpace(UncompressedVideoFrame::ColorSpace cs) {
        if (colorSpace == ColorSpaceYV12) {
        
                long int    i, j, uv_i, uv_j, x, r, g, b,y,u,v, cnt;
                char* data_y;
                char* data_u;
                char* data_v;
                u8* payload;
                int   pixel;
                int    width_uv  = width/2;
                int    height_uv = height/2;
                int depth = mapColorSpaceToBitDepth(cs);
                UncompressedVideoFrame* frm;
                                                                                                                                                                                                                                               
                
                switch (cs) {
                case ColorSpaceRGB32:
                case ColorSpaceRGB24:
                case ColorSpaceRGB565:
                        frm = new UncompressedVideoFrame( RGB_VOP, width, height);
                        frm->setAU(new AU(this->getAU()));

                        payload = (u8*)malloc(width*height*(depth/8));


#ifdef BUILD_ARCH_ARM
                        //SUPER HACK....
                        // adding cache support for transcoded image... only for one... works for our hourglass splashscreen scenario
#define ARM_HOURGLASS_CACHE "/media/ram/hourglass.rgb565"
                        FILE* fp = fopen(ARM_HOURGLASS_CACHE ,"r");
                        if (fp != NULL) {
                                fread(payload, width*height*(depth/8), 1, fp);
                                frm->getAU()->payload = payload;
                                frm->getAU()->size = width*height*(depth/8);
                                fclose(fp);
                                dprintf_err("UncompressedVideoFrame::convertToColorSpace RGB depth %i: reading from cache file!! real code not executed!\n",depth);
                                return frm;
                        }
#endif
                        getYBuffer((u8**)&data_y);
                        getUBuffer((u8**)&data_u);
                        getVBuffer((u8**)&data_v);
                        
                        
                        for(uv_i = 0; uv_i < height_uv; uv_i++)
                                for(uv_j = 0; uv_j < width_uv; uv_j++) {
                                        
                                        u = data_u[uv_i * width_uv + uv_j]; /* U value */
                                        v = data_v[uv_i * width_uv + uv_j]; /* V value */
                                        
                                        x=0; 
                                        while(x < 4) {
                                                if (x == 0) {
                                                        /* first pixel */
                                                        i = uv_i * 2;  j = uv_j * 2;
                                                } else {
                                                        /* second, 3rd, 4th  pixel */
                                                        if (x==1) i++;
                                                        else if (x==2) j++;
                                                        else if (x==3) i--;
                                                }
                                                x++;
                                                y = data_y[i*width+j];  /* Y value */
                                                
                                                r = (long int)round(y + (1.370705 * (v-128)));
                                                g = (long int)round(y - (0.698001 * (v-128)) - (0.337633 * (u-128)));
                                                b = (long int)round(y + (1.732446 * (u-128)));
                                                
                                                // Even with proper conversion, some values still need clipping.
                                                if (r > 255) r = 255; if (g > 255) g = 255;
                                                if (b > 255) b = 255; if (r < 0) r = 0;
                                                if (g < 0) g = 0; if (b < 0) b = 0;
                                                
                                                if (depth==16) {
                                                        ((u16*)(payload))[i*width+j] = ((r >> 3) << 11) + ((g >> 2) << 5) + (b >> 3);
                                                } else
                                                        if (depth==32) {
                                                                ((u32*)(payload))[i*width+j] = ((r << 16) + (g << 8) + b);
                                                        } else
                                                                assert("THIS RGB DEPTH IS NOT_SUPPORTED" && (1==0));
                                                cnt++;
                                        } //yuv 4:2:2 four pixel while
                                } //scan yuv pic
                                
                                frm->getAU()->payload = payload;
                                frm->getAU()->size = width*height*(depth/8);

#ifdef BUILD_ARCH_ARM
                                //SUPER HACK....write away the rgb565 into a cache
                                        fp = fopen(ARM_HOURGLASS_CACHE ,"w");
                                if (fp != NULL) {
                                        fwrite(payload, width*height*(depth/8), 1, fp);
                                        fclose(fp);
                                }
#endif
                                dprintf_full("UncompressedVideoFrame::convertToColorSpace RGB depth %i by calculating\n",depth);
                                return frm;
                                break;
                        case ColorSpaceYV12:
                                //no conversion needed... 
                                return NULL;
                                break;
                        case ColorSpaceI420:
                        case ColorSpaceGRAY8:
                        default:
                                dprintf_err("UncompressedVideoFrame::convertToColorSpace does not support this destination colorSpace!\n");
                                exit(-1);
                        }                               
                
        } else {
                dprintf_err("UncompressedVideoFrame::convertToColorSpace does not support RGB->YUV yet!\n");
                return NULL;
        }
}


int UncompressedVideoFrame::getYBuffer(u8** buf) {

        assert((colorSpace == ColorSpaceI420) || (colorSpace == ColorSpaceYV12));

        if(accessUnit->payload && accessUnit->size > 0)
        {
                *buf = accessUnit->payload;
                return width*height;
        }
        else
        {
                *buf = NULL;
                return -1;
        }
}


int UncompressedVideoFrame::getUBuffer(u8** buf) {

        assert((colorSpace == ColorSpaceI420) || (colorSpace == ColorSpaceYV12));

        if(accessUnit->payload && accessUnit->size > 0)
        {
                *buf = accessUnit->payload + (width*height);
                return width*height/4;
        }
        else
        {
                *buf = NULL;
                return -1;
        }
}
        
        
int UncompressedVideoFrame::getVBuffer(u8** buf) {

        assert((colorSpace == ColorSpaceI420) || (colorSpace == ColorSpaceYV12));

        if(accessUnit->payload && accessUnit->size > 0)
        {
                *buf = accessUnit->payload + (width*height) + width*height/4;
                return width*height/4;
        }
        else
        {
                *buf = NULL;
                return -1;
        }
}


double UncompressedVideoFrame::computePSNRwithOffset(UncompressedVideoFrame *other, long offset) {
  double rmse = 0;
        double mse = 0;
  int k = 0;
  int temp = 0;
  unsigned char *otherData;
  unsigned char *thisData;

  int width = this->getWidth();
  int height = this->getHeight();


        assert((colorSpace == ColorSpaceI420) || (colorSpace == ColorSpaceYV12));

        assert (width > 0 && height > 0);
        //dprintf_full("UncompressedVideoFrame::computePSNRwithOffset %i (%ix%i)\n",offset,width,height);

        if (other->getAU())
                otherData = (unsigned char *) other->getAU()->payload;
        else
                return ERR_PSNR;
        if (this->getAU())
                thisData = (unsigned char *) this->getAU()->payload;
        else
                return ERR_PSNR;

        /*
        if (offset == 0)  //optimized
          for (int i = 0; i < width; i++) {
                        for (int j = 0; j < height; j++) {
                                temp = (thisData[k] - otherData[k]);
                                mse += (double)(temp * temp);
                                k++;
                        }
                }
        else // use offset calculations
        */
          for (int i = 0; i < width; i++) {
                        for (int j = 0; j < height; j++) {
                                temp = thisData[k + offset] -
                                        otherData[k + offset];
                                mse += (double)(temp * temp);
                                k++;
                        }
                }

  if (mse == 0) {
         // frames are equal return maxPSNR of stream
                // FIXME: ignored now... will return INFINITE
  }

  mse = (double) mse / ((double) width * (double) height);
  rmse = sqrt(mse);
  return 20 * log10(255.0 / rmse);
}


double UncompressedVideoFrame::computePSNRy(UncompressedVideoFrame * other) {

        return computePSNRwithOffset(other,0); //y component has 0 offset

}


double UncompressedVideoFrame::computePSNRu(UncompressedVideoFrame * other) {
        return computePSNRwithOffset(other,width*height); // after Y buf
}


double UncompressedVideoFrame::computePSNRv(UncompressedVideoFrame * other) {
        return computePSNRwithOffset(other,width*height +(width*height/4) ); // after Y+U buf
}


double UncompressedVideoFrame::computePSNR(UncompressedVideoFrame * other) {
        
        psnr = this->computePSNRy(other);
        return psnr;
}

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