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

---

StrategyUsingNativeIndex.h

Go to the documentation of this file.

#ifndef Impala_Core_Stream_Lavc_StrategyUsingNativeIndex_h
#define Impala_Core_Stream_Lavc_StrategyUsingNativeIndex_h

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

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

class StrategyUsingNativeIndex : public VideoAccessStrategy
{

public:

    StrategyUsingNativeIndex(const Lavc::VideoAccessObject* const vao) 
        : VideoAccessStrategy(vao)
    {
        SetNrOfFrames(vao->NativeIndexSize());

        ILOG_DEBUG("Applying video access strategy using libavcodec's " <<
            "native frame index, measuring in PTS");
    }

    virtual bool
    FrameCanBeRead(int frameNr) const
    {
        // frames recognized by lavc to be bad, can not be read
        return !FrameIsBadInNativeIndex(frameNr);
    }


protected:

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

    virtual bool
    ScanProtected()
    {
        const AVIndexEntry* const nativeIndex = mVao->NativeIndexEntries();
        const int nativeIndexSize = mVao->NativeIndexSize();
        ILOG_INFO("Native index has size " << nativeIndexSize);


        // debug logging
        int offset = 0;
        for (int e = offset; e <= offset + 10 && e <= nativeIndexSize; e++)
            ILOG_DEBUG("index entry " << e << ": size=" << 
            nativeIndex[e].size << ", flags=" << nativeIndex[e].flags << 
            ", timestamp=" << nativeIndex[e].timestamp << ", pos=" << 
            nativeIndex[e].pos << ", min_distance=" << 
            nativeIndex[e].min_distance << ")"); 


        int nrOfBadFrames = 0;
        int nrOfLeadingBadFrames = 0;
        for (int indexPos = 0; indexPos < nativeIndexSize; indexPos++)
        //int debugMax = 320;
        //for (int indexPos = 0; indexPos < debugMax; indexPos++)
        //for (int indexPos = nativeIndexSize - 1; indexPos >= 0; indexPos--)
        {
            if (indexPos % 250 == 0)
                ILOG_DEBUG("Scanning using native index entry " << indexPos);

            const int indexFlags = nativeIndex[indexPos].flags;
            const bool isKeyFrameAccToIndex = (indexFlags == AVINDEX_KEYFRAME);

            if (FrameIsBadInNativeIndex(indexPos))
            {
                // don't attempt reading the frame since it cannot be 'seen'
                ProcessFrame(false, false, indexPos);
                nrOfBadFrames++;
                if (indexPos < nrOfBadFrames)
                    nrOfLeadingBadFrames++;
                continue;
            }

            if (isKeyFrameAccToIndex)
            {
                const UInt64& pts = nativeIndex[indexPos].timestamp;
                if (!mVao->Seek(pts, AVSEEK_FLAG_ANY))
                {
                    ILOG_ERROR("Failed on PTS based seek for frame " << 
                        indexPos << "; native index flags: " << indexFlags << ")");
                    return false;
                }
            }

            //bool isValidFrame = false; // value not used
            //bool isKeyFrame = false;  // value not used
            bool isValidFrame = true;
            bool isKeyFrame = isKeyFrameAccToIndex;
            //const int result = mVao->DecodeNextFrame(&isValidFrame, &isKeyFrame);
            //if (result < 0)
            //{
            //    ILOG_DEBUG("Frame " << indexPos << " is invalid");
            //    EvalFrame(false, false);
            //    continue;
            //}
            if (!DecodeNextValidFrame(isKeyFrameAccToIndex, 0))
            {
                ILOG_ERROR("Failed to read valid frame " << indexPos);
                return false;
            }
            if (!isKeyFrameAccToIndex && mVao->FrameIsKey())
            {
                ILOG_WARN("Frame read is a key frame but not expected to be: " <<
                    indexPos);
                //return false;
            }

            if (isValidFrame)
            {
                if (isKeyFrameAccToIndex && !isKeyFrame)
                {
                    ILOG_ERROR("Key frame " << indexPos << 
                        " according to native index, appears not to be " << 
                        "a key frame upon decoding");
                    return false;
                }

                if (!isKeyFrameAccToIndex && isKeyFrame)
                {
                    ILOG_ERROR("Non-key frame " << indexPos << 
                        " according to native index, appears to be " << 
                        "a key frame upon decoding");
                    return false;
                }
            }

            ProcessFrame(isValidFrame, isKeyFrame, indexPos);
        }

        ILOG_DEBUG("Bad frames according to native index: " << 
            nrOfBadFrames << " (of which are " <<
            "leading: " << nrOfLeadingBadFrames << ")");
        mBadFrameCount = nrOfBadFrames;
        mLeadingBadFrameCount = nrOfLeadingBadFrames;
        return true;
    }

