|| || || || || || || ||

---

VideoJpgCamera.h

Go to the documentation of this file.

/*
12345678901234567890123456789012345678901234567890123456789012345678901234567890
*/
// Author: Richard van Balen

#ifndef Impala_Application_SDash_VideoJpgCamera_h
#define Impala_Application_SDash_VideoJpgCamera_h

#include <time.h>

#ifndef Impala_Core_Array_Arrays_h
#include "Core/Array/Arrays.h"
#endif

#ifndef Impala_Core_Array_ReadJpg_h
#include "Core/Array/ReadJpg.h"
#endif

#ifndef Impala_Visualisation_RgbOglImage_h
#include "Visualization/RgbOglImage.h"
#endif

#ifndef OglGui_Window_h
#include "OglGui/Window.h"
#endif

#include "Visualization/Video.h"

namespace Impala {
namespace Application {
namespace SDash {

// Note: rudimentary: no listener no minFrame/maxFrame yet
class VideoJpgCamera : public OglGui::Window
{
typedef Impala::Core::Array::Array2dVec3UInt8   Array2dVec3UInt8;
typedef OglGui::Window                          Window;
public:

    VideoJpgCamera(int x, int y, int w, int h, Visualization::Video& video, bool doLoop = true):
        Window(x, y, w, h), mVideo(&video)
    {
        Init(w, h, doLoop);
    }

    VideoJpgCamera(Window* parent, int w, int h, Visualization::Video& video, bool doLoop = true):
        Window(parent, w, h), mVideo(&video)
    {
        Init(w, h, doLoop);
    }

    VideoJpgCamera(Window* parent,int x,int y,int w,int h, Visualization::Video& video, bool doLoop = true):
        Window(parent, x, y, w, h), mVideo(&video)
    {
        Init(w, h, doLoop);
    }

    //void    TimePerFrame(float seconds)     { mTimePerFrame = seconds; } // SK: is now taken from mVideo
    float   TimePerFrame()                  { return mTimePerFrame; }
    int     FrameNr()                       { return mFrameNr; }

    void OpenVideo(Visualization::Video& video)
    {
        mVideo = &video;
        mTimePerFrame = mVideo->GetTimePerFrame();
        mFirstFrameNr = mVideo->GetNrOfFirstFrame();
        mLastFrameNr = mVideo->GetNrOfLastFrame();

        if (mOglView)
            viewSys.SetImage(mOglView,0);
        mArray = 0;
        OGLIMAGE* im = OglImageReadFirstFrame();
        IsPower2(mImW, &mPower2W);
            IsPower2(mImH, &mPower2H);
            im->noTexScaling = 1;

        if (!mOglView)
        {
            mOglView = viewSys.View2D(mOglWnd, NULL, 0, 0, W(), H());
                    viewSys.SetColor(mOglView, OGL_BG, 0x400000ff);
                    viewSys.SetColor(mOglView, OGL_BORDER, oglWHITE);
            viewSys.SetTexturing(mOglView, true);
            viewSys.SetTags(mOglView, FlexViewTags & ~deletableTag);
            viewSys.SetTags(mOglView, selectedTag);
        }

        if (mOglView)
            viewSys.SetImage(mOglView, im);
        oglSys.ReleaseOglImage(im);
    }

    void Play(int startTimeOffset = 0)
    {
        mStartTime = clock();
        mStartTimeOffset = startTimeOffset;
        mPlaying = true;
        oglSys.SetAlwaysDraw(mOglWnd, true);
    }

    OGLVIEW* OglView()
    {
        return mOglView;
    }

    void FitViewToWindow(bool mode)     { mFitViewToWindow = mode; }
    bool FitViewToWindow()              { return mFitViewToWindow; }
    void ScaleImageToView(bool mode)    { mScaleImageToView = mode; }
    bool ScaleImageToView()             { return mScaleImageToView; }

    virtual void InitDisplayFunc()
    {
        if (mFitViewToWindow && mOglView)
            viewSys.SetDimensions(mOglView, 2, 2, W()-4, H()-4);

        if (mOglView && mScaleImageToView && mOglView->im)
        {
            float   zX = W()/(float)mImW;
            float   zY = H()/(float)mImH;
            if (mOglView->texturing && mOglView->im->noTexScaling)
            {
                zX = (W()/(float)mImW)*(mPower2W/(float)mImW);
                zY = (H()/(float)mImH)*(mPower2H/(float)mImH);
            }
                    viewSys.SetZoom(mOglView, zX, zY);
        }
        Window::InitDisplayFunc();
    }

    virtual void DisplayFunc()
    {
        clock_t  cpuTime = clock();

            if (mPlaying && mOglView){
            float   elapsedTime = ((cpuTime-mStartTime) / (float) CLOCKS_PER_SEC) + (float) mStartTimeOffset;
            int     nFrameNr = elapsedTime / mTimePerFrame;
            if ((mFrameNr != nFrameNr) && ((mFrameNr < mLastFrameNr) || mDoLoop))
            {
                mFrameNr = nFrameNr-1;
                    NextFrameIntoOglImage(mOglView->im );
            }
        }
        if (mOglView && mOglView->rotZ<0)
            mOglView->rotZ += 30;
        Window::DisplayFunc();
    }

    // reads first frame to display; this is not necessarily 
    // frame with number '0'
    OGLIMAGE* OglImageReadFirstFrame()
    {
        mFrameNr = mFirstFrameNr;
        mVideo->GetFramePath(mFrameNr, mNameBuf);
        ReadJpg(mArray,mNameBuf);

            mImW = mArray->CW();
            mImH = mArray->CH();

        return Impala::Visualization::RgbOglImage::OglImage(mArray);
    }

    void NextFrameIntoOglImage(OGLIMAGE *oglIm)
    {
        mFrameNr++;
        //if (mFrameNr > mLastFrameNr || mFrameNr < 0)
        //    mFrameNr = mVideo->GetNrOfFirstFrame();
        mFrameNr = ((mFrameNr - mFirstFrameNr) % mVideo->GetTotalNrOfFrames()) + mFirstFrameNr;
        if (mArray)
            delete mArray;
        mArray = 0;
        mVideo->GetFramePath(mFrameNr, mNameBuf);
        ReadJpg(mArray,mNameBuf);
#ifdef PRINT_JPG_READ
printf("Read:%s\n",mNameBuf);
#endif
        oglIm->imageHandle = mArray;
            oglIm->changed = 1;
    }

private:

    void Init(int w, int h, bool doLoop)
    {
        mArray = 0;
        //mFrameNr = 0;
        mOglView = 0;
        mPlaying = 0;
        mDoLoop = doLoop;
        mFitViewToWindow = true;
        mScaleImageToView = true;

        OpenVideo(*mVideo);
    }

    char                    mNameBuf[2048];
    Array2dVec3UInt8*       mArray;

    Visualization::Video*   mVideo;
    OGLVIEW*                mOglView;

    float                   mTimePerFrame;
    clock_t                 mStartTime;
    int                     mStartTimeOffset;
    int                     mFrameNr;
    int                     mFirstFrameNr;
    int                     mLastFrameNr;

    int                     mImW, mImH;
    int                     mPower2W, mPower2H;    

    bool                    mPlaying;
    bool                    mDoLoop;
    bool                    mFitViewToWindow;
    bool                    mScaleImageToView;
};

} // namespace SDash
} // namespace Application
} // namespace Impala

#endif

---