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

---

VideoJpgPlayer.h

Go to the documentation of this file.

 /*
12345678901234567890123456789012345678901234567890123456789012345678901234567890
*/
// RvB: Note adjusted by SK for sdash.
// In future this file should be moved to impala::application::sdash
// and the original file should be restored.
//
// SK: What part of this file is sdash specific? I ment to help improve structure
// in introducing the sdash independent class Video, which would then be used to
// isolate knowledge on specific jpg based video datasets, like length in frames, first/last frame
// nr used, frame rate, etc. This way class VideoJpgPlayer will be more focused on 
// how to play video's based on seperate jpg's, hence its name.

#ifndef Impala_Visualization_VideoJpgPlayer_h
#define Impala_Visualization_VideoJpgPlayer_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

#ifndef Impala_Visualisation_VideoJpgPlayerListener_h
#include "Visualization/VideoJpgPlayerListener.h"
#endif

#include "Visualization/Video.h"


namespace Impala
{
namespace Visualization
{

class VideoJpgPlayer : public OglGui::Window
{
public:

    typedef Impala::Core::Array::Array2dVec3UInt8    Array2dVec3UInt8;
    typedef OglGui::Window                           Window;

    VideoJpgPlayer(int x, int y, int w, int h, Video& video):
        Window(x, y, w, h), mVideo(&video)
    {
        Init(w,h);
    }

    VideoJpgPlayer(Window* parent, int w, int h, Video& video):
        Window(parent, w, h), mVideo(&video)
    {
        Init(w,h);
    }

    VideoJpgPlayer(Window* parent,int x,int y,int w,int h, Video& video):
        Window(parent, x, y, w, h), mVideo(&video)
    {
        Init(w,h);
    }

    void SetVideoJpgPlayerListener(VideoJpgPlayerListener* listener,
                                   void* userData)
    {
        mListener = listener;
        mListenerData = userData;
    }

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

    void OpenVideo(Video& video)
    {
        mVideo = &video;

        if (mOglView)
            viewSys.SetImage(mOglView,0);
        mArray = 0;

        mTimePerFrame = mVideo->GetTimePerFrame();
        mFirstFrameNr = mVideo->GetNrOfFirstFrame();
        mLastFrameNr = mShowMaxFrameNr = mVideo->GetNrOfLastFrame();
        mFrameNr = mFirstFrameNr;
        mIncrement = 1;
        mNewFrame = false;
        mLastReadFrameNr = -999999;

        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.SetTexturing(mOglView, true);
            viewSys.SetTags(mOglView, FlexViewTags & ~deletableTag);
            viewSys.SetTags(mOglView, selectedTag);
        }

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

    void SetShowMaxFrame(int frameNr)      { mShowMaxFrameNr = frameNr;}
    void SetFirstFrame(int frameNr)        { mFirstFrameNr = frameNr; } // SK: is now taken from mVideo
    void SetLastFrame(int frameNr)         { mLastFrameNr = frameNr; } // SK: is now taken from mVideo

    float GetTimePast(int frameNr)
    {
        return (float) (frameNr - mFirstFrameNr) * mTimePerFrame;
    }

    float GetTimePast()
    {
        return GetTimePast(mFrameNr);
    }

    void Play()
    {
        mPlaying = true;
        mNormalSpeed = true;
        mIncrement = 1;
        oglSys.SetAlwaysDraw(mOglWnd, true);
    }

    void Stop()
    {
        mPlaying = false;
        oglSys.SetAlwaysDraw(mOglWnd, false);
    }

    void Reset()
    {
        Stop();
        GoToFrame(mFirstFrameNr);
    }

    void FFwd()
    {
        Play();
        mIncrement = 1;
        mNormalSpeed = false;
    }

    void FBwd()
    {
        Play();
        mIncrement = -1;
        mNormalSpeed = false;
    }

    void NextFrame(int inc=1)
    {
        GoToFrame(mFrameNr+inc);
    }

    void GoToFrame(int frameNr)
    {
        mFrameNr = frameNr;
        if (mFrameNr < mFirstFrameNr)
            mFrameNr = mFirstFrameNr;
        if (mFrameNr > mShowMaxFrameNr)
            mFrameNr = mShowMaxFrameNr;
        if (mFrameNr > mLastFrameNr)
        {
            mFrameNr = mLastFrameNr;
            if (mLooping)
                Reset();
        }
        if (mLastReadFrameNr != mFrameNr)
            ReadFrameIntoOglImage(mOglView->im );
    }

