---

PatGen.cpp

Go to the documentation of this file.

#include "PatGen.hpp"
#include "MPGStream.hpp"
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <fcntl.h>
#ifdef WIN32
#include <io.h>
#else
#include <unistd.h>
#include <qmutex.h>
#include <qwaitcondition.h>
#endif
#include <iostream>
#include <fstream>
#include <qdatastream.h>

PatGen::~PatGen () {
        delete yuv;
        delete mpg;
}

PatGen::PatGen (const QString & yuvfname, const QString & mpgfname,
                                int x, int y, uint fpp) {
        this->init (yuvfname, NULL, mpgfname, x, y, fpp);
}


PatGen::PatGen (const QString & yuvfname, const QString & orgfname,
                                const QString & mpgfname, int x, int y, uint fpp) {

        this->init (yuvfname, orgfname, mpgfname, x, y, fpp);
}


void PatGen::init (const QString & yuvfname, const QString & orgfname,
                           const QString & mpgfname, int x, int y, uint fpp) {

        MPGGOP *mpgpat = NULL;
        YUVGOP *yuvpat = NULL;
        YUVGOP *orgpat = NULL;
        uint fcnt;
        FrameType type;
        YUVFrame *yuvfr = NULL;
        YUVFrame *orgfr = NULL;
        MPGFrame *mpgfr = NULL;

        uint iCount = 0;
        uint pCount = 0;
        uint bCount = 0;

        uint sumI = 0;
        uint sumP = 0;
        uint sumB = 0;

        framesPerGOP = fpp;

        // do not preRead in any case
        this->mpg = new MPGStream (mpgfname, false);
        this->yuv = new YUVStream (yuvfname, x, y, false, fpp);
        if (orgfname) {
                dmsg (0, "org file name given!");
                this->org = new YUVStream (orgfname, x, y, false, fpp);
        }

        width = x;
        height = y;

        // now get sync'd pattern sizes
        while ((mpgpat = (MPGGOP*) mpg->addNextGOP (fpp)) != NULL)      {
                if (((yuvpat=(YUVGOP*) yuv->addNextGOP(mpgpat->getFrameCount ()))==NULL)
                    || (yuvpat->getFrameCount () != mpgpat->getFrameCount ())) {
                        emsg ("YUV Stream does not match MPEG-4 Stream!");
                        break;
                }               
                if (orgfname) {
                        if (((orgpat = (YUVGOP*) org->addNextGOP (mpgpat->getFrameCount ()))
                             == NULL) || (orgpat->getFrameCount () != mpgpat->getFrameCount ())) {
                                fmsg ("Original YUV Stream does not match MPEG-4 Stream!");
                                break;
                        }
                }
                if (orgfname) {
                        yuvpat->setOrgGOP (orgpat);
                        yuvpat->getStream ()->fillBuffer (yuvpat);
                        orgpat->getStream ()->fillBuffer (orgpat);
                        yuvpat->setPSNRmp (yuvpat->computePSNR (orgpat));
                        yuvpat->getStream ()->freeBuffer (yuvpat);
                        orgpat->getStream ()->freeBuffer (orgpat);
                }

                uint baselayerSize = 0;
                uint compFrSize;

                // uint frameNoInStream;
                for (fcnt = 0; fcnt < mpgpat->getFrameCount (); fcnt++) {
                        mpgfr = (MPGFrame *) mpgpat->getFrame (fcnt);
                        yuvfr = (YUVFrame *) yuvpat->getFrame (fcnt);
                        if (orgfname)
                                orgfr = (YUVFrame *) yuvpat->getFrame (fcnt);
                        
                        ASSERT (yuvfr != NULL);
                        ASSERT (mpgfr != NULL);
                        if (orgfname)
                                ASSERT (orgfr != NULL);
                        
                        mpgfr->setYUVFrame (yuvfr);
                        yuvfr->setMPGFrame (mpgfr);
                        type = mpgfr->getType ();
                        yuvfr->setType (type);
                        compFrSize = mpgfr->getByteSize ();
                        yuvfr->setCompressedByteSize (compFrSize);

                        // set no in stream for YUVFrames
                        yuvfr->setNoInStream (mpgfr->getNoInStream ());
                        if (orgfname)
                                orgfr->setNoInStream (mpgfr->
                                                      getNoInStream ());

                        if (type == I_VOP) {
                                iCount++;
                                sumI += compFrSize;
                                mpgfr->setPriority (1);
                                yuvfr->setPriority (1);
                        }
                        else if (type == P_VOP) {
                                pCount++;
                                sumP += compFrSize;
                                mpgfr->setPriority (2);
                                yuvfr->setPriority (2);
                        }
                        else if (type == B_VOP) {
                                bCount++;
                                sumB += compFrSize;
                        }

                        if ((type == I_VOP) || (type == P_VOP))
                                baselayerSize += compFrSize;
#if MYDEBUG >= 4
                        printf ("set YUV frame %i type %s MPGFrame %i compressedSize %i\n", fcnt, (type == I_VOP) ? "I" : (type == P_VOP) ? "P" : (type == B_VOP) ? "B" : "U", mpgfr->getNoInDisplay (), yuvfr->getCompressedByteSize ());
#endif
                }
                yuvpat->setCompressedByteSize (mpgpat->getByteSize ());
                yuvpat->setCompressedBaselayerSize (baselayerSize);

                if ((yuvpat->getGOPNo () == 0)||(yuv->getMinCompressedPatSize () >
                     yuvpat->getCompressedByteSize ()))
                        yuv->setMinCompressedPatSize (yuvpat->
                                                      getCompressedByteSize
                                                      ());

                if ((yuvpat->getGOPNo () == 0) ||
                    (yuv->getMinCompressedBaselayerSize () >
                     yuvpat->getCompressedBaselayerSize ()))
                        yuv->setMinCompressedBaselayerSize (yuvpat->
                                                            getCompressedBaselayerSize
                                                            ());

                if (yuv->getMaxCompressedPatSize () <
                    yuvpat->getCompressedByteSize ())
                        yuv->setMaxCompressedPatSize (yuvpat->
                                                      getCompressedByteSize
                                                      ());

                if (yuv->getMaxCompressedBaselayerSize () <
                    yuvpat->getCompressedBaselayerSize ())
                        yuv->setMaxCompressedBaselayerSize (yuvpat->
                                                            getCompressedBaselayerSize
                                                            ());
        }
}


PatGen::PatGen (const QString & name) {

        QFile file;
        file.setName(name);
        file.open(IO_ReadOnly);

        QDataStream in (&file); // we will serialize the data into file


        char *yuvName, *mpgName;
        int width, height;
        uint fpg;

        in >> yuvName >> mpgName >> width >> height >> fpg;

        this->init (yuvName, NULL, mpgName, width, height, fpg);
}

int PatGen::getWidth() { return width; }

int PatGen::getHeight() { return height; }

YUVStream* PatGen::getYUVStream() { return yuv; }

YUVStream* PatGen::getOrgStream() { return org; }

MPGStream* PatGen::getMPGStream() { return mpg; }

---