    virtual VideoIndex*
    ConstructIndexProtected() const
    {
        const AVIndexEntry* const idx = mVao->NativeIndexEntries();
        const int nativeIndexSize = mVao->NativeIndexSize();
        VideoIndex* videoIndex = new VideoIndex();

        //const static int MAX_SEEKABLE_FRAME_DISTANCE = 15;
        //int currentDistance = 0;
        int prevSeekableFrame = -1;
        for (int frameNr = 0; frameNr < nativeIndexSize; frameNr++)
        //int debugMax = 50;
        //for (int frameNr = 0; frameNr < debugMax; frameNr++)
        {
            // note that currently the external index may be bypassed when
            // navigating to a frame; but for PTS this may not work because
            // certain invalid frames will not be 'seen' by sequential reads,
            // while certain valid frames will not be recognized (matched) when
            // reading sequentially. And so I have to introduce restrictions for
            // reading sequentially i.e. in ~Lavc.


            if (!FrameIsValid(frameNr))
            {
                // if invalidity followed from flags or size in the index,
                // I assume that the frame will not be 'seen' during sequential
                // reads?!

                // if invalidity followed from reading a bad frame, the frame 
                // *will* be 'seen' by sequential reads.

                if (idx[frameNr].size > 0 &&
                    ((idx[frameNr].flags | AVINDEX_KEYFRAME) == AVINDEX_KEYFRAME))
                {
                    bool lookForKeyFrame = (idx[frameNr].flags == AVINDEX_KEYFRAME);
                    //bool foundFrame = 
                        //mVao->DecodeNextValidFrame(lookForKeyFrame, 0);
                    bool isValidFrame;
                    bool isKeyFrame;
                    int res = DecodeNextFrame(&isValidFrame, &isKeyFrame, 0);
                    //if (foundFrame)
                    if (res >= 0 && isValidFrame)
                    {
                        String hash = mVao->CurrentHash();
                        ILOG_WARN("Unexpectedly able to successfully read a (" << 
                            mVao->FrameType() << ") frame for (invalid) frame " << 
                            frameNr << ", having hash value " << hash <<
                            "; frame data will be ignored");
                    }

                    //currentDistance++;
                }

                continue;
            }

            const UInt64& pts = idx[frameNr].timestamp;
            bool isKeyFrame = FrameIsKey(frameNr);
            if (isKeyFrame)
            {
                if (!mVao->Seek(pts, AVSEEK_FLAG_ANY))
                {
                    ILOG_ERROR("Failed on PTS based seek for frame: " << 
                        frameNr << (isKeyFrame ? " (is key frame)" : ""));
                    return 0;
                }
            }

            // read next frame
            //bool lookForKeyFrame = false;
            //PacketTrace trace(10);
            //bool foundFrame = 
            //    mVao->DecodeNextValidFrame(lookForKeyFrame, 0);
            //bool isValidFrame;
            //int res = mVao->DecodeNextFrame(&isValidFrame, &isKeyFrame);
            //if (res < 0 || !isValidFrame)
            //{
            //    ILOG_ERROR("Unexpectedly unable to successfully read frame: " << 
            //        frameNr);
            //    return 0;
            //}
            //mVao->CurrentFrameToRgb();
            if (!DecodeNextValidFrame(isKeyFrame, 0))
            {
                ILOG_ERROR("Failed to read valid frame " << frameNr);
                return 0;
            }

            mVao->CurrentFrameToRgb();

            // if not a key frame, check whether the frame is reproducable
            // using sequential reading from previous seekable frame
            //if (!mScanner.FrameIsKey(frameNr))
            if (!isKeyFrame)
            {
                if (prevSeekableFrame >= 0)
                {
                    // kijk of dit frame via seq read vanaf laatste seek reprodbr is
                    //if (foundFrame)
                    
                    if (CurrentFrameMatchesFrame(frameNr, 0))
                    {
                        //currentDistance++;
                        continue;
                    }
                    else
                    {
                        ILOG_ERROR("Non-reproducable frame: " << frameNr <<
                            ", current hash value is " << mVao->CurrentHash());
                        return 0;
                    }
                }
            }

            if (!CurrentFrameMatchesFrame(frameNr, 0))
            {
                ILOG_ERROR("Non-reproducable key frame: " << frameNr <<
                    ", current hash value is " << mVao->CurrentHash());
                return 0;
            }

            // add an entry to the external index for this key frame
            videoIndex->AddFrame(frameNr, true, pts);
            ILOG_DEBUG("Indexed frame: " << frameNr << " " << 
                frameNr << " " << true << " " << pts);
            prevSeekableFrame = frameNr;
            //currentDistance = 0;
        }

        return videoIndex;
    }

    virtual bool
    NextFrameMatchesFrame(int frameNr, const VideoIndex& videoIndex) const
    {
        return true; // already tested at index creation
    }


private:

    // Returns 'true' if the specified frame is bad according to the
    // native index
    bool
    FrameIsBadInNativeIndex(int frameNr) const
    {
        const AVIndexEntry* const nativeIndex = mVao->NativeIndexEntries();
        const int indexFlags = nativeIndex[frameNr].flags;
        const bool isBad = (nativeIndex[frameNr].size <= 0) ||
            (indexFlags != 0 && indexFlags != AVINDEX_KEYFRAME);
        return isBad;
    }


    ILOG_VAR_DECL;

}; //class

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

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

#endif

---