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

---

VideoAccessStrategy.h

Go to the documentation of this file.

#ifndef Impala_Core_Stream_Lavc_VideoAccessStrategy_h
#define Impala_Core_Stream_Lavc_VideoAccessStrategy_h

#include "Core/Table/TableTem.h"
#include "Core/Stream/Lavc/VideoAccessObject.h"
#include "Core/Stream/Lavc/VideoIndex.h"

#include "Util/IOBufferFile.h"
#include "Core/Table/Write.h"

namespace Impala
{
namespace Core
{
namespace Stream
{
namespace Lavc
{

class VideoAccessStrategy
{

protected:

    // packet idx nr | size | flags | file position after read 
    typedef Table::TableTem< Column::ColumnTem<Int32>,
                             Column::ColumnTem<Int32>,
                             Column::ColumnTem<Int32>,
                             Column::ColumnTem<UInt64> > PacketTable;

    typedef Column::FixedStringColumn::ColElemType FixedString;

    // frame idx nr | packet idx nr | is valid | is key frame | hash 
    typedef Table::TableTem< Column::ColumnTem<Int32>,
                             Column::ColumnTem<Int32>,
                             Column::ColumnTem<Int32>,
                             Column::ColumnTem<Int32>,
                             Column::FixedStringColumn > FrameTable;

public:

    static const int HASH_SIZE = 32;
    static const String INVALID_FRAME_HASH;
    static const String UNSTABLE_FRAME_HASH;


    VideoAccessStrategy(const Lavc::VideoAccessObject* const vao) : mVao(vao)
    {
        mVideoIsValid = false;
        mFailingKeyFrameNr = -1;
        mPackets = 0;
        mFrames = 0;
        mScanDataPresent = false;
        mNrOfFrames = -1;
        mBadFrameCount = -1;
        mLeadingBadFrameCount = -1;
    }

    virtual
    ~VideoAccessStrategy()
    {
        CleanUp();
        if (mVao != 0)
            delete mVao;
    }

    bool
    Scan()
    {
        if (!ResetVideoSrc())
            return false;

        ILOG_INFO("Scanning video data...");
        mPackets = new PacketTable(1);
        mFrames = new FrameTable(Column::ColumnTem<Int32>(1),
                             Column::ColumnTem<Int32>(1),
                             Column::ColumnTem<Int32>(1),
                             Column::ColumnTem<Int32>(1),
                             Column::FixedStringColumn(HASH_SIZE, 1));
        mNrOfFrames = 0;
        mBadFrameCount = 0;
        mLeadingBadFrameCount = 0;

        bool scanSuccess = ScanProtected();
        ResetVideoSrc();
        if (!scanSuccess)
        {
            CleanUp();
            return false;
        }

        mScanDataPresent = true;
        mNrOfFrames = mFrames->Size();
        ILOG_INFO("Finished video scan; frame count established: " << 
            NrOfFrames());
        return true;
    }

    // Should not be used, in order to isolate knowledge of the vao class
    const VideoAccessObject* const
    VideoAccessObj() const
    {
        return mVao;
    }

    virtual bool
    ResetVideoSrc() const
    {
        return mVao->Reset();
    }

    bool
    VideoIsValid() const
    {
        return mVideoIsValid;
    }

    virtual int
    NrOfFrames() const
    {
        return mNrOfFrames;
    }

    int
    LeadingBadFrames() const
    {
        return mLeadingBadFrameCount;
    }

    bool
    FrameIsValid(int frameNr) const
    {
        return mFrames->Get3(frameNr) != 0;
    }
    
    char
    FrameType() const
    {
        return mVao->FrameType();
    }

    UInt8*
    RgbDataPtr() const
    {
        return mVao->RgbDataPtr();
    }

