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

---

VideoPlayer.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// Author: Richard van Balen
#ifndef Impala_Visualization_VideoPlayer_h
#define Impala_Visualization_VideoPlayer_h

#include <time.h>

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

#ifndef Impala_Core_Stream_RgbDataSrcFactory_h
#include "Core/Stream/RgbDataSrcFactory.h"
#endif

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

//#include "Visualization/ThreadSystemWnd.h"

#ifndef Impala_Visualization_VideoPlayerListener_h
#include "Visualization/VideoPlayerListener.h"
#endif

namespace Impala {
namespace Visualization {

class VideoPlayer : public OglGui::Window
{
public:
    typedef Impala::Core::Stream::RgbDataSrcFactory  RgbDataSrcFactory;
    typedef Impala::Core::Stream::RgbDataSrc         RgbDataSrc;
    typedef Impala::Core::Array::Array2dVec3UInt8    Array2dVec3UInt8;
    typedef OglGui::Window                           Window;

    VideoPlayer(int x, int y, int w, int h,
                strconst videoFileName="", strconst videoType="lavc"):
        Window(x, y, w, h)
    {
        Init(w, h, videoFileName, videoType);
    }

    VideoPlayer(Window* parent, int w, int h,
                strconst videoFileName="", strconst videoType="lavc"):
        Window(parent, w, h)
    {
        Init(w, h, videoFileName, videoType);
    }

    VideoPlayer(Window* parent,int x,int y,int w,int h,
                strconst videoFileName="", strconst videoType="lavc"):
        Window(parent, x, y, w, h)
    {
        Init(w, h, videoFileName, videoType);
    }

    void SetVideoPlayerListener(VideoPlayerListener* listener, void* userData)
    {
        mListener = listener;
        mListenerData = userData;
    }
    void SetVideoPlayerListener(VideoPlayerListener* listener, int userData)
    {
        SetVideoPlayerListener(listener,(void*)userData);
    }


    static RgbDataSrc*
    Construct(String videoName, strconst videoType)
    {
#ifndef REPOSITORY_USED
        RgbDataSrcFactory& factory = RgbDataSrcFactory::Instance();     
        RgbDataSrc* rgbDataSrc = factory.Construct(videoName, videoType);
#else
        Persistency::RgbDataSrcLocator loc("file:", "abs", videoName);
        RgbDataSrcFactory& factory = RgbDataSrcFactory::Instance();
        RgbDataSrc* rgbDataSrc = factory.Construct(loc, videoType);
#endif
        if (!rgbDataSrc || !rgbDataSrc->Valid())
        {
            ILOG_ERROR("Construct Rgb [" << videoName << "] " << "failed");
            if (rgbDataSrc)
                delete rgbDataSrc;
            return 0;
            }
        return rgbDataSrc;
    }

    void OpenVideo(strconst videoFileName, strconst videoType, int lastFrame=-1,
                   int partitionInto=1, int partitionIndex = 0)
    {
        RgbDataSrc* rgbDataSrc = Construct(videoFileName, videoType);
        OpenVideo(rgbDataSrc, lastFrame, partitionInto, partitionIndex);
    }