    bool Playing()
    {
        return mPlaying;
    }

    bool FFwding()
    {
        return mPlaying && !mNormalSpeed && mIncrement > 0;
    }
    bool FBwding()
    {
        return mPlaying && !mNormalSpeed && mIncrement < 0;
    }

    OGLVIEW* OglView()
    {
        return mOglView;
    }

    void FitViewToWindow(bool mode)     { mFitViewToWindow = mode; }
    bool FitViewToWindow()              { return mFitViewToWindow; }
    void ScaleImageToView(bool mode)    { mScaleImageToView = mode; }
    bool ScaleImageToView()             { return mScaleImageToView; }
    void NormalSpeed(bool mode)         { mNormalSpeed = mode; }
    void SetIncrement(int incr)         { mIncrement = incr; }

    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()
    {
        double  cpuTime = OglClock();

            if (mPlaying && mOglView){
            if (!mNormalSpeed || (cpuTime-mLastTime) > mTimePerFrame)
            {
                mLastTime = cpuTime;
                NextFrame(mIncrement);
            }
        }
        Window::DisplayFunc();
        if (mNewFrame && mListener)
            mListener->OnNewFrame(this, mFrameNr, mListenerData);
        mNewFrame = false;
    }

    virtual void MouseFunc(int msg, int btn, int state, int x, int y)
    {
        if (msg == oglMouseWheelDown)
            NextFrame();
        if (msg == oglMouseWheelUp)
            NextFrame(-1);
        Window::MouseFunc(msg,btn,state,x,y);
    }

    virtual void KeyboardFunc(int c, int state)
    {
        if (!mNoKeyboardCommands)
        {
            if (c == 'p')
                Play();
            if (c == 's')
                Stop();
            if (c == oglHOME)
                Reset();
            if (c == 'n')
                mNormalSpeed = !mNormalSpeed;
            if (c == '+')
                NextFrame(1);
            if (c == '-')
                NextFrame(-1);
            if (c == 'S')
                mScaleImageToView = !mScaleImageToView;
            if (c == 'F')
                mFitViewToWindow = !mFitViewToWindow;
        }
        Window::KeyboardFunc(c, state);
        if (mListener)
            mListener->OnKey(this, c, state, mListenerData);
    }

    OGLIMAGE* OglImageReadFirstFrame()
    {
        mFrameNr = mFirstFrameNr;
        mVideo->GetFramePathAnnotated(mFirstFrameNr, mNameBuf);
        ReadJpg(mArray,mNameBuf);
        mNewFrame = true;

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

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


private:

    void ReadFrameIntoOglImage(OGLIMAGE *oglIm)
    {
        if (mFrameNr > mLastFrameNr)
            mFrameNr = mLastFrameNr;
        if (mFrameNr < mFirstFrameNr)
            mFrameNr = mFirstFrameNr;
        if (mArray)
            delete mArray;
        mArray = 0;
        mVideo->GetFramePathAnnotated(mFrameNr, mNameBuf);
        ReadJpg(mArray,mNameBuf);
        mLastReadFrameNr = mFrameNr;
        oglIm->imageHandle = mArray;
            oglIm->changed = 1;
        mNewFrame = true;
    }

    void Init(int w, int h)
    {
        mArray = 0;

        mListener = 0;

        mOglView = 0;
        mNoKeyboardCommands = false;
        mLooping = false;
        mPlaying = 0;
        mLastTime = 0;
        mNormalSpeed = true;
        mFitViewToWindow = true;
        mScaleImageToView = true;

        OpenVideo(*mVideo);
    }

    VideoJpgPlayerListener* mListener;
    void*                   mListenerData;

    char                    mNameBuf[2048];
    Array2dVec3UInt8*       mArray;

    Video*                  mVideo;
    OGLVIEW*                mOglView;

    float                   mTimePerFrame;
    double                  mLastTime;
    bool                    mNewFrame;

    int                     mLastReadFrameNr;
    int                     mFirstFrameNr;
    int                     mLastFrameNr;
    int                     mShowMaxFrameNr;
    int                     mFrameNr;

    int                     mIncrement;

    int                     mImW, mImH;
    int                     mPower2W, mPower2H;    

    bool                    mLooping;
    bool                    mNoKeyboardCommands;
    bool                    mPlaying;
    bool                    mNormalSpeed;
    bool                    mFitViewToWindow;
    bool                    mScaleImageToView;
};

} // namespace Visualization
} // namespace Impala

#endif

---