    VideoIndex*
    ConstructIndex() 
    {
        if (!mScanDataPresent)
        {
            ILOG_ERROR("[ConstructIndex] No scan data");
            return 0;
        }

        ResetVideoSrc();
        VideoIndex* videoIndex = ConstructIndexPrivate();
        if (videoIndex == 0)
            return 0;

        const double percIndexedFrames = 100.0 *
            videoIndex->NrOfEntries() / NrOfFrames();
        const double percentageSeekable = 100.0 * 
            videoIndex->NrOfSeekableFrames() / videoIndex->NrOfEntries();
        const int maxNonTargetFrameReads = videoIndex->MaxNonTargetFrameReads();

        ILOG_INFO("Number of entries in index: " << 
            videoIndex->NrOfEntries() << " (" << percIndexedFrames <<
            " %)");
        ILOG_INFO("Number of seekable entries in index: " << 
            videoIndex->NrOfSeekableFrames() << " (" << percentageSeekable <<
            " %)");
        ILOG_INFO("Max. frame reads required to get to any frame: " << 
            maxNonTargetFrameReads + 1);

        return videoIndex;
    }

    virtual void
    CleanUp()
    {
        if (mPackets != 0)
        {
            delete mPackets;
            mPackets = 0;
        }
        if (mFrames != 0)
        {
            delete mFrames;
            mFrames = 0;
        }
        mScanDataPresent = false;
        mFailingKeyFrameNr = -1;
    }

    virtual int
    DecodeNextFrame(bool* isValidFrame, bool* isKeyFrame, PacketTrace* pktTrace) const
    {
        //avcodec_get_frame_defaults(mFrame);

        const int MAX_READ_FAILURES = Max(15, 5 * mVao->GopSize());
        int nrOfReadFailures = 0;
        bool atEndOfFile = mVao->AtEof();

        bool readPacketFailed = false;
        *isValidFrame = false;
        *isKeyFrame = false;
        int rc = 0;
        while (true)
        {
            int readPacketResult = mVao->ReadPacket();
            readPacketFailed = (readPacketResult < 0);
            if (readPacketFailed)
            {
                // upon a negative value, there may still be 
                // valid frames left to decode
                ILOG_DEBUG("ReadPacket() failed and returned: " << 
                    readPacketResult);
            }
            else if (pktTrace)
                pktTrace->Add(mVao->CurrentPacketSize(), mVao->CurrentPacketFlags(), 
                    mVao->CurrentFilePosition(), mVao->CurrentPacketIsVideo());

            if (mVao->CurrentPacketIsVideo()) 
            {
                int frameDecoded = -1;
                int len = mVao->DecodeFrame(&frameDecoded);

                // SK: used for problem analysis
                int doDecodeTwice = false;
                if (doDecodeTwice)
                {
                    //int frameDecoded2nd = -1;
                    //int len2 = DecodeFrame(&frameDecoded2nd);
                    //if (frameDecoded && frameDecoded2nd)
                    //    ...
                    len = mVao->DecodeFrame(&frameDecoded);
                }

                if (frameDecoded != 0)
                {
                    *isValidFrame = true;
                    *isKeyFrame = 
                        (mVao->FrameType() == 'I' && mVao->FrameIsKey());
                    break;
                }
                else
                {
                    // do not continue if reading reached eof
                    if (atEndOfFile)
                    {
                        rc = -3;
                        break;
                    }

                    // mPacket->flags unequal zero seems to indicate incomplete
                    // frames other than P or B frames missing I or P frame data
                    if (mVao->CurrentPacketFlags() == 0)
                        break;
                }
            }
 
            // while the read buffer already reached eof, there may
            // still be some valid frames left to decode!
            nrOfReadFailures++;
            if ((atEndOfFile || readPacketFailed) 
                && (nrOfReadFailures > MAX_READ_FAILURES))
            {
                ILOG_WARN("Max. nr of frame read failures reached (" <<
                    MAX_READ_FAILURES << "); probably at end of file");
                rc = -1;
                break;
            }
        } // while (true)

        return rc;
    }