    void OpenVideo(RgbDataSrc *video, int lastFrame=-1,
                   int partitionInto=1, int partitionIndex = 0)
    {
        if (mOwnRgbDataSrc && mRgbDataSrc)
            delete mRgbDataSrc;

        if ( !(mRgbDataSrc = video))
        {
            viewSys.SetImage(mOglView,0);
            return;
        }

        if (!mRgbDataSrc->Valid())
        {
            ILOG_WARN("OpenVideo stream failed");
            return;
        }

        mRgbDataSrc->Reset();

        if (partitionInto < 1)
            return;
        if (partitionIndex < 0 || partitionIndex >= partitionInto)
            return;

        if (lastFrame < 0)
            lastFrame = mRgbDataSrc->LastFrame();
        if (lastFrame < 0 || lastFrame == RgbDataSrc::LASTFRAME_UNKNOWN)
        {
            mRgbDataSrc->GotoFrame(RgbDataSrc::LASTFRAME_UNKNOWN);
            lastFrame = mRgbDataSrc->LastFrame();
        }
        mStartFrame = (partitionIndex * lastFrame) / partitionInto;
        if (partitionIndex > 0)
            mStartFrame++; // we dont want overlapping frame ranges
        mEndFrame = ((partitionIndex + 1) * lastFrame) / partitionInto;

        ILOG_SYSTEM("OpenVideo: " << partitionIndex+1  << " of " <<
                    partitionInto << ": " << mStartFrame << " -- " <<
                    mEndFrame << " in " << lastFrame << " frames.");

        mRgbDataSrc->GotoFrame(mStartFrame);

        OGLIMAGE* im = OglImageReadFrame(mRgbDataSrc);
        mImW = im->w;
        mImH = im->h;
        IsPower2(mImW, &mPower2W);
        IsPower2(mImH, &mPower2H);
        im->noTexScaling = 1;

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

    int FrameNr()
    {
        if (mRgbDataSrc)
            return mRgbDataSrc->FrameNr();
        return -1;
    }

    int LastFrame()
    {
        if (mRgbDataSrc)
            return mRgbDataSrc->LastFrame();
        return -1;
    }

    void Play()
    {
        if (!mRgbDataSrc)
            return;
        if (mRgbDataSrc->FrameNr() >= mEndFrame)
            Rewind();
        mPlaying = true;
        mIncrement = 1;
        mLastTime = mTimer->SplitTime();
        oglSys.SetAlwaysDraw(mOglWnd, true);
    }

    void Stop()
    {
        mPlaying = false;
        SetAlwaysDraw(false);
        UpdateScene();
    }

    void Reset()
    {
        Stop();
        if (mRgbDataSrc)
        {
            mRgbDataSrc->Reset();
            ReadFrameIntoOglImage(mRgbDataSrc, mOglView->im);
        }
    }

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

    void FBwd()
    {
        if (!mRgbDataSrc)
            return;
/*
        int oldIncr = mIncrement;
        if (mIncrement > 0)
            oldIncr = 0;
        mIncrement = oldIncr-1;
*/
        mIncrement = -1;
        mPlaying = true;
        mNormalSpeed = false;
        mLastTime = mTimer->SplitTime();
        oglSys.SetAlwaysDraw(mOglWnd, true);
    }


    void Rewind()
    {
        GotoFrame(mStartFrame);
    }

    void NextFrame(int inc=1)
    {
        if (!mRgbDataSrc)
            return;
        int fr = mRgbDataSrc->FrameNr() + inc;
        if (inc > 0 && fr >= mEndFrame)
            fr = mLoopVideo ? mStartFrame : mEndFrame;
        if (inc < 0 && fr < mStartFrame)
            fr = mLoopVideo ? mEndFrame : mStartFrame;
        if (fr != mRgbDataSrc->FrameNr())
            GotoFrame(fr);
    }

    void GotoFrame(int frameNr)
    {
        if (!mRgbDataSrc)
            return;
        mRgbDataSrc->GotoFrame(frameNr);
        ReadFrameIntoOglImage(mRgbDataSrc,mOglView->im,0);
    }

    bool Playing()      { return mPlaying; }
    bool FFwding()      { return mPlaying&&  !mNormalSpeed && mIncrement > 0; }
    bool FBwding()      { return mPlaying && !mNormalSpeed && mIncrement < 0; }
    OGLVIEW* OglView()  { return mOglView; }

    bool GetLoopVideo()                 { return mLoopVideo; }
    void SetLoopVideo(bool value)       { mLoopVideo = value; }
    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 OwnRgbDataSrc(bool mode)       { mOwnRgbDataSrc = mode; }
    RgbDataSrc* DataSrc()               { return mRgbDataSrc; }
    void ShowFrameNr(bool mode)         { mShowFrameNr = mode; }
    bool ShowFrameNr()                  { return mShowFrameNr; }

    void MoveToFrame(int frameNr)
    {
        if (mPlaying)
            GotoFrame(frameNr);
        else {
            mMoveToFrameTarget = frameNr;
            oglSys.SetAlwaysDraw(mOglWnd,1);
        }
    }

    int GetMoveToFrame()
    {
        return mMoveToFrameTarget;
    }

    void StopMoveToFrame()
    {
        mMoveToFrameTarget = -1;
        oglSys.SetAlwaysDraw(mOglWnd,0);
    }

    void HandleMoveToFrame()
    {
        if (mMoveToFrameTarget == -1)
            return;
        if (!mRgbDataSrc || !mOglView || mPlaying)
        {
            mMoveToFrameTarget = -1;
            return;
        }
        int frameNr = FrameNr();
        if (frameNr == -1 || frameNr == mMoveToFrameTarget)
            StopMoveToFrame();
        else {
            int dir = (mMoveToFrameTarget < frameNr) ? -1 : 1;
            int inc = (mMoveToFrameTarget - frameNr) / 4;
            if (abs(inc)<6) inc = dir;   
            GotoFrame(frameNr+inc);
        }
    }

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

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

    virtual void DisplayFunc()
    {

//SK
try
{
        double  cpuTime = mTimer->SplitTime();
        if (mRgbDataSrc && mPlaying && mOglView) 
        {
            if (!mNormalSpeed || cpuTime-mLastTime >= 0.04)
            {
                mLastTime = cpuTime + (0.04-(cpuTime-mLastTime));
                        ReadFrameIntoOglImage(mRgbDataSrc, mOglView->im,mIncrement);
            }
        }
        else if (mMoveToFrameTarget != -1)
            HandleMoveToFrame();
        Window::DisplayFunc();
        if (mRgbDataSrc && mShowFrameNr)
            oglSys.ShadowPrintf(mOglWnd,8,8,oglLIGHTGREY,oglBLACK,"%d",
                                mRgbDataSrc->FrameNr());
        if (mRgbDataSrc && mNewFrame && mListener)
            mListener->OnNewFrame(this, mRgbDataSrc->FrameNr(), mListenerData);
        mNewFrame = false;
}
catch (std::exception e)
{
    ILOG_ERROR("Video playback failure");
}
//SK

    }

    virtual void KeyboardFunc(int c, int state)
    {
        if (c == 'P')
        {
            char sysBuf[1024];
            sprintf(sysBuf, "mplayer -ss %d:%d:%d %s",
                    mRgbDataSrc->GetHour(), mRgbDataSrc->GetMinute(),
                    mRgbDataSrc->GetSecond(), mRgbDataSrc->GetName().c_str());
            ILOG_INFO("sysbuf = [" << sysBuf << "]");
            int sysRes = system(sysBuf);
            if (sysRes != 0)
            {
                ILOG_ERROR("system ["  << sysBuf << "]");
                return;
            }
        }
        if (c == 'p')
            Play();
        if (c == 's')
            Stop();
        if (c == oglHOME)
            Reset();
        if (c == '+')
            NextFrame(1);
        if (c == '-')
            NextFrame(-1);
        if (c == '<')
            NextFrame(-10);
        if (c == '>')
            NextFrame(10);
        if (c == 'S')
            mScaleImageToView = !mScaleImageToView;
        if (c == 'F')
            mFitViewToWindow = !mFitViewToWindow;
        if (c=='f') FFwd();
        if (c=='b') FBwd();
        Window::KeyboardFunc(c, state);
        if (mListener)
            mListener->OnKey(this, c, state, mListenerData);
    }

    // SK experimental
    int LastFrameNr()
    {
        if (mRgbDataSrc == 0)
            return -1;
        int lastFrame = mRgbDataSrc->LastFrame();
        if (lastFrame == RgbDataSrc::LASTFRAME_UNKNOWN)
            return -1;
        return lastFrame;
    }

protected:
    static void* OglImdataFunc(OGLIMAGE* oglIm)
    {
            // Obtain our 'im' stored as 'imageHandle'
        Array2dVec3UInt8* ar = (Array2dVec3UInt8 *) oglIm->imageHandle;

        // Set oglIm dimensions to our 'im' dimensions
            oglIm->w = ar->CW();
            oglIm->h = ar->CH();
        // RvB: Saver to do this after texture loading rather than here
            //oglIm->changed = 0;

            return (void *) ar->CPB(0, 0); // Pointer to the image pixels
    }

    static void OglImdataDestroyFunc(OGLIMAGE* oglIm)
    {
            if (!oglIm) return;

            Array2dVec3UInt8* ar = (Array2dVec3UInt8 *) oglIm->imageHandle;

            if (ar) delete ar;
    }

    OGLIMAGE* OglImageReadFrame(RgbDataSrc* src)
    {
            int imW = src->FrameWidth();
            int imH = src->FrameHeight();

            Array2dVec3UInt8* ar =
                new Array2dVec3UInt8(imW, imH, 0, 0, 0, false);

            OGLIMAGE* oglIm = oglSys.OglImage(GL_RGB, imW, imH);
            oglIm->imDataFunc = OglImdataFunc;
        oglIm->onDestroy = OglImdataDestroyFunc;
            oglIm->imageHandle = ar;
        ReadFrameIntoOglImage(src,oglIm,0);
            return oglIm;
    }

    void ReadFrameIntoOglImage(RgbDataSrc* src, OGLIMAGE *oglIm, int incr=1)
    {
        if (!src || !oglIm )
            return;

        int targetFrame = src->FrameNr() + incr;
        if (targetFrame < mStartFrame || targetFrame > mEndFrame)
        {
            if (mLoopVideo)
                targetFrame = targetFrame > mEndFrame ? mStartFrame : mEndFrame;
            else
            {
                Stop();
                return;
            }
        }
        if (targetFrame != src->FrameNr())
            src->GotoFrame(targetFrame);

            int imW = src->FrameWidth();
            int imH = src->FrameHeight();
            Array2dVec3UInt8* ar = (Array2dVec3UInt8 *) oglIm->imageHandle;
            memcpy( (void *) ar->CPB(0, 0), src->DataPtr(), imW*imH*3 );
            oglIm->changed = 1;
        mNewFrame = true;
    }
/*
    void ReadFrameIntoOglImage(RgbDataSrc* src, OGLIMAGE *oglIm, int incr=1)
    {
        if (!src || !oglIm )
            return;

        int targetFrame = src->FrameNr() + incr;
        if (targetFrame < mStartFrame)
            targetFrame = mStartFrame;
        else if (targetFrame > mEndFrame)
        {
            if (mLoopVideo)
                targetFrame = mStartFrame;
            else {
                Stop();
                return;
            }
        }
        if (targetFrame != src->FrameNr())
            src->GotoFrame(targetFrame);

            int imW = src->FrameWidth();
            int imH = src->FrameHeight();
            Array2dVec3UInt8* ar = (Array2dVec3UInt8 *) oglIm->imageHandle;
            memcpy( (void *) ar->CPB(0, 0), src->DataPtr(), imW*imH*3 );
            oglIm->changed = 1;
        mNewFrame = true;
    }
*/
private:

    void Init(int w, int h, strconst videoFileName, strconst videoType)
    {
        GuiGeneralName("VideoPlayer");
        GuiName("VideoPlayer");
        mRgbDataSrc = 0;

        mListener = 0;

        mOwnRgbDataSrc = true;
        mNewFrame = false;
        mIncrement = 1;
        mMoveToFrameTarget = -1;
        mOglView = 0;
        mPlaying = 0;
        mLastTime = 0;
        mNormalSpeed = true;
        mFitViewToWindow = true;
        mScaleImageToView = true;
        mLoopVideo = false;
        mShowFrameNr = false;
        mStartFrame = 0; // SK
        mEndFrame = 0; // SK

        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.ClearTags(mOglView, deletableTag|showBorderTag);

        if (!(videoFileName == ""))
            OpenVideo(videoFileName, videoType);
        mTimer = new Timer(1);
    }

    VideoPlayerListener*    mListener;
    void*                   mListenerData;

    RgbDataSrc*     mRgbDataSrc;
    bool            mOwnRgbDataSrc;
    OGLVIEW*        mOglView;

    double          mLastTime;
    bool            mNewFrame;
    bool            mLoopVideo;

    int             mIncrement;

    int             mMoveToFrameTarget;

    int             mImW, mImH;
    int             mPower2W, mPower2H;    

    bool            mPlaying;
    bool            mNormalSpeed;
    bool            mFitViewToWindow;
    bool            mScaleImageToView;
    bool            mShowFrameNr;

    int             mStartFrame; // SK
    int             mEndFrame;   // SK

    Timer*          mTimer;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(VideoPlayer, Visualization);

} // namespace Visualization
} // namespace Impala

#endif

---