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

---

StrategyIgnoringNativeIndex.h

Go to the documentation of this file.

#ifndef Impala_Core_Stream_Lavc_StrategyIgnoringNativeIndex_h
#define Impala_Core_Stream_Lavc_StrategyIgnoringNativeIndex_h

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

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

class StrategyIgnoringNativeIndex : public VideoAccessStrategy
{

public:

    StrategyIgnoringNativeIndex(const Lavc::VideoAccessObject* const vao) 
        : VideoAccessStrategy(vao)
    {
        ILOG_DEBUG("Applying video access strategy based on " <<
            "frame positions expressed in bytes");
    }

    virtual bool
    FrameCanBeRead(int frameNr) const
    {
        // all frames' data can be read
        return true;
    }


protected:

    virtual int
    GetJumpFlags() const
    {
        //return AVSEEK_FLAG_BYTE | AVSEEK_FLAG_ANY;
        return AVSEEK_FLAG_BYTE;
    }

    virtual bool
    ScanProtected()
    {
        ILOG_INFO("First scan pass, collecting...");
        bool debug = false;
        if (!debug)
            ScanPackets(false);
        //else
        //    ReadScanData("scandata");
        //if (!debug)
        //    WriteScanData("scandata");
        mScanDataPresent = true;
        mVao->Reset();
        ILOG_INFO("Second scan pass, validating...");
        if (!debug)
            ScanPackets(true);
        //else
        //    ReadScanData("scandata");
        //if (!debug)
        //    WriteScanData("scandata");

        const int frameCnt = mFrames->Size();
        if (frameCnt <= 0)
        {
            ILOG_ERROR("No frames found");
            return false;
        }

        ILOG_INFO("Detected " << mLeadingBadFrameCount << 
            " leading bad frame(s) and " << mBadFrameCount << 
            " bad frame(s) in total");
        if (mLeadingBadFrameCount >= frameCnt)
        {
            ILOG_ERROR("No valid frames found");
            return false;
        }

        const int firstValidFrameNr = mLeadingBadFrameCount;
        if (!FrameIsKey(firstValidFrameNr))
        {
            ILOG_ERROR("Unexpected: first valid frame (" << firstValidFrameNr <<
                ") is not a key frame (type: " << mVao->FrameType() << ")");
            return false;
        }

        // validate reproduction of first valid key frame's hash
        mVao->Reset();
        bool lookForKeyFrame = true;
        PacketTrace trace(10);
        bool foundFirstKeyFrame = 
            DecodeNextValidFrame(lookForKeyFrame, &trace);
        if (!foundFirstKeyFrame)
        {
            ILOG_ERROR("Could not locate first valid key frame");
            return false;
        }

        mVao->CurrentFrameToRgb();
        if (!CurrentFrameMatchesFrame(firstValidFrameNr, &trace))
        {
            ILOG_ERROR("Could not reproduce first valid key frame " << 
                firstValidFrameNr);
            return false;
        }

        return true;
    }

    virtual VideoIndex*
    ConstructIndexProtected() const
    {
        VideoIndex* videoIndex = new VideoIndex();
        UInt64 seekPos;
        int packetToStartSearchAt = -1; 
        const int frameCount = NrOfFrames();
        for (int f = 0; f < frameCount; f++)
        {
            if (FrameIsValid(f) && FrameIsKey(f) && FrameIsStable(f))
            {
                const bool frameIsSeekable = FindSeekPosition(f, 
                    &seekPos, &packetToStartSearchAt);
                if (frameIsSeekable)
                {
                    videoIndex->AddFrame(f, true, seekPos);
                    ILOG_DEBUG("Indexed frame: " << f << " " << f << 
                        " true " << seekPos);
                }
                else if (videoIndex->NrOfEntries() == 0)
                {
                    ILOG_ERROR("Failed to find a seek position for " <<
                        "frame " << f);
                    delete videoIndex;
                    return 0;
                }
            }
        }
        return videoIndex;
    }