    int
    CurrentFrameToRgb() const
    {
        return mVao->CurrentFrameToRgb();
    }

    String
    FrameHash(int frameNr) const
    {
        if (mScanDataPresent)
            return String(mFrames->Get5(frameNr).GetData(), HASH_SIZE);

        ILOG_ERROR("[FrameHash] No scan data");
        return "";
    }

    bool
    JumpToFramePosition(const UInt64& target) const
    {
        const bool mustBeKey = true;
        const int flushMode = 2; // flush (if applies) after the jump
        return Jump(target, GetJumpFlags(), mustBeKey, flushMode);
    }

    bool
    FrameIsStable(int frameNr) const
    {
        if (mScanDataPresent)
            return FrameHash(frameNr) != UNSTABLE_FRAME_HASH;
        else
            ILOG_ERROR("[FrameHash] No scan data");
        return true;
    }

    // Returns whether a frame's data can be read from the stream
    virtual bool
    FrameCanBeRead(int frameNr) const = 0;


protected:

    virtual int
    GetJumpFlags() const = 0;

    virtual bool
    ScanProtected() = 0;

    // Caller assumes responsibility for the returned object.
    virtual VideoIndex*
    ConstructIndexProtected() const = 0;

    virtual bool
    Jump(const UInt64& target, int flags, bool mustBeKey = false, 
        int flush = 0, PacketTrace* trace = 0) const
    {
        if (flush & 1) // flush before seek
            mVao->FlushCodecContext();

        if (!mVao->Seek(target, flags))
            return false;

        if (flush & 2) // flush after seek
            mVao->FlushCodecContext();

        return DecodeNextValidFrame(mustBeKey, trace);
    }

    virtual bool
    DecodeNextValidFrame(bool lookForKeyFrame, PacketTrace* pktTrace = 0)  const
    {
        bool isValidFrame;
        bool isKeyFrame;
        do
        {
            if (DecodeNextFrame(&isValidFrame, &isKeyFrame, pktTrace) != 0) 
                // eof or error
                return false; 
            if (!isValidFrame)
            {
                //ILOG_DEBUG("Skipping invalid frame");
                continue;
            }
            if (lookForKeyFrame && !isKeyFrame)
            {
                //ILOG_DEBUG("Skipping non-keyframe");
                continue;
            }
            break;
        } while (true);

        return true;
    }

    // Processes the currently read frame
    void
    ProcessFrame(bool isValid, bool isKey, int frameNr, bool validating = false)
    {
        static const FixedString invalidAsFixedStr(
            HASH_SIZE, (char*) INVALID_FRAME_HASH.c_str(), true);

        if (validating)
        {
            if (isValid)
            {
                if (!FrameIsValid(frameNr) || 
                    (isKey && !FrameIsKey(frameNr)) ||
                    (!isKey && FrameIsKey(frameNr)))
                {
                    ILOG_ERROR("Unsupported instability type detected for" <<
                        " frame " << frameNr << " (" << FrameIsValid(frameNr) <<
                        "->" << isValid << ", " << FrameIsKey(frameNr) << 
                        "->" << isKey << ")");
                }
                else
                {
                    mVao->CurrentFrameToRgb();
                    if (!CurrentHashMatchesFrame(frameNr))
                        MarkFrameUnstable(frameNr);
                }
            }
            else if (FrameIsValid(frameNr))
                ILOG_ERROR("Unsupported instability type detected for" <<
                    " frame " << frameNr << " (" << FrameIsValid(frameNr) <<
                        "->" << isValid << ")");

            ILOG_DEBUG("Re-scanned frame " << frameNr);
        }

        else 
        {
            String hash = INVALID_FRAME_HASH;
            if (isValid)
            {
                mVao->CurrentFrameToRgb();
                hash = mVao->CurrentHash();
                FixedString hashAsFixedStr(HASH_SIZE, (char*) hash.c_str(), true);
                AddFrameToTable(isValid, isKey, hash, hashAsFixedStr);
            }
            else
                AddFrameToTable(false, false, INVALID_FRAME_HASH, invalidAsFixedStr);

            ILOG_DEBUG("Scanned frame " << frameNr << " [" << 
                (isValid ? mVao->FrameType() : '?') << "] " << hash);
        }
    }

