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

---

RgbDataSrc.h

Go to the documentation of this file.

#ifndef Impala_Core_Stream_RgbDataSrc_h
#define Impala_Core_Stream_RgbDataSrc_h

#include <iostream>

#include "Basis/String.h"
#include "Basis/NativeTypes.h"
#include "Core/Array/Arrays.h"
#include "Core/Array/MD5Hash.h"

#include "Core/Stream/DummyFrameProvider.h" 


namespace Impala
{
namespace Core
{
namespace Stream
{


class RgbDataSrc
{

public:

    static const int     LASTFRAME_UNKNOWN = 10000000; // not known (yet)
    static const int     LASTFRAME_INFINITY = -1;      // src is endless :camera
    static const int     UNKNOWN_INT   = -2;
    static const Int64   UNKNOWN_INT64 = -2;
    static const long    UNKNOWN_LONG  = -2;
    // MSVC cannot handle these :-(
    //static const float   UNKNOWN_FLOAT = -2;
    //static const double  UNKNOWN_DOUBLE= -2;

    static const int HASH_SIZE = 32;
    static const String UNKNOWN_FRAME_HASH; // =  "FRAME_HASH_UNKNOWN______________";
    static const String INVALID_FRAME_HASH; // =  "INVALID_FRAME___________________";
    static const String UNSTABLE_FRAME_HASH; // = "UNSTABLE_FRAME__________________";

    RgbDataSrc(int src, CString srcName)
    :   mSrc            (src),
        mSrcName        (srcName),
        mFrameNr        (-1),             // SK: deprecated
        mTargetFrameNr        (-1),
        mCurrentFrameNr        (-1),
        mFrameWidth     (0),
        mFrameHeight    (0),
        mLastFrame      (LASTFRAME_UNKNOWN),
        mData           (0),
        mDataOrig       (0),

        mNewImpl        (false),

        mFormatName     ("Unknown Format"),
        mFormatLName    (""),
        mCodecName      ("Unknown Codec"),

        mGopSize        (UNKNOWN_INT),
        mBitRate        (UNKNOWN_INT),
        mFrameRateNum   (UNKNOWN_INT),
        mFrameRateDen   (UNKNOWN_INT),
        mTimeBaseNum    (UNKNOWN_INT),
        mTimeBaseDen    (UNKNOWN_INT),
        mAspectRatioNum (UNKNOWN_INT),
        mAspectRatioDen (UNKNOWN_INT),
        mStreamCount    (UNKNOWN_INT),
        mBlankFrames    (0),

        mIndexExists(false),
        mIsFrameAccurate(true),

        mStartTime      (UNKNOWN_INT64), // deprecated
        mEndTime        (UNKNOWN_INT64), // deprecated
        mDuration       (UNKNOWN_INT64),
        mDurationSec    (UNKNOWN_INT64),
        mDurationMin    (UNKNOWN_INT64),
        mDurationHour   (UNKNOWN_INT64),
        mVideoDuration  (UNKNOWN_INT64),
        mVideoShiftSec  (UNKNOWN_INT64) // deprecated
    {
    }

    virtual
    ~RgbDataSrc()
    {
    }

    int
    FrameWidth() const
    {
        return mFrameWidth;
    }

    int
    FrameHeight() const
    {
        return mFrameHeight;
    }

    int
    FrameNr() const
    {
        if (mNewImpl)
            return mCurrentFrameNr;
        else
            return mFrameNr;
    }

    String
    CodecName() const
    {
        return mCodecName;
    }

    String 
    FormatName() const
    {
        return mFormatName + " : " + mFormatLName;
    }

    int 
    FrameRateNum() const
    {
        return mFrameRateNum;
    }

    int 
    FrameRateDen() const
    {
        return mFrameRateDen;
    }

    int 
    TimeBaseNum() const
    {
        return mTimeBaseNum;
    }

    int 
    TimeBaseDen() const
    {
        return mTimeBaseDen;
    }

    int 
    GopSize() const
    {
        return mGopSize;
    }

    int 
    AspectRatioNum() const
    {
        return mAspectRatioNum;
    }

    int 
    AspectRatioDen() const
    {
        return mAspectRatioDen;
    }

