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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

PSNR.cpp

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


PSNR::PSNR(VideoESInfo* esi, YUVStreamIO *OrigYUVStream, Statistics *statistics, FILE* psnrFP) {

        es = esi;
        yuvOrig = OrigYUVStream;
        sumPSNR = 0.0;
        dummyFrame = NULL;
        numFrames = 0;
        numFramesNotInf = 0;
        lastAU.payload = NULL;
        stats = statistics;
        strcpy(name,"PSNR");
        assert (yuvOrig->open());
        psnrInfo=psnrFP;
        initialized=false;
}


PSNR::~PSNR() {

        delete yuvOrig;
        if (dummyFrame) {
                dummyFrame->unsetAU();
                delete dummyFrame;
        }
        if(psnrInfo)
                fclose(psnrInfo);
}


void PSNR::initialize() {
        if(!initialized) {
                if(psnrInfo) {
                        fprintf(psnrInfo,"Second status Orig_CTS Compr_CTS framePSNR thisSecAvgPSNR totalAvgPSNR numFramesPerSec SumNumFrames SumNumFramesNotInfinite\n");
                }
                initialized=true;
        }
}


/***************************************************************/
list < Frame * > PSNR::adapt(Frame * frm) {
        list < Frame * >tmp;
        u32 thisCTS;
        double psnr;
        int thisSec;
        int done=0;
        if(!this->initialized)
                initialize();

        UncompressedVideoFrame *thisFrame = (UncompressedVideoFrame*)frm;
        thisCTS = frm->getAU()->cts;
        thisSec = (int)floor((double)thisCTS / es->getMediaTimeScale());
        UncompressedVideoFrame *origFrame;
        dprintf_full("PSNR::adapt frame CTS %i, VOP increment %i, playoutSec: %6.3f\n",
                                                         thisCTS,es->getVOPTimeIncrement(),stats->getPlayoutSec());
        
        //first frame, malloc payload, size is always the same for YUV frames!
        if (!lastAU.payload) {
                dprintf_full("PSNR::adapt creating initial buffers\n");
                lastPayload = (u8*)malloc(thisFrame->getAU()->size);
                lastAU.payload = lastPayload;
                lastAU.size = thisFrame->getAU()->size;
                dummyFrame = new UncompressedVideoFrame(Frame::NN_VOP, thisFrame->getWidth(), thisFrame->getHeight());
                dummyFrame->setMediaTimeScale(thisFrame->getMediaTimeScale());
                dummyFrame->setAU(&lastAU,false); //disable detectFrameType() for efficiency!
        }

        while(!done) {
                numFrames++;
                origFrame = (UncompressedVideoFrame *)yuvOrig->getFrame();
                assert(origFrame);
                assert(origFrame->getAU()->cts <= thisCTS);
                psnr=0;

                if (origFrame->getAU()->cts == thisCTS) { //NO FRAME LOSS
                        psnr = thisFrame->computePSNR(origFrame);
                        done=1;
                } else { //catch up BECAUSE OF FRAME LOSS
                        psnr = dummyFrame->computePSNR(origFrame);
                        dprintf_full("PSNR::adapt dummyADAPT!\n");
                }
                if (psnr < DBL_MAX) {
                        numFramesNotInf++;
                        sumPSNR+=psnr;
                        stats->incPlayoutSecPSNR(thisSec, psnr);
                }

                if (done) {
                        dprintf_full("PSNR::adapt: (sec %i), origFrame CTS %8i thisFrame CTS %8i: thisPSNR %3.3f thisSecAvgPSNR %3.3f thisSecFPS %i   overallPSNR  %3.3f\n",
                                                                         thisSec, origFrame->getAU()->cts, thisCTS,  psnr,
                                                                         stats->getPlayoutSecPSNR(thisSec), stats->getPlayoutSecFPS(thisSec),
                                                                         sumPSNR/numFramesNotInf);
                } else {
                        dprintf_full("PSNR::adapt: (sec %i), origFrame CTS %8i dummyFrame CTS %8i: thisPSNR %3.3f thisSecAvgPSNR %3.3f thisSecFPS %i   overallPSNR  %3.3f\n",
                                                                         thisSec, origFrame->getAU()->cts, dummyFrame->getAU()->cts, psnr,
                                                                         stats->getPlayoutSecPSNR(thisSec), stats->getPlayoutSecFPS(thisSec),
                                                                         sumPSNR/numFramesNotInf);
                }

                if(psnrInfo) {
                        fprintf(psnrInfo,"%8i %s %8i %8i %6.3f %6.3f %6.3f %8i %8i %8i\n",
                                                        thisSec, done?"OK  ":"DROP", origFrame->getAU()->cts, done?thisCTS:dummyFrame->getAU()->cts, psnr,
                                                        stats->getPlayoutSecPSNR(thisSec), sumPSNR/numFramesNotInf,
                                                        stats->getPlayoutSecFPS(thisSec), numFrames, numFramesNotInf);
                }
                delete origFrame;
        }

        
        assert(lastAU.size == thisFrame->getAU()->size);
        dummyFrame->unsetAU();
        lastAU = thisFrame->getAU();
  lastAU.payload = lastPayload;
        lastAU.size = thisFrame->getAU()->size;
        memcpy(lastAU.payload, thisFrame->getAU()->payload, thisFrame->getAU()->size);
        dummyFrame->setAU(&lastAU,false); //disable detectFrameType() for efficiency!
 
        //standard forwarding adaptor behaviour
        tmp.push_front(frm);
        return tmp;
}

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