    bool
    FrameIsKey(int frameNr) const
    {
        return mFrames->Get4(frameNr) != 0;
    }

    bool
    CurrentFrameMatchesFrame(int frameNr, const PacketTrace* trace = 0) const
    {
        if (mPackets != 0 && mPackets->Size() > 0)
        {
            const int packetNr = mFrames->Get2(frameNr);
            const int packetSize = mPackets->Get2(packetNr);
            if (mVao->CurrentPacketSize() != packetSize)
                return false;
        }

        if (!CurrentHashMatchesFrame(frameNr))
            return false;

        if (trace && !PacketTraceMatchesFrame(*trace, frameNr))
        {
            ILOG_DEBUG("Packet trace does not match for frame " << frameNr);
            return false;
        }

        return true;
    }

    bool
    CurrentHashMatchesFrame(int frameNr) const
    {
        bool matched = false;
        const String currentHash = mVao->CurrentHash();
        if (currentHash.size() == HASH_SIZE)
        {
            const char* currentHashStr = currentHash.c_str();
            const char* frameHash = 
                mFrames->GetColumn5()->GetVectorData(frameNr);
            matched = true;
            for (int i = 0; i < HASH_SIZE; i++)
                if (frameHash[i] != currentHashStr[i])
                {
                    matched = false;
                    break;
                }
        }

        if (!matched)
            ILOG_DEBUG("Hash does not match for frame " << 
                frameNr << "; found: " << mVao->CurrentHash());
        return matched;
    }

    virtual bool
    NextFrameMatchesFrame(int frameNr, const VideoIndex& videoIndex) const = 0;

    bool
    ScanDataPresent()
    {
        return mScanDataPresent;
    }

    virtual void
    MarkFrameUnstable(int frameNr)
    {
        ILOG_INFO("Instability detected for frame: " << frameNr);
        static const FixedString unstableAsFixedStr(
            HASH_SIZE, (char*) UNSTABLE_FRAME_HASH.c_str(), true);
        mFrames->Set5(frameNr, unstableAsFixedStr);
    }

    // for dev/debug purposes only
    void
    WriteScanData(CString fileName)
    {
        Util::IOBufferFile buf(fileName, false, false);
        Table::Write(mPackets, &buf, true);
        ILOG_INFO("Wrote " << mPackets->Size() << " packets to file");
        Table::Write(mFrames, &buf, true);
        ILOG_INFO("Wrote " << mFrames->Size() << " frames to file");
    }

    // for dev/debug purposes only
    void
    ReadScanData(CString fileName)
    {
        Util::IOBufferFile buf(fileName, true, false);

        if (mPackets)
            mPackets->SetEmpty();
        else
            mPackets = new PacketTable(1);
        Table::Read(mPackets, &buf);
        ILOG_INFO("Read " << mPackets->Size() << " packets from file");

        if (mFrames)
            mFrames->SetEmpty();
        else
            mFrames = new FrameTable(Column::ColumnTem<Int32>(1),
                                     Column::ColumnTem<Int32>(1),
                                     Column::ColumnTem<Int32>(1),
                                     Column::ColumnTem<Int32>(1),
                                     Column::FixedStringColumn(HASH_SIZE, 1));
        Table::Read(mFrames, &buf);
        ILOG_INFO("Read " << mFrames->Size() << " frames from file");

        bool oldScanDataPresent = mScanDataPresent;
        mScanDataPresent = true;
        mNrOfFrames = mFrames->Size();
        mBadFrameCount = 0;
        mLeadingBadFrameCount = 0;
        for (int f = 0; f < mNrOfFrames; f++)
            if (!FrameIsValid(f))
            {
                mBadFrameCount++;
                if (mBadFrameCount > f)
                    mLeadingBadFrameCount++;
            }
        mVideoIsValid = true;
        mScanDataPresent = oldScanDataPresent;
    }