    float 
    BitRate() const
    {
        return mBitRate;
    }

    //* deprecated; use LeadingBadFrames instead;
    const int 
    BlankFrames() const
    {
        ILOG_WARN("BlankFrames() is deprecated; use LeadingBadFrames() instead");
        return LeadingBadFrames();
    }

    // number of bad frames before the first valid frame
    //(used to be called "blank frames")
    const int
    LeadingBadFrames() const
    {
        return mBlankFrames;
    }

    // total number of bad frames (including leading bad frames)
    virtual const int 
    BadFrames() const
    {
        return LeadingBadFrames();
    }

    int 
    StreamCnt() const
    {
        return mStreamCount;
    }

    virtual bool
    IsFrameAccurate() const
    {
        return mIsFrameAccurate;
    }

    Int64
    GetDurationSec() const
    {
        return mDuration;
    }

    void 
    GetDuration(long& hour,long& minute,long& second,long& fraction) const
    {
        hour     = mDurationHour;
        minute   = mDurationMin;
        second   = mDurationSec;
        fraction = 0;
        return;
    }

    void
    GetTime(long& hour, long& minute, long& second, long& fraction) const
    {
        Frame2Time(FrameNr(), hour, minute, second, fraction);
    }

    int
    GetHour() const
    {
        long hour, minute, second, fraction;
        GetTime(hour, minute, second, fraction);
        return hour;
    }

    int
    GetMinute() const
    {
        long hour, minute, second, fraction;
        GetTime(hour, minute, second, fraction);
        return minute;
    }

    int
    GetSecond() const
    {
        long hour, minute, second, fraction;
        GetTime(hour, minute, second, fraction);
        return second;
    }

    int
    GetFraction() const
    {
        long hour, minute, second, fraction;
        GetTime(hour, minute, second, fraction);
        return fraction;
    }

    int
    LastFrame() const
    {
        return mLastFrame;
    }

    int
    NrOfFrames() const
    {
        return LastFrame() + 1;
    }

    String
    LastFrameAsTime() const
    {
        return FrameAsTimeString(mLastFrame);
    }

    UInt8*
    DataPtr() const
    {
        if (!mNewImpl || FrameValid(FrameNr()))
            return mData;
        else
            return DummyFrameProvider::DataPtr(FrameWidth(), FrameHeight());
    }

    virtual char
    FrameType() const
    {
        return '?';
    }

    virtual bool
    CurIsIFrame() const
    {
        return false;
    }

    virtual bool
    Valid() const = 0;

    virtual bool
    HasIndex() const
    {
        return mIndexExists;
    }

    virtual void
    SetInterval(int /*interval*/)
    {
    }

    bool
    NextFrame(int inc = 1)
    {
        return GotoFrame(FrameNr() + inc);
    }

    bool
    GotoFrame(int target)
    {
        if (target < 0)
            target = 0;
        if (target >= mLastFrame)
            target = mLastFrame;

        if (!mNewImpl)
        {
            mFrameNr = target;          //SK: deprecated
        }
        else
            mTargetFrameNr = target;

         return ReadFrameData();
    }

    virtual bool
    TheEnd() const
    {
        return FrameNr() >= mLastFrame;
    }

    virtual void
    Reset()
    {
        if (!mNewImpl)
        {
            ILOG_INFO("Using deprecated code within Reset()");
            mFrameNr = -1; // for backw.compat.
        }

        mCurrentFrameNr = -1;
    }

    String
    GetName() const
    {
        return mSrcName;
    }

    int
    GetType() const
    {
        return mSrc;
    }

    virtual int
    GetTimeBaseNumerator() const
    {
        return 1;
    }

    virtual int
    GetTimeBaseDenominator() const
    {
        return 25;
    }

    virtual void
    DumpInfo() const
    {
    }

    virtual String 
    FrameHash() const
    {
        if (FrameValid(FrameNr()))
            return CalcHash();
        else
            return INVALID_FRAME_HASH;
    }

    virtual String 
    FrameHashBeforeConversion() const
    {
        return FrameHash();
    }


protected:

    // debug; caller assumes ownership
    UInt8*
    CopyData(UInt8* dP, int numBytes)
    {
        UInt8* theCopy = new UInt8[numBytes];
        for (int i = 0; i < numBytes; i++)
            theCopy[i] = dP[i];
        return theCopy;
    }

    // debug; caller assumes ownership
    void
    MatchData(UInt8* dP, UInt8* dataCopy, int numBytes) const
    {
        for (int i = 0; i < numBytes; i++)
            if (dP[i] != dataCopy[i])
            {
                ILOG_DEBUG("mismatch for i=" << i << " ; stored value=" << (int) dataCopy[i] << " and current value=" << (int) dP[i]);
                break;
            }
    }

    virtual String
    CalcHash() const
    {
        Array::Array2dVec3UInt8* arr =
            new Array::Array2dVec3UInt8(FrameWidth(), FrameHeight(), 0, 0,
                                 DataPtr(), true, false);
        String hash = Array::MD5Hash(arr);
        delete arr;
        return hash;
    }

    // Read data for frame mCurrentFrameNr
    virtual bool
    ReadFrameData() = 0;

    void
    Frame2Time(int frameNr, long& hour, long& minute, long& second,
               long& fraction) const
    {
        long numerator = GetTimeBaseNumerator();
        long denominator = GetTimeBaseDenominator();
        long totalFractions = frameNr * numerator;
        fraction = totalFractions % denominator;
        long totalSeconds = (totalFractions - fraction) / denominator;
        hour = totalSeconds / 3600;
        totalSeconds %= 3600;
        minute = totalSeconds / 60;
        second = totalSeconds % 60;
    }

    String
    FrameAsTimeString(int frameNr) const
    {
        if ((frameNr < 0) || (frameNr >= LASTFRAME_UNKNOWN))
            return "unknown";
        long hour, minute, second, fraction;
        Frame2Time(frameNr, hour, minute, second, fraction);
        return MakeString(hour) + ":" + MakeString(minute, 2, '0')
            + ":" + MakeString(second, 2, '0') + "."
            + MakeString(fraction);
    }

    virtual bool
    FrameValid(int frameNr) const
    {
        if (frameNr < mBlankFrames)
            return false;

        if (frameNr > mLastFrame)
            return false;

        return true;
    }

    void
    SetLeadingBadFrames(const int numberOfFrames)
    {
        mBlankFrames = numberOfFrames;
    }


    bool           mNewImpl; // for distinction between old and new impl

    int            mSrc;
    String         mSrcName;
    int            mFrameNr; //SK: deprecated
    int            mTargetFrameNr;
    int            mCurrentFrameNr;
    int            mFrameWidth;
    int            mFrameHeight;
    int            mLastFrame;
    UInt8*         mData;
    UInt8*         mDataOrig;

    //VideoInfo
    bool   mIndexExists;
    mutable bool mIsFrameAccurate;
    String mFormatName;
    String mFormatLName;
    String mCodecName;
    String mCodecTag;
    int    mFrameRateNum;
    int    mFrameRateDen;
    int    mTimeBaseNum;
    int    mTimeBaseDen;
    int    mAspectRatioNum;
    int    mAspectRatioDen;
    int    mGopSize;
    int    mBitRate;
    int    mStreamCount;
    UInt32 mBlankFrames; // i.e. number of leading bad frames; to be renamed mLeadingBadFrames
    Int64  mStartTime; // deprecated
    Int64  mEndTime;   // deprecated
    Int64  mDuration;
    Int64  mDurationSec;
    Int64  mDurationMin;
    Int64  mDurationHour;
    Int64  mVideoDuration; // duration of video stream in number of fractions
    double mVideoShiftSec; // deprecated

    ILOG_VAR_DECL;

};

const String RgbDataSrc::UNKNOWN_FRAME_HASH = "FRAME_HASH_UNKNOWN______________";
const String RgbDataSrc::INVALID_FRAME_HASH = "INVALID_FRAME___________________";
const String RgbDataSrc::UNSTABLE_FRAME_HASH = "UNSTABLE_FRAME__________________";

ILOG_VAR_INIT(RgbDataSrc, Impala.Core.Stream);

} // namespace Stream
} // namespace Core
} // namespace Impala

#endif

---