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

---

RgbDataSrcLavc.h

Go to the documentation of this file.

#ifndef Impala_Core_Stream_RgbDataSrcLavc_h
#define Impala_Core_Stream_RgbDataSrcLavc_h

#include "Basis/CmdOptions.h"
#include "Util/Database.h"

#include "Core/Stream/RgbDataSrcInfo.h"

#include "Core/Stream/LavcProtocolDataServer.h"

#include "Core/Stream/Lavc/VideoAccessStrategyFactory.h"
#include "Core/Stream/Lavc/VideoAccessStrategy.h"
#include "Core/Stream/Lavc/VideoIndex.h"

namespace Impala
{
namespace Core
{
namespace Stream
{

class RgbDataSrcLavc : public RgbDataSrcInfo
{

    typedef Array::Array2dVec3UInt8 Array2dVec3UInt8;

public:

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    RgbDataSrcLavc(int src, CString srcName, Util::Database* db, 
        IndexMode mode)
        : RgbDataSrcInfo(src, srcName, db, 
            DetermineInfoName(srcName, mode, db), true)
    {
#else // REPOSITORY_USED
    RgbDataSrcLavc(int src, const Persistency::RgbDataSrcLocator& loc, 
                   IndexMode mode)
        : RgbDataSrcInfo(src, loc, "", true)
    {
        mLoc = loc;
        String srcName = loc.GetName();
#endif // REPOSITORY_USED
        mSrcName = StringReplaceAll(srcName, "\\", "/", false);
        mMode = mode;

        mValid = false;
        mBufferedFrameNr = -1;
        mLastDecodedFrameNr = -1;

        mFixCnt = 0;
        mLastFixNr = 0;

        mVideoAccessor = 0;

        Init();
    }

    virtual
    ~RgbDataSrcLavc() 
    {
        if (mVideoAccessor != 0)
            delete mVideoAccessor;
    }
    
    virtual char
    FrameType() const
    {
        return mVideoAccessor->FrameType();
    }

    virtual bool
    CurIsIFrame() const
    {
        return FrameType() == 'I';
    }

    virtual bool
    Valid() const
    {
        return mValid; 
    }
    

private:

    bool
    IncurExtraLavcInitialization()
    {
        Reset();
        const int firstValidFrame = LeadingBadFrames();
        if (!SeekFrame(firstValidFrame))
            return false;
        mLastDecodedFrameNr = mBufferedFrameNr = mCurrentFrameNr = firstValidFrame;
        return true;
    }

    bool
    ReadIndex(bool silent)
    {
        const int currentFrameCount = mLastFrame + 1;
        const int currentBadFramesCount = BadFrames();
        const int currentLeadingBadCount = LeadingBadFrames();
        const bool wasRead = ReadInfo(silent);

        //if (wasRead)
        //{
        //    // do some sanity checks:
        //    if (mLastFrame != currentFrameCount - 1)
        //    {
        //        ILOG_ERROR("Number of frames according to info file (" << 
        //            (mLastFrame + 1) << ") does not match previously " <<
        //            " established value (" << currentFrameCount << ")");
        //        return false;
        //    }
        //    if (BadFrames() != currentBadFramesCount)
        //    {
        //        ILOG_ERROR("Number of bad frames according to " <<
        //            "info file (" << LeadingBadFrames() << ") does not match " <<
        //            "previously established value (" << 
        //            currentBadFramesCount << ")")
        //        return false;
        //    }
        //    if (LeadingBadFrames() != currentLeadingBadCount)
        //    {
        //        ILOG_ERROR("Number of leading bad frames according to " <<
        //            "info file (" << LeadingBadFrames() << ") does not match " <<
        //            "previously established value (" << 
        //            currentLeadingBadCount << ")")
        //        return false;
        //    }
        //}
        return wasRead;
    }

    bool
    SeekFrame(int seekableFrame)
    {
        const UInt64 targetPos = GetPos(seekableFrame);
        ILOG_DEBUG("Seeking frame " << seekableFrame << " at position " << 
            targetPos);
        if (!mVideoAccessor->JumpToFramePosition(targetPos))
        {
            ILOG_ERROR("Jump to frame position "  << targetPos << " failed");
            return false;
        }
        return true;
    }

    void
    Init()
    {
        CmdOptions& options = CmdOptions::GetInstance();
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        String dataServer = options.GetString("dataServer");
#else // REPOSITORY_USED
        String dataServer = (mLoc.GetProtocol() == "dataServer") ? "dataserver"
                                                                 : "";
#endif // REPOSITORY_USED
        const String dataSrcAddress =
            dataServer.empty() ? mSrcName : "dataserver:" + mSrcName;
        Lavc::VideoAccessStrategyFactory factory;
        mVideoAccessor = factory.Construct(dataSrcAddress);
        if (mVideoAccessor == 0)
        {
            mValid = false;
            return;
        }

        if (mVideoAccessor->NrOfFrames() >= 0)
            mLastFrame = mVideoAccessor->NrOfFrames() - 1;

        InitStaticMetadata(*mVideoAccessor);

        mData = mVideoAccessor->RgbDataPtr();

        if (mMode == SCANONLY)
        {
            if (!Scan(*mVideoAccessor))
                return;
        }
        else if (mMode == READIDX)
        {
            int nrOfFramesNow = -1;
            bool checkFrameCount = options.GetBool("checkstoredframecount", false);
            if (checkFrameCount)
            {
                if (!Scan(*mVideoAccessor))
                    return;
                nrOfFramesNow = mVideoAccessor->NrOfFrames();
            }

            if (ReadIndex(false))
            {
                if (!IncurExtraLavcInitialization())
                    return;
                if (checkFrameCount && (nrOfFramesNow != (LastFrame() + 1)))
                {
                    ILOG_ERROR("Freshly established frame count (" << 
                        nrOfFramesNow << ") different " <<
                        "from stored frame count (" << LastFrame() + 1 << 
                        ") for: " << mSrcName);
                    return;
                }
            }
            else
            {
                ILOG_ERROR("Failed while reading index info for: " << 
                    mSrcName);
                return;
            }
        }
        else if (mMode == WITHIDX)
        {
            if (ReadIndex(true))
            {
                if (!IncurExtraLavcInitialization())
                    return;
            }
            else
            {
                if (!PopulateIndex(*mVideoAccessor))
                    return;
            }
        }
        else if (mMode == ADHOCIDX)
        {
            if (!PopulateIndex(*mVideoAccessor))
                return;
        }
        else if (mMode == WRITEIDX)
        {
            if (!PopulateIndex(*mVideoAccessor))
                return;
            WriteInfo();
        }

        Reset();
        mValid = true;
        ILOG_DEBUG("Initialization succeeded");
    }


    void 
        InitStaticMetadata(const Lavc::VideoAccessStrategy& videoAccessStrategy)
    {
        // local scope VAO class usage in order to isolate knowledge
        // of this class; using access strategy (sub-) classes is preferred
        const Lavc::VideoAccessObject* const vao = 
            videoAccessStrategy.VideoAccessObj();

        // collect format info
        mBitRate = vao->BitRate();
        mFormatName = vao->FormatNameShort();
        mFormatLName = vao->FormatNameLong();
        ILOG_INFO("Format name is: " << mFormatLName << " (" << 
            mFormatName << ")");

        // collect stream info
        mStreamCount = vao->StreamCount();
        mVideoDuration = vao->VideoDuration();
        mTimeBaseNum = vao->VideoTimeBaseNumerator();
        mTimeBaseDen = vao->VideoTimeBaseDenominator();
        mDuration = ceil(
            double(mVideoDuration) * mTimeBaseNum / mTimeBaseDen
            ); // rounded up (number of seconds)
        mDurationSec = mDuration;
        mDurationHour = mDurationSec / 3600;
        mDurationSec %= 3600;
        mDurationMin = mDurationSec / 60;
        mDurationSec %= 60;

        // collect frame info
        mFrameRateNum = vao->FrameRateNumerator();
        mFrameRateDen = vao->FrameRateDenominator();
        const double fractionsPerSec = double(mTimeBaseDen) / mTimeBaseNum;
        const double secondsPerFrame = double(mFrameRateDen) / mFrameRateNum;
        const double fractionsPerFrame = fractionsPerSec * secondsPerFrame;
        const double frameCount = mVideoDuration / fractionsPerFrame;
        mFrameCountCalculated = ceil(frameCount);
        ILOG_INFO("Frame count estimate based on video duration: " << 
            mFrameCountCalculated);

        mFrameWidth = vao->FrameWidth();
        mFrameHeight = vao->FrameHeight();
        mAspectRatioNum = vao->AspectRatioNum();
        mAspectRatioDen = vao->AspectRatioDen();

        mGopSize = vao->GopSize();

        mCodecTag = vao->VideoCodecTag();
        mCodecName = vao->VideoCodecName();

        ILOG_INFO("Opened codec (id=" << vao->VideoCodecId() << 
            ", name=" << mCodecName << ") for: " << mSrcName);
    }

    void 
    Reset()
    {
        mVideoAccessor->ResetVideoSrc();
        mLastDecodedFrameNr = mBufferedFrameNr = mCurrentFrameNr = -1;
    }

    bool PopulateIndex(Lavc::VideoAccessStrategy& accessStrategy)
    {
        if (!Scan(accessStrategy))
            return false;

        ILOG_INFO("Starting index population...");
        ILOG_INFO("Constructing intermediate index...");
        Lavc::VideoIndex* tempIndex = accessStrategy.ConstructIndex();
        if (!tempIndex)
        {
            ILOG_ERROR("Construction of intermediate index failed; " <<
                "aborting video population");
            return false;
        }

        // copy data from temp index to local index
        const int nrOfFrames = accessStrategy.NrOfFrames();
        String frameHash;
        int seekableFrameNr;
        UInt64 seekableFramePos = 0;
        for (int f = 0; f < nrOfFrames; f++)
        {
            if (accessStrategy.FrameIsValid(f))
            {
                frameHash = accessStrategy.FrameHash(f);
                tempIndex->GetSeekInfo(f, &seekableFrameNr, &seekableFramePos);
            }
            else
            {
                MarkBadFrame(f);
                frameHash = DUMMY_FRAME_HASH;
                seekableFrameNr = -1;
                seekableFramePos = -1;
            }

            ILOG_DEBUG("Adding to index: " << f << ", " << seekableFrameNr << 
                ", " << seekableFramePos << ", " << frameHash);
            AddIndex(f, seekableFrameNr, seekableFramePos, frameHash);
        }

        delete tempIndex;
        accessStrategy.CleanUp();
        mIndexExists = true;
        ILOG_INFO("Finished index population");
        return true;
    }

    bool
    Scan(Lavc::VideoAccessStrategy& accessStrategy)
    {
        if (!accessStrategy.Scan())
        {
            ILOG_ERROR("Failed while scanning: " << mSrcName);
            return false;
        }

        const int frameCnt = accessStrategy.NrOfFrames();
        mLastFrame = frameCnt - 1;  // may yet change when using native index??
        for (int f = 0; f < frameCnt; f++)
            if (!accessStrategy.FrameIsValid(f))
                MarkBadFrame(f);
        SetLeadingBadFrames(accessStrategy.LeadingBadFrames());
        return true;
    }

    virtual bool
    ReadFrameData()
    {
        if (mTargetFrameNr == mCurrentFrameNr)
            return true;

        if (!FrameValid(mTargetFrameNr) || mTargetFrameNr == mBufferedFrameNr)
        {
            mCurrentFrameNr = mTargetFrameNr;
            return true;
        }

        if (mTargetFrameNr < mBufferedFrameNr)
            Reset();

        const bool videoSeekable = mIndexExists;
        if (videoSeekable)
        {
            int sFrameNr = GetSeekableFrame(mTargetFrameNr);
            // dont jump just to read the next frame:
            if (sFrameNr > mBufferedFrameNr + 1)
            {
                ILOG_DEBUG("Targeting frame " << mTargetFrameNr << 
                    " by first seeking to frame " << sFrameNr);
                if (!SeekFrame(sFrameNr))
                    return false;
                mLastDecodedFrameNr = mBufferedFrameNr = mCurrentFrameNr = 
                    sFrameNr;
            }
        }

        const bool lastDecodedFrameValid = ReadToTarget();
        mCurrentFrameNr = mLastDecodedFrameNr;
        if (lastDecodedFrameValid)
        {
            int result = mVideoAccessor->CurrentFrameToRgb();
            mBufferedFrameNr = mCurrentFrameNr;

            if (mFormatName != "asf") // SK: dirty debug fix
                if (!CheckMD5Hash(mBufferedFrameNr))
                {
                    ILOG_ERROR("Frame hash failure going to frame " << 
                        mTargetFrameNr);
                    return false;
                }
        }

        return true;
    }

    // Read and decode frames until we reach the target frame
    bool
    ReadToTarget()
    {
        bool lastDecodedFrameIsValid = true;
        while (mLastDecodedFrameNr < mTargetFrameNr)
        {
            const int nextFrameNr = mLastDecodedFrameNr + 1;

                        if (mVideoAccessor->FrameCanBeRead(nextFrameNr))
                        {
                bool foundValidFrame;
                bool isKeyFrame; // not actually used
                const int decodingResult = mVideoAccessor->
                    DecodeNextFrame(&foundValidFrame, &isKeyFrame, 0);
                const bool gotFrame = (decodingResult == 0);
                if (!gotFrame)
                {
                    // may occur at eof if the video was not scanned in advance
                    if (mLastFrame == LASTFRAME_UNKNOWN)
                    {
                        mLastFrame = mLastDecodedFrameNr; 
                        ILOG_DEBUG("Assuming we arrived at eof; " <<
                            "frame count established is: " << mLastFrame + 1);
                    }
                    return false;
                }
                        
                lastDecodedFrameIsValid = FrameValid(nextFrameNr);
                if (lastDecodedFrameIsValid && !foundValidFrame)
                {
                    // may occur for bad frames if the video was not scanned in advance
                    MarkBadFrame(nextFrameNr);
                    lastDecodedFrameIsValid = false;
                }
                else if (!lastDecodedFrameIsValid && foundValidFrame)
                {
                    ILOG_WARN("Did not expect to read a valid frame for " << 
                        nextFrameNr);
                }
                        }
            else
            {
                if (FrameValid(nextFrameNr))
                {
                    // may occur when the video was not scanned in advance
                    MarkBadFrame(nextFrameNr);
                }
                lastDecodedFrameIsValid = false;
            }

            mLastDecodedFrameNr = nextFrameNr;
        }
        return lastDecodedFrameIsValid;
    }

    bool
    CheckMD5Hash(int frameNr) const
    {
        if (!mIndexExists)
            return true;

        if (!FrameIsStable(frameNr))
            return true;

        const String refHash = GetHash(frameNr);
        const String hash = CalcHash_protected();
        mIsFrameAccurate = (hash == refHash);
        if (mIsFrameAccurate)
        {
            //ILOG_DEBUG("Hash match for frame " << frameNr << ": " << refHash);
            return true;
        }

        ILOG_ERROR("No hash match for frame " << frameNr << "; expected " <<
            refHash << " but found " << hash);
        return false;
    }

    bool
    FrameIsStable(int frameNr) const
    {
        return GetHash(frameNr) != mVideoAccessor->UNSTABLE_FRAME_HASH;
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    String 
    DetermineInfoName(CString srcName, IndexMode mode, Util::Database* db) const
    {
        String infoName = "";
        if (Link::DiskImage::DiskImageUsed())
        {
            String subPath = FileNamePath(srcName);
            if (subPath.substr(0, 10) == "diskimage:")
            {
                int posAfterDiskImageFileName = subPath.find("://", 10);
                // SK: assume disk image file name is unique, 
                // not needing an additional (sub-)path specification
                const String uptoDiskImageToken = 
                    subPath.substr(0, posAfterDiskImageFileName);
                int diskImageFileNamePos = 
                    FileNameLastPathSepPos(uptoDiskImageToken) + 1;
                if (diskImageFileNamePos == String::npos)
                    ILOG_ERROR("Disk image file was expected to be prefixed "
                    << "with a path: " << uptoDiskImageToken);

                String subSubPath = 
                        subPath.substr(posAfterDiskImageFileName + 1);
                subSubPath = StringReplaceAll(subSubPath,
                                                     "0x", "0x30x", false);
                subSubPath = StringReplaceAll(subSubPath, 
                                                     "//", "/0x2F", false);
                subSubPath = subSubPath.substr(0, subSubPath.size() - 1);
                subPath = subPath.substr(diskImageFileNamePos, 
                    posAfterDiskImageFileName-diskImageFileNamePos)+subSubPath;

                String dir = "FramePosIndex/" + subPath;

                bool toWrite = (mode == WRITEIDX);
                bool silent = (mode != READIDX);

                if (toWrite)
                    db->MakeDir(dir);

                String fname = FileNameTail(srcName) + ".info";
                infoName = db->GetFilePath(dir, fname, toWrite, silent);
            }
            else
                infoName = srcName + ".info";
        }
        return infoName;
    }
#endif // REPOSITORY_USED

    Lavc::VideoAccessStrategy* mVideoAccessor;
    Persistency::RgbDataSrcLocator mLoc;

    int                mBufferedFrameNr; // as RGB frame 
    int                mLastDecodedFrameNr;
    bool               mValid;
    uint32_t           mFrameCountCalculated; // based on mDuration
    IndexMode          mMode;

    int                mLastFixNr;
    int                mFixCnt;

    ILOG_VAR_DECL;

}; //class

ILOG_VAR_INIT(RgbDataSrcLavc, Impala.Core.Stream);

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

#endif

---