    void
    SetNrOfFrames(int count)
    {
        mNrOfFrames = count;
    }

    const VideoAccessObject* const mVao;

    PacketTable* mPackets;
    FrameTable* mFrames;

    int mBadFrameCount;
    int mLeadingBadFrameCount;

    bool mScanDataPresent;

    //int mPacketTeller;
    //int mFrameTeller;


private:

    void
    AddFrameToTable(bool isValid, bool isKey, CString hash, 
        const FixedString& hashAsFixedStr)
    {
        int frameIdx = mFrames->Size();
        const int lastPacketEntry = mPackets->Size() - 1;
        mFrames->Add(frameIdx, lastPacketEntry, isValid, isKey, 
            hashAsFixedStr);
    }

    // Caller assumes responsibility for the returned object.
    VideoIndex*
    ConstructIndexPrivate() 
    {
        VideoIndex* videoIndex = ConstructIndexProtected();
        if (videoIndex == 0)
            return 0;

        // disable the index' seekable entries that appear to be invalid
        while (!IndexValid(*videoIndex))
        {
            int failingFrameNr = mFailingKeyFrameNr;
            ILOG_DEBUG("Disabling invalid video index entry for frame " << 
                failingFrameNr);
            if (!videoIndex->SetNotSeekable(failingFrameNr))
            {
                ILOG_ERROR("Index entry could not be disabled for frame " << 
                    failingFrameNr);
                delete videoIndex;
                return 0;
            }
        }

        ILOG_DEBUG("Index validated");

        return videoIndex;
    }

    bool 
    IndexValid(const VideoIndex& idx) const
    {
        ILOG_DEBUG("Validating index...");
        return IndexValidTraversingBackwards(idx) &&
            IndexValidTraversingForwards(idx);
    }
    
    bool
    IndexValidTraversingBackwards(const VideoIndex& idx) const
    {
        const int startFrame = 
            (mFailingKeyFrameNr < 0) ? NrOfFrames() : mFailingKeyFrameNr;
        for (int f = startFrame; f > 0 ; )
            if (idx.IsSeekable(--f))
            {
                //ResetVideoSrc();
                if (!JumpValidForFrame(f, idx))
                {
                    mFailingKeyFrameNr = f;
                    return false;
                }
            }
        return true;
    }

    bool
    IndexValidTraversingForwards(const VideoIndex& idx) const
    {
        int startFrame = 0;
        for (int f = startFrame; f < mFailingKeyFrameNr; f++)
            if (idx.IsSeekable(f))
                startFrame = f;

        ResetVideoSrc();
        for (int f = startFrame; f < NrOfFrames(); f++)
            if (idx.IsSeekable(f) && !JumpValidForFrame(f, idx))
            {
                mFailingKeyFrameNr = f;
                return false;
            }
        return true;
    }

    bool
    JumpValidForFrame(int frameNr, const VideoIndex& videoIndex) const
    {
        int seekableFrame = -1;
        UInt64 seekTarget = -1;
        videoIndex.GetSeekInfo(frameNr, &seekableFrame, &seekTarget);
        static const bool MUST_BE_KEY = true;
        const int flushMode = 2; // flush (if applies) after the jump
        Jump(seekTarget, GetJumpFlags(), MUST_BE_KEY, flushMode);
        mVao->CurrentFrameToRgb();
        if (!CurrentFrameMatchesFrame(seekableFrame))
        {
            ILOG_DEBUG("Index failed for (seekable) frame " << frameNr);
            return false;
        }
        ILOG_DEBUG("Jump validated for (seekable) frame " << frameNr);

        // now read sequentially some frames and validate these as well
        bool includedOneSeekable = false;
        while (++frameNr < NrOfFrames())
        {
            if (videoIndex.IsSeekable(frameNr))
                if (includedOneSeekable)
                    break;
                else
                    includedOneSeekable = true;

            if (!NextFrameMatchesFrame(frameNr, videoIndex))
                return false;
        }

        return true;
    }