    virtual bool
    NextFrameMatchesFrame(int frameNr, const VideoIndex& videoIndex) const
    {
        if (!DecodeNextValidFrame(false))
        {
            ILOG_DEBUG("Failed on sequential read for frame " << frameNr);
            return false;
        }

        if (FrameIsStable(frameNr))
        {
            mVao->CurrentFrameToRgb();
            if (!CurrentHashMatchesFrame(frameNr))
            {
                ILOG_DEBUG("Index error for frame " << frameNr << 
                    " ; hash found = " << mVao->CurrentHash());
                return false;
            }
        }

        return true;
    }


private:

    void
    ScanPackets(bool validating)
    {
        int packetCount = 0;
        int frameCount = 0;
        mBadFrameCount = 0;
        mLeadingBadFrameCount = 0;

        // ***************************
        // SK: for debugging
        bool _limitWork4Debugging = false;
        int _myMax = -1;
        if (_limitWork4Debugging)
        {
            _myMax = 30;
            _myMax *= 1;
        }
        else
        {
            _myMax *= 1;
        }

        bool noMorePackets = false;
        while (!noMorePackets && !(_limitWork4Debugging && frameCount > _myMax))
        // ***************************
            noMorePackets = ScanOnePacket(&packetCount, &frameCount, validating);

        ILOG_DEBUG("Scanned " << packetCount << " packets, and found " <<
            frameCount << " frames");
    }

    // Returns 'true' if no packet could be read; 'false' otherwise.
    bool
    ScanOnePacket(int* packetCount, int* frameCount, bool validating)
    {
        const int MAX_POST_EOF_FAILURES = Max(15, 2 * mVao->GopSize());
        int nrOfConsecutivePostEofFailures = 0;

        while (true)
        {
            const bool atEofBeforeRead = mVao->AtEof();
            const int readPacketResult = mVao->ReadPacket();
            if (mVao->AtEof() && !atEofBeforeRead)
                ILOG_DEBUG("Reached end of file");

            const bool readPacketFailed = (readPacketResult < 0);
            if (!readPacketFailed)
            {
                if (atEofBeforeRead)
                {
                    ILOG_DEBUG("A packet was successfully read after " <<
                        "reading arrived at end of file");
                }
                const int packetNr = (*packetCount)++;
                ProcessPacket(packetNr, frameCount, validating);
                return false;
            }

            ILOG_DEBUG("ReadPacket() failed and returned: " << 
                readPacketResult);

            if (atEofBeforeRead)
            {
                if (readPacketFailed)
                {
                    nrOfConsecutivePostEofFailures++;
                    if (nrOfConsecutivePostEofFailures > MAX_POST_EOF_FAILURES)
                    {
                        ILOG_DEBUG("Max. nr of consecutive post-EOF " <<
                            "read failures reached (" <<
                            MAX_POST_EOF_FAILURES << ")");
                        return true;
                    }
                }
                else 
                    nrOfConsecutivePostEofFailures = 0;
            }
        }
    }

    // Evaluates the currently read packet, which must be the result of a 
    // successful read operation; otherwise this call might incorrectly 'see'
    // a valid packet and frame!
    void
    ProcessPacket(int packetNr, int* frameCount, bool validating)
    {
        const int size = mVao->CurrentPacketSize();
        const int flags = mVao->CurrentPacketFlags();
        const UInt64 posAfterRead = mVao->CurrentFilePosition();

        if (validating)
        {
            if (mPackets->Get2(packetNr) != size || 
                mPackets->Get3(packetNr) != flags ||
                mPackets->Get4(packetNr) != posAfterRead)
            {
                ILOG_ERROR("Packet " << packetNr << " not reproducable");
                return;
            }
        }
        else
            mPackets->Add(packetNr, size, flags, posAfterRead);

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

            // libavcodec's packet flags usage is not clear,  
            // but this appeared to work out fine: 
            const bool ignorePacket = (frameDecoded <= 0) && (flags != 0);

            if (!ignorePacket)
            {
                const bool frameValid = (len >= 0 && frameDecoded > 0);
                bool frameIsKey = false;
                if (frameValid)
                {
                    frameIsKey = (mVao->FrameType() == 'I' && mVao->FrameIsKey());
                }
                else
                {
                    ILOG_DEBUG("DecodeFrame() failed (" << frameDecoded << 
                        ") and returned: " << len );
                    mBadFrameCount++;
                    if (mBadFrameCount >= *frameCount)
                        mLeadingBadFrameCount++;
                }

                const int frameNr = (*frameCount)++;
                ProcessFrame(frameValid, frameIsKey, frameNr, validating);
            }
        }
    }

    // Returns 'true' if a position was found that allows 
    // random (seek) access to the specified frame; 'false' otherwise.
    // The frame specified must be valid and be a key frame, must not yet occur 
    // in the index, and must be greater than all frame nrs already occurring 
    // in the index. 
    // Furthermore the packet table is assumed to be in ascending 
    // order with regard to post-read file positions.
    bool
    FindSeekPosition(int frameNr, UInt64* seekPos, int* refPacket) const
    {
        // find: the first next file position suitable for seeking the frame
        bool foundCandSeekPos = FindCandidateSeekPosition(seekPos, refPacket);
        if (!foundCandSeekPos || !IsValidSeekTarget(frameNr, *seekPos))
        {
            ILOG_DEBUG("No valid seek position found for frame " << frameNr);
            return false;
        }

        // optimize: check whether the next candidate position is also valid
        UInt64 nextSeekTarget;
        int tempRefPacket = *refPacket;
        while (true)
        {
            foundCandSeekPos = 
                FindCandidateSeekPosition(&nextSeekTarget, &tempRefPacket);
            if (!foundCandSeekPos || !IsValidSeekTarget(frameNr, nextSeekTarget))
                break;
            *seekPos = nextSeekTarget;
            *refPacket = tempRefPacket;
        }
        return true;
    }

    // Determines the smallest post-read file position occurring in the packet 
    // table from the specified reference packet on, updates the reference 
    // packet with the first next packet nr with a post-read position greater than 
    // the value found, and returns 'true'. If a negative value is passed in 
    // for the ref packet, the first data position from the video 
    // stream will be used. If no valid file position could be found, 'false' 
    // is returned.
    bool FindCandidateSeekPosition(UInt64* seekPos, int* refPacket) const
    {
        const int packetTableSize = mPackets->Size();
        if (*refPacket >= packetTableSize)
            return false;

        int nextRefPacket;
        if (*refPacket < 0)
        {
            *seekPos = mVao->FirstPacketPosition();
            nextRefPacket = 0;
        }
        else
        {
            *seekPos = mPackets->Get4(*refPacket);
            nextRefPacket = *refPacket + 1;
        }

        while (nextRefPacket < packetTableSize)
        {
            if (mPackets->Get4(nextRefPacket) > *seekPos) // post-read file pos
            {
                *refPacket = nextRefPacket;
                return true;
            }
            nextRefPacket++;
        }

        return false;
    }

    // Returns 'true' if seeking to the specified position in the video and 
    // reading frames until a key frame is found, will result in the specified
    // key frame;
    // assumes the specified frame is a valid and stable key frame!
    bool
    IsValidSeekTarget(int frameNr, const UInt64& seekPos) const
    {
        PacketTrace trace(10);
        static const bool MUST_BE_KEY = true;
        if (!Jump(seekPos, AVSEEK_FLAG_BYTE, MUST_BE_KEY, 2, &trace))
            return false;

        CurrentFrameToRgb();
        if (!CurrentFrameMatchesFrame(frameNr, &trace))
            return false;

        UInt64 postReadPos = mPackets->Get4(mFrames->Get2(frameNr));
        UInt64 lastPostReadPosOfTrace = trace.Get3(trace.Size() - 1);
        if (lastPostReadPosOfTrace <= postReadPos)
            return true;

        for (int f = frameNr + 1; f < mFrames->Size(); f++)
        {
            if (!DecodeNextValidFrame(false, &trace))
            {
                ILOG_ERROR("Unexpected: could not find/decode frame " << f);
                return false;
            }

            CurrentFrameToRgb();
            if (!CurrentFrameMatchesFrame(f, &trace))
            {
                ILOG_DEBUG(seekPos << " is not a valid seek target for " <<
                    "frame " << frameNr << ", following from a mismatch for " <<
                    "frame " << f);
                return false;
            }

            postReadPos = mPackets->Get4(mFrames->Get2(f));
            lastPostReadPosOfTrace = trace.Get3(trace.Size() - 1);
            if (lastPostReadPosOfTrace <= postReadPos)
                break;
        }
        return true;
    }


    ILOG_VAR_DECL;

}; //class

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

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

#endif

---