    bool
    PacketTraceMatchesFrame(const PacketTrace& trace, int frameNr) const
    {
        const int nrOfFrames = mFrames->Size();
        if (frameNr < 0 || frameNr >= nrOfFrames)
            return false;

        //if (!FrameIsKey(frameNr))
        //    return false;

        const int traceLen = trace.Size();

        int nrOfVideoPackets = 0;
        for (int t = 0; t < traceLen; t++)
            if (trace.Get4(t))
                nrOfVideoPackets++;
        int nrOfNonVideoPackets = traceLen - nrOfVideoPackets;

        int packetIdx = mFrames->Get2(frameNr);
        for (int t = traceLen - 1; t >= 0; t--)
        {
            if (packetIdx < 0)
                return false;

            const int sizeFromPackets = mPackets->Get2(packetIdx);
            const int sizeFromTrace = trace.Get1(t);
            const int flagsFromPackets = mPackets->Get3(packetIdx);
            const int flagsFromTrace = trace.Get2(t);
            bool sizeAndFlagsMatch = 
                (sizeFromPackets == sizeFromTrace &&
                flagsFromPackets == flagsFromTrace);

            if (trace.Get4(t)) // from video stream?
            {
                if (--nrOfVideoPackets <= 0)
                    sizeAndFlagsMatch = true;
            }
            else
                if (--nrOfNonVideoPackets <= 0)
                    sizeAndFlagsMatch = true;

            if (!sizeAndFlagsMatch)
            {
                ILOG_DEBUG("Size and/or flags don't match at trace pos " << t << 
                    " of " << traceLen << " : " << sizeFromPackets <<
                    " vs. " << sizeFromTrace << " ; " << flagsFromPackets <<
                    " vs. " << flagsFromTrace);
                return false;
            }

            packetIdx--;

            // SK: trace matching appears not to be trivial; use only last trace entry 
            break; 
        }

        // test match for post-read file position 
        packetIdx = mFrames->Get2(frameNr);
        const UInt64 postReadPosOfFrame = mPackets->Get4(packetIdx);
        const UInt64 lastPosOfTrace = trace.Get3(traceLen - 1);
        if (lastPosOfTrace > postReadPosOfFrame)
        {
            // locate next key frame
            int nextKeyFrame = frameNr + 1;
            for ( ; nextKeyFrame < nrOfFrames; nextKeyFrame++)
                if (mFrames->Get4(nextKeyFrame)) // is key frame?
                    break; 
            if (nextKeyFrame >= nrOfFrames) 
                return true; // assume a match if no more key frames

            // check current (post-read) file position against 
            // post-read-position of next key frame
            packetIdx = mFrames->Get2(nextKeyFrame);
            const UInt64 nextKeyFramesFilePos = mPackets->Get4(packetIdx);
            if (lastPosOfTrace > nextKeyFramesFilePos)
                return false;
        }

        return true;
    }


    bool mVideoIsValid;
    int mNrOfFrames;
    mutable int mFailingKeyFrameNr;

    ILOG_VAR_DECL;

}; //class

ILOG_VAR_INIT(VideoAccessStrategy, Impala.Core.Stream.Lavc);

const String VideoAccessStrategy::INVALID_FRAME_HASH =  "INVALID_FRAME___________________";
const String VideoAccessStrategy::UNSTABLE_FRAME_HASH = "UNSTABLE_FRAME__________________";

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

#endif

---