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

---

RgbDataSrcLavc_old.h

Go to the documentation of this file.

#ifndef Impala_Core_Stream_RgbDataSrcLavc_old_h
#define Impala_Core_Stream_RgbDataSrcLavc_old_h

#include <string>
#include <iostream>
#include <vector>

//extern "C"{
//#include "ffmpeg/swscale.h"
//}

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

// include our one and only entry point into libavcodec:
#include "Link/Lavc/Lavc.h"

#include "Link/DiskImage/DiskImageFuncs.h"
#include "Core/Stream/RgbDataSrcInfo.h"
#include "Core/Stream/LavcProtocolDataServer.h"
#include "Core/Table/TableTem.h"

#ifdef USE_IFILE
#include "Core/Stream/LavcProtocolLocalFile.h"
#endif


namespace Impala
{
namespace Core
{
namespace Stream
{


class LAVCException : public std::exception
{
    String mWhat;
    int mType;

public:

    LAVCException(const String what, int type) : mWhat(what), mType(type) {}
    ~LAVCException() throw() {}
    virtual const char* what() const throw() { return mWhat.c_str(); }
};


class RgbDataSrcLavc_old : public RgbDataSrcInfo
{

    typedef Array::Array2dVec3UInt8 Array2dVec3UInt8;

public:

    RgbDataSrcLavc_old(int src, CString srcName, Util::Database* db, 
        IndexMode mode = READIDX)
        : RgbDataSrcInfo(src, srcName, db, 
            DetermineInfoName(srcName, mode, db), true)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        mValid = false;
        mMode = mode;
        mBufferedFrameNr = -1;
        mFixCnt = 0;
        mLastFixNr = 0;

        mLastFrame = mFrameCnt = LASTFRAME_UNKNOWN;
        mSrcName = StringReplaceAll(srcName, "\\", "/", false);
        mPacket = 0;

        mFixIndexIfBroken = options.GetBool("fixIdx", true);
        if (!mFixIndexIfBroken)
        {
            ILOG_WARN("Index will NOT be fixed if broken!");
        }
        SetJumpMethod(options.GetString("jmp", "pos"));        

        Init();
    }

    virtual
    ~RgbDataSrcLavc_old() 
    {
        // Free the RGB image data
        delete [] mData;

        if (mPacket != 0)
            delete mPacket;

        av_free(mFrameRGB);

        // Free the YUV frame
        av_free(mFrame);

        // free the image conversion context
        sws_freeContext(mSwsContext);

        // Close the codec
        avcodec_close(mCodecCtx);

        // Close the video file
        av_close_input_file(mFormatCtx);
    }
    
    virtual char
    FrameType() const
    {
        switch (mFrame->pict_type)
        {
            case FF_I_TYPE : return 'I';
            case FF_P_TYPE : return 'P';
            case FF_B_TYPE : return 'B';
        }
        return '?';
    }

    virtual bool
    CurIsIFrame() const
    {
        return mFrame->pict_type == FF_I_TYPE;
    }


//public:

    virtual bool
    Valid() const
    {
        return mValid;
    }

    void
    JumpToKeyFrame(int key)
    {
        const int64_t targetPos = GetPos(key);
        ILOG_DEBUG("Jumping to Keyframe " << key << " @ " 
                << targetPos << " (" << mJumpMethod << ") " );

        //flush after the jump and sync to keyframe
        Jump(targetPos, mJumpFlags, 2, 2);
        mCurrentFrameNr = mBufferedFrameNr = key;
        CheckMD5Hash(key);
    }

    void
    Jump(int64_t newPos, int flag, int flush=0, int sync=0)
    {
        ILOG_DEBUG("Attempting jump to " << newPos << " (method: " << 
            mJumpMethod << ")");

        if (mCodecCtx->codec->flush == NULL)
            flush = 0; // never flush
        else if (flush & 1) // flush before seek (flushing was introduced by Taylan)
            mCodecCtx->codec->flush(mCodecCtx);

        //ILOG_DEBUG("[Jump] " << mVideoStream->last_IP_duration << " " << mVideoStream->cur_dts);
        int res = av_seek_frame(mFormatCtx, mVideoStreamIndex, newPos, flag);
        //ILOG_DEBUG("[Jump] " << mVideoStream->last_IP_duration << " " << mVideoStream->cur_dts);

        if (res >= 0)
        {
            if (flush & 2) // flush after seek (flushing was introduced by Taylan)
                mCodecCtx->codec->flush(mCodecCtx);
        }
        else
        {
            ILOG_ERROR("av_seek_frame returned negative value: " << res << 
                " (" << newPos << " " << flag << " " << flush << " " << sync << ")");
            return;
        }

        if (sync == 1)
            FindNextDecodedFrame(false);
        else 
            if (sync == 2)
                FindNextDecodedFrame(true);
    }
    
    bool
    FindNextDecodedFrame(const bool lookForKeyFrame) 
    {
        //ILOG_DEBUG("[FindNextDecodedFrame] mCurrentFrameNr=" << mCurrentFrameNr << " mBufferedFrameNr=" << mBufferedFrameNr);
        //ILOG_DEBUG("  video stream's curdts=" << mVideoStream->cur_dts << " mPacket->dts=" << mPacket->dts);

        bool isValidFrame;
        bool isKeyFrame;
        do
        {
            const bool gotFrame = (DecodeNextFrame(isValidFrame, isKeyFrame) == 0);
            if (!gotFrame) // indicates 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);

        ConvertFrameToRgb();
        return true;
    }
    
private:

    void
    SetJumpMethod(String jmp)
    {
        mJumpMethod = jmp;
        ILOG_DEBUG("Jump Method is " << mJumpMethod);
        if (mJumpMethod == "pos")
            mJumpFlags = AVSEEK_FLAG_ANY | AVSEEK_FLAG_BYTE;
        else
            //mJumpFlags = AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD;
            mJumpFlags = AVSEEK_FLAG_ANY;
    }

    void
    Init()
    {
        try
        {
            InitFFMPEG();
            InitFormatCtx();
            InitStreams();
            InitCodecCtx();
            InitFrames();

            if (!PrepareForReading())
            {
                mValid = false;
                return;
            }

            if (mMode != NOCHECK)
            {
                if (mMode == READIDX && !ReadInfo())
                {
                    throw LAVCException("Could not read info file for: " + 
                        mSrcName, 0);
                }

                else if (mMode == WITHIDX)
                {
                    if (!ReadInfo(true))
                        PopulateIndex();
                }

                else if (mMode == ADHOCIDX)
                {
                    // Create but don't store
                    PopulateIndex();
                }

                else if (mMode == WRITEIDX)
                {
                    // Create and store
                    PopulateIndex();
                    WriteInfo();
                }

                Reset();
            }
        }
        catch (LAVCException& e)
        {
            mValid = false;
            ILOG_ERROR("Initialization failed: " << e.what());
            return;
        }

        mValid = true;
        ILOG_DEBUG("Initialization succeeded");
    }
    
    bool 
    InitFFMPEG()
    {
        ILOG_INFO("libavcodec version  : " << 
            (int)(LIBAVCODEC_VERSION_INT>>16) << "." << 
            (int)((LIBAVCODEC_VERSION_INT>>8)&0xFF) << "." << 
            (int)(LIBAVCODEC_VERSION_INT&0xFF));

        ILOG_INFO("libavformat version : " << 
            (int)(LIBAVFORMAT_VERSION_INT>>16) << "." << 
            (int)((LIBAVFORMAT_VERSION_INT>>8)&0xFF) << "." << 
            (int)(LIBAVFORMAT_VERSION_INT&0xFF));

        ILOG_INFO("libavutil version   : " << 
            (int)(LIBAVUTIL_VERSION_INT>>16) << "." << 
            (int)((LIBAVUTIL_VERSION_INT>>8)&0xFF) << "." << 
            (int)(LIBAVUTIL_VERSION_INT&0xFF));


        // Set libavcodec's log output level
        //av_log_set_level(AV_LOG_DEBUG);
        //av_log_set_level(AV_LOG_ERROR);
        //av_log_set_level(AV_LOG_FATAL);
        av_log_set_level(AV_LOG_QUIET);


        // Register all formats and codecs 
        av_register_all();
        avcodec_register_all();

        register_protocol(&LavcProtocolDataServer_protocol);

        if (Link::DiskImage::DiskImageUsed())
        {
            ILOG_DEBUG("Registering disk image protocol..");
            Link::DiskImage::RegisterProtocol();
        }

#ifdef USE_IFILE
        ILOG_DEBUG("Registering Impala file protocol..");
        register_protocol(&LavcProtocolLocalFile_protocol);
#endif
        return true;
    }


    bool 
    InitFormatCtx()
    {
        // Open video file 
        CmdOptions& options = CmdOptions::GetInstance();
        String dataServer = options.GetString("dataServer");
        String srcAddress = mSrcName;
        if (!dataServer.empty())
            srcAddress = "dataserver:" + mSrcName;

        int result = av_open_input_file(&mFormatCtx, 
                                 srcAddress.c_str(), NULL, 0, NULL);

        if (result != 0)
        {
            ILOG_ERROR("Return value from av_open_input_file(): " << result);
            throw (LAVCException("Unable to open: " + mSrcName, 0));
            return false;
        }

#if LIBAVFORMAT_VERSION_INT >= ((51<<16)+(14<<8)+0) // from version 51.14.0 on
        if (mFormatCtx->iformat->flags & AVFMT_GENERIC_INDEX)
        {
            // if flag not initially cleared, may result in invalid data;
            // mFormatCtx is not available until input file is opened
            mFormatCtx->iformat->flags -= AVFMT_GENERIC_INDEX;
            ILOG_DEBUG("Flag cleared: mFormatCtx->iformat->flags -= " <<
                "AVFMT_GENERIC_INDEX");

            // re-open the file
            result = av_open_input_file(&mFormatCtx, 
                                 srcAddress.c_str(), NULL, 0, NULL);
        }
#endif

        // Retrieve stream information
        if (av_find_stream_info(mFormatCtx) < 0) 
            throw LAVCException("Could not find stream info in: " + mSrcName, 0);

        // Dump information about file onto standard error
        dump_format(mFormatCtx, 0, mSrcName.c_str(), false);

        mFormatCtx->flags |= AVFMT_FLAG_GENPTS;

        mBitRate     = mFormatCtx->bit_rate;
        mFormatName  = mFormatCtx->iformat->name;
        mFormatLName = mFormatCtx->iformat->long_name;
        ILOG_INFO("Format name is: " << mFormatLName << " (" << mFormatName << ")");
        
        if ((mFormatName == "avi") ||
            (mFormatName == "mov,mp4,m4a,3gp,3g2,mj2"))
        {
            SetJumpMethod("pts");
        }
        else
        {
             //SK, 16-Mar-2009: It appears the following clause should
             //  never be used anyway.
//#if LIBAVFORMAT_VERSION_INT >= ((51<<16)+(14<<8)+0) 
//            // SK, 11-Mar-2009: this appeared not to work out well for AVI:
//            int oldFlags = mFormatCtx->iformat->flags;
//            ILOG_DEBUG("Changing mFormatCtx->iformat->flags from " << 
//                oldFlags << " into " << (oldFlags | AVFMT_GENERIC_INDEX));
//            mFormatCtx->iformat->flags |= AVFMT_GENERIC_INDEX;
//#endif
        }

        return true;
    }


    bool
    InitStreams()
    {
        mStreamCount = mFormatCtx->nb_streams;
        mVideoStreamIndex = -1;
        mVideoStream = 0;

        // find the first video stream 
        for (int i = 0; i < mStreamCount; i++)
        {
            if (mFormatCtx->streams[i]->codec->codec_type 
                                                    == CODEC_TYPE_VIDEO)
            {
                if (mVideoStreamIndex >= 0)
                    throw (LAVCException("Multiple video streams found in: " 
                                + mSrcName, 0));

                mVideoStreamIndex = i;
                mVideoStream = mFormatCtx->streams[i];
            }
        }
        if (mVideoStream == 0) 
            throw LAVCException("Could not find video stream in: " 
                                + mSrcName, 0);

        // collect video stream info
        mVideoDuration = mVideoStream->duration; // number of (time) fractions
        const AVRational videoTimeBase = 
            mVideoStream->time_base; // time fraction duration (seconds)
        mTimeBaseNum = videoTimeBase.num;
        mTimeBaseDen = videoTimeBase.den;
        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 = mVideoStream->r_frame_rate.num;
        mFrameRateDen = mVideoStream->r_frame_rate.den;
        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_DEBUG("Frame count estimate based on video duration: " << 
            mFrameCountCalculated);

        return true;
    }


    bool InitCodecCtx()
    {
        // Get a pointer to the codec context for the video stream
        mCodecCtx = mVideoStream->codec;
        
        // Find the decoder for the video stream
        mCodec = avcodec_find_decoder(mCodecCtx->codec_id);
        if (mCodec == NULL) 
            throw LAVCException("Codec not found for: " + mSrcName, 0);

        // Open codec
        if (avcodec_open(mCodecCtx, mCodec) < 0) 
            throw LAVCException("Could not open codec (id=" + 
                MakeString(mCodecCtx->codec_id) + ", name=" + 
                mCodecName + ") for: " + mSrcName, 0);

        mFrameWidth = mCodecCtx->width;
        mFrameHeight = mCodecCtx->height;

        mAspectRatioNum = mCodecCtx->sample_aspect_ratio.num;
        mAspectRatioDen = mCodecCtx->sample_aspect_ratio.den;

        mGopSize = mCodecCtx->gop_size;

        // setup image conversion context
        mSwsContext = sws_getContext(
            mFrameWidth, mFrameHeight, mCodecCtx->pix_fmt, 
            mFrameWidth, mFrameHeight, PIX_FMT_RGB24, 
            SWS_BICUBIC, NULL, NULL, NULL);
        if (mSwsContext == NULL) 
            throw LAVCException(
                "Failed to initialize image conversion context for: " + 
                mSrcName, 0);


        char buf[5];
#ifdef WIN32
        _snprintf(
#else
        snprintf(
#endif
            buf, sizeof(buf), "%c%c%c%c",
            mCodecCtx->codec_tag & 0xff,
            (mCodecCtx->codec_tag >> 8) & 0xff,
            (mCodecCtx->codec_tag >> 16) & 0xff,
            (mCodecCtx->codec_tag >> 24) & 0xff);
        mCodecTag = buf;


        mCodecName = mCodec->name;

        ILOG_INFO("Opened codec (id=" << mCodecCtx->codec_id << 
            ", name=" << mCodecName << ") for: " << mSrcName);

        if (mCodecName == "mpeg1video")
        {
            // "mpeg1video" is troublesome with presentation timestamps,
            SetJumpMethod("pos");
        }

        return true;
    }

    bool InitFrames()
    {
        mPacket = new AVPacket;

        // Allocate frame for reading
        mFrame = avcodec_alloc_frame();

        // Allocate frame for RGB conversion
        mFrameRGB = avcodec_alloc_frame();

        if ((mFrameRGB == NULL) || (mFrame == NULL)) 
            throw LAVCException("Could not allocate frame memory for: "
                                 + mSrcName, 0);

        // allocate buffer to hold frame data converted to RGB
        const int numBytes = avpicture_get_size(
            PIX_FMT_RGB24, mFrameWidth, mFrameHeight);
        mData = new UInt8[numBytes];

        // Assign appropriate parts of buffer to image planes in mFrameRGB
        int result = avpicture_fill( (AVPicture*) mFrameRGB, 
            mData, PIX_FMT_RGB24, mFrameWidth, mFrameHeight);

        return true;
    }

    void 
    Reset()
    {
        ILOG_DEBUG("Rewinding stream");

        Int64 startPos = GetPos(mBlankFrames);
        if (startPos < 0)
        {
            ILOG_WARN("No position found for frame: " << mBlankFrames <<
                ". Trying 0 as position (which is probably fine " <<
                "for getting to the head of the file)");
            startPos = 0;
        }

        const int flush = 2; // i.e. flush after jump
        const int sync = 1;  // i.e. no sync on key frames
        Jump(startPos, mJumpFlags, flush, sync);

        mBufferedFrameNr = mBlankFrames; // the currently buffered (valid) frame
        mCurrentFrameNr = 0;
    }
    
    bool 
    PrepareForReading()
    {
        ILOG_DEBUG("Preparing for reading video stream...");

#ifdef FFMPEG_52
        ILOG_DEBUG("[PrepareForReading] stream's curdts=" << mVideoStream->cur_dts << " mPacket->dts=" << mPacket->dts << " mPacket->pts=" << mPacket->pts << " mPacket->size=" << mPacket->size << "; pb->pos=" << mFormatCtx->pb->pos);
        int result = av_seek_frame(mFormatCtx, mVideoStreamIndex, 0, AVSEEK_FLAG_BYTE | AVSEEK_FLAG_ANY);
        ILOG_DEBUG("[PrepareForReading] stream's curdts=" << mVideoStream->cur_dts << " mPacket->dts=" << mPacket->dts << " mPacket->pts=" << mPacket->pts << " mPacket->size=" << mPacket->size << "; pb->pos=" << mFormatCtx->pb->pos << "; result = " << result);
        //result = av_seek_frame(mFormatCtx, mVideoStreamIndex, 0, AVSEEK_FLAG_BYTE | AVSEEK_FLAG_ANY);
        //ILOG_DEBUG("[PrepareForReading] stream's curdts=" << mVideoStream->cur_dts << " mPacket->dts=" << mPacket->dts << " mPacket->pts=" << mPacket->pts << " mPacket->size=" << mPacket->size << "; pb->pos=" << mFormatCtx->pb->pos << "; result = " << result);
#else
        ILOG_DEBUG("[PrepareForReading] stream's curdts=" << mVideoStream->cur_dts << " mPacket->dts=" << mPacket->dts << " mPacket->pts=" << mPacket->pts << " mPacket->size=" << mPacket->size << "; pb.pos=" << mFormatCtx->pb.pos);
        const int flags = AVSEEK_FLAG_BYTE | AVSEEK_FLAG_ANY;
        int result = av_seek_frame(mFormatCtx, mVideoStreamIndex, 0, flags);
        ILOG_DEBUG("[PrepareForReading] stream's curdts=" << mVideoStream->cur_dts << " mPacket->dts=" << mPacket->dts << " mPacket->pts=" << mPacket->pts << " mPacket->size=" << mPacket->size << "; pb.pos=" << mFormatCtx->pb.pos << "; result = " << result);
        //result = av_seek_frame(mFormatCtx, mVideoStreamIndex, 0, AVSEEK_FLAG_BYTE | AVSEEK_FLAG_ANY);
        //ILOG_DEBUG("[PrepareForReading] stream's curdts=" << mVideoStream->cur_dts << " mPacket->dts=" << mPacket->dts << " mPacket->pts=" << mPacket->pts << " mPacket->size=" << mPacket->size << "; pb.pos=" << mFormatCtx->pb.pos << "; result = " << result);
#endif

        if (result < 0)
        {
            ILOG_ERROR("[PrepareForReading] av_seek_frame returned " << result);
            return false;
        }

        if (mCodecCtx->codec->flush != NULL)
            mCodecCtx->codec->flush(mCodecCtx);

        mBlankFrames = 0;
        int currentFrameNr = -1;
        const bool startAtKeyFrame = false; // SK: I think we should start at a keyframe; Taylan did not; what does VirtualDub do? Might a first frame be non-keyframe but readable nevertheless?
        bool isValidFrame = false;
        bool isKeyFrame = false;
        while (!isValidFrame || (startAtKeyFrame && !isKeyFrame))
        {
            const bool gotFrame = (DecodeNextFrame(isValidFrame, isKeyFrame) == 0);
            if (!gotFrame) // indicates eof or error
                return false; 
            currentFrameNr++;
            if (!isValidFrame)
            {
                MarkBadFrame(currentFrameNr);
                mBlankFrames++;
            }
        }

        ConvertFrameToRgb();

        mCurrentFrameNr = mBufferedFrameNr = currentFrameNr;
        ILOG_DEBUG("Prepared for reading video stream; detected " << mBlankFrames << " leading invalid frame(s)");
        return true;
    }

    bool PopulateIndex()
    {
        ILOG_DEBUG("Creating the video index!");

        const String formatName(mFormatCtx->iformat->name);
        if (("mpeg" == formatName) || ("mpg" == formatName) 
            || mCodecName == "mpeg1video")
        {
            PopulateMpegIndex();
        }
        else if (("avi" == formatName) || ("mov,mp4,m4a,3gp,3g2,mj2" == formatName))
        {
            PopulateAviIndex();
        }
        else
        {
            ILOG_WARN("Cannot an create external index for format: " << formatName);
            mLastFrame = mFrameCountCalculated - 1; // is an estimate
            return false;

            //PopulateTrivialIndex();
        }
        
        ILOG_DEBUG("Frame count established from populating the index: " << mLastFrame + 1);
        return true;
    }


    void 
    PopulateMpegIndex()
    {
        AVIndexEntry *idx = mVideoStream->index_entries;
        if (idx && !(mFormatCtx->flags & AVFMT_FLAG_IGNIDX))
        {
            const int nrOfIndexEntries = 
                mVideoStream->nb_index_entries;
            int countValidSize = 0;
            int countKeyFrame = 0;
            int indexPos = 0;
            while (indexPos < nrOfIndexEntries)
            {
                if (idx[indexPos].size > 0)
                {
                    countValidSize++;
                    if (idx[indexPos].flags & AVINDEX_KEYFRAME)
                        countKeyFrame++;
                }
                indexPos++;
            }
            ILOG_INFO("Stream contains an index which will be ignored; nr of entries is " << 
                nrOfIndexEntries << 
                ", of which " << countValidSize << " have size>0" <<
                ", of which " << countKeyFrame << " are marked as KEYFRAME");
        }

        // add blank frames to the index
        for (int i = 0; i < mBlankFrames; i++)
        {
            ILOG_DEBUG("AddIndex(" << i << ", -1, -1, " << DUMMY_FRAME_HASH << ")");
            AddIndex(i, -1, -1, DUMMY_FRAME_HASH);
        }

        PopulateMpegIndexBase();

        mIndexExists = true;
    }

    void 
    PopulateMpegIndexBase()
    {
        AVIndexEntry *idx = mVideoStream->index_entries;

        typedef Column::FixedStringColumn::ColElemType FixedString;

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

        // frame nr | seek position | recurrence | hash
        typedef Table::TableTem< Column::ColumnTem<Int32>,
                                 Column::ColumnTem<Real64>,
                                 Column::ColumnTem<Int32>,
                                 Column::FixedStringColumn > KeyFrameTable;

        // seek position (unique)
        typedef Table::TableTem< Column::ColumnTem<Real64> > SeekPositionTable;

        static const int HASH_SIZE = 32;

        FrameTable frameTable(Column::ColumnTem<Int32>(1000),
                              Column::ColumnTem<Int32>(1000),
                              Column::FixedStringColumn(HASH_SIZE, 1000));

        KeyFrameTable keyFrameTable(Column::ColumnTem<Int32>(1000),
                                    Column::ColumnTem<Real64>(1000),
                                    Column::ColumnTem<Int32>(1000),
                                    Column::FixedStringColumn(HASH_SIZE, 1000));

        SeekPositionTable seekPosTable(Column::ColumnTem<Real64>(1000));


        // list frames, key frames and candidate seek positions;
        // note that values of mCurrentFrameNr and mBufferedFrameNr follow from the search for leading bad frames ("blank frames")

        int64_t startPosOfBuffer = 0;
        int64_t lastEndPosOfBuffer = 0;

        String prevHash = "";
        int lastKeyFrameNr = -1;
        while (mCurrentFrameNr < mLastFrame)
        //while (mCurrentFrameNr < 500)
        {
#ifdef FFMPEG_52
            const int64_t& actualEndPosOfBuffer = mFormatCtx->pb->pos;
#else
            const int64_t& actualEndPosOfBuffer = mFormatCtx->pb.pos;
#endif
            if (actualEndPosOfBuffer < lastEndPosOfBuffer)
            {
                ILOG_ERROR("Unexpected buffer position change (from " <<
                    lastEndPosOfBuffer << " to " << actualEndPosOfBuffer << ")");
                return;
            }

            const bool bufferAdvanced = (actualEndPosOfBuffer > lastEndPosOfBuffer);
            if (bufferAdvanced)
            {
                startPosOfBuffer = lastEndPosOfBuffer;
                lastEndPosOfBuffer = actualEndPosOfBuffer;

                seekPosTable.Add(startPosOfBuffer);
            }

            // did reading a frame result in a valid frame?
            if  (mCurrentFrameNr > mBufferedFrameNr)
            {
                MarkBadFrame(mCurrentFrameNr);
                ILOG_DEBUG("Found a bad frame where mCurrentFrameNr = " << mCurrentFrameNr << " (and mBufferedFrameNr = " << mBufferedFrameNr << ")");
            }
            else
            {
                const String hash = CalcHash_protected();
                const FixedString hashAsFixedStr(HASH_SIZE, (char*) hash.c_str(), false);

                if (mFrame->pict_type == FF_I_TYPE) // I-frames only
                {
                    int recurrence = 1;
                    if (hash == prevHash) // (adjacent) duplicate frames/hashes
                    {
                        recurrence = 1 + keyFrameTable.Get3(keyFrameTable.Size() - 1);
                        //keyFrameTable.Set3(keyFrameTable.Size() - 1, recurrence + 1);
                    }
                    else
                    {
                        prevHash = hash;
                    }
                    const Int64 position = 0;
                    keyFrameTable.Add(mCurrentFrameNr, position, recurrence, hashAsFixedStr);
                    lastKeyFrameNr = mCurrentFrameNr;
                }
                else if (mFrame->pict_type != FF_P_TYPE &&
                    mFrame->pict_type != FF_B_TYPE)
                {
                    ILOG_ERROR("Unexpected picture type: " << mFrame->pict_type);
                    return;
                }

                frameTable.Add(mCurrentFrameNr, lastKeyFrameNr, hashAsFixedStr);
                ILOG_DEBUG("Added frame to frame table: " << mCurrentFrameNr << " : " << lastKeyFrameNr << " : " << hashAsFixedStr);
            }

            NextFrame();
        }


        keyFrameTable.Dump(0, 25);


        // match candidate jump positions to key frames:

        int keyFrameTableIndexMin = 0;
        int64_t topSafeSeekPos = 0;

        for (int seekPosTableIndex = 0; seekPosTableIndex < seekPosTable.Size(); seekPosTableIndex++)
        {
            const int64_t seekPos = seekPosTable.Get1(seekPosTableIndex);

            // reset (without using the index)
            const int posZero = 0;
            const int flush = 2;
            const int no_sync = 1;
            const int sync = 2;
            Jump(posZero, mJumpFlags, flush, (seekPos == posZero) ? sync : no_sync);
            ILOG_DEBUG("Jumped to head of file for seekPosTableIndex " << seekPosTableIndex);
            if (seekPos != posZero)
                Jump(seekPos, mJumpFlags, flush, sync);
            ILOG_DEBUG("Jumped to seekPos " << seekPos);

            Array2dVec3UInt8* arr = 
                new Array2dVec3UInt8(FrameWidth(), FrameHeight(), 0, 0,
                mData, true, false);
            const String hashOfKeyFrameJumpedTo = Array::MD5Hash(arr);
            delete arr;

            int k = keyFrameTableIndexMin;

            for (; k < keyFrameTable.Size(); k++)
            {
                const String hash(keyFrameTable.Get4(k).GetData(), HASH_SIZE);
                if (hash == hashOfKeyFrameJumpedTo)
                {
                    ILOG_DEBUG("Key frame " << k << " matches hash of first key frame found");
                    break;
                }

                keyFrameTable.Set2(k, topSafeSeekPos);
                keyFrameTableIndexMin++;
            }
            if (k >= keyFrameTable.Size())
            {
                ILOG_DEBUG("At end of key frame table; no matching key frame for seek pos jumped to");
                break; // ready
            }



            // A: how many remaining, consecutive key frame entries have this hash as well (and so are identical images)? 

            int recurrence = 0;
            k = keyFrameTableIndexMin + 1;
            for (; k < keyFrameTable.Size(); k++)
            {
                const String hash(keyFrameTable.Get4(k).GetData(), HASH_SIZE);
                if (hash != hashOfKeyFrameJumpedTo)
                    break;

                recurrence++;
            }


            // B: how many key frames can be read with this hash?

            mCurrentFrameNr = mBlankFrames; // mCurrentFrame is used by CalcHash_protected to check if current frame is valid
            int distanceToDifferentHash = 1; // in number of keyframes
            bool foundNextKeyFrame = false;
            while (true)
            {
                foundNextKeyFrame = FindNextDecodedFrame(true);
                if (!foundNextKeyFrame)
                    break;

                const String hash = CalcHash_protected();
                if (hash != hashOfKeyFrameJumpedTo) // what if at eof?
                    break;

                //for (int f = keyFrameTableIndexMin; f < keyFrameTable.Size(); f++)
                //    if (keyFrameTable.Get1(f) == // shit; wat 

                distanceToDifferentHash++;
            }



            // now resolve using A and B!

            int keyFramesWithOldSafePos = 0;
            if (distanceToDifferentHash <= recurrence)
            {
                keyFramesWithOldSafePos = (1 + recurrence) - distanceToDifferentHash;
                for (int kk = 0; kk < keyFramesWithOldSafePos; kk++)
                {
                    keyFrameTable.Set2(keyFrameTableIndexMin, topSafeSeekPos);
                    keyFrameTableIndexMin++;
                }
            }

            keyFrameTable.Set2(keyFrameTableIndexMin, seekPos);
            topSafeSeekPos = seekPos;


            if (!foundNextKeyFrame)
            {
                break; // assumed this only occurs at eof
            }
        }

        // frameTable aanpassen zodat alleen gewezen wordt naar key frames met een seek position
        int64_t lastProperSeekPos = -1;
        int frameIndex = 0;
        int keyFrameIndex = 0;
        int nextProperKeyFrameIndex = 0;
        while (keyFrameIndex < keyFrameTable.Size())
        {
            int seekFrameNr = keyFrameTable.Get1(keyFrameIndex);
            lastProperSeekPos = keyFrameTable.Get2(keyFrameIndex);
            nextProperKeyFrameIndex = keyFrameIndex;
            while (nextProperKeyFrameIndex < keyFrameTable.Size() && keyFrameTable.Get2(nextProperKeyFrameIndex) == lastProperSeekPos)
                nextProperKeyFrameIndex++;

            int nextProperSeekFrame = 1000000;
            if (nextProperKeyFrameIndex < keyFrameTable.Size())
            {
                nextProperSeekFrame = keyFrameTable.Get1(nextProperKeyFrameIndex);
            }

            while (frameIndex < frameTable.Size() && frameTable.Get2(frameIndex) < nextProperSeekFrame)
            {
                frameTable.Set2(frameIndex, seekFrameNr);
                frameIndex++;
            }

            keyFrameIndex = nextProperKeyFrameIndex;
        }


        // Add results to the index
        keyFrameIndex = 0;
        for (int i = 0; i < frameTable.Size(); i++)
        {
            const int frameNr = frameTable.Get1(i);
            const int keyFrameNr = frameTable.Get2(i);
            const String hash(frameTable.Get3(i).GetData(), HASH_SIZE);
            while (keyFrameTable.Get1(keyFrameIndex) < keyFrameNr)
                keyFrameIndex++;
            const int64_t seekPos = keyFrameTable.Get2(keyFrameIndex);
            ILOG_DEBUG("AddIndex(" << frameNr << ", " << keyFrameNr << ", " << seekPos << ", " << hash << ")");
            AddIndex(frameNr, keyFrameNr, seekPos, hash);
        }
    }

    void
    PopulateAviIndex()
    {
        ILOG_INFO("Timestamp Based Indexing for AVI started!");

        if (mBlankFrames > 0)
        {
            // for AVI lavc is not expected to actually try to read invalid frames 
            ILOG_ERROR("Did not expect blank frames to have been registered here");
            return;
        }

        const AVIndexEntry * const idx = mVideoStream->index_entries;
        if (!idx)
        {
            ILOG_ERROR("Stream contains no index");
            mFrameCnt = 0;
            mLastFrame = -1;
            return;
        }

        mFrameCnt = mVideoStream->nb_index_entries;
        mLastFrame = mFrameCnt - 1;
        ILOG_INFO("FrameCount from Index: " << mFrameCnt);

        for (int e = 0; e <= 20; e++)
            ILOG_DEBUG("index entry " << e << ": size=" << idx[e].size << ", flags=" << idx[e].flags << ", timestamp=" << idx[e].timestamp << ", pos=" << idx[e].pos << ", min_distance=" << idx[e].min_distance << ")"); 

        // add dummy index entries for all leading bad frames;
        // note that the currently cached frame is the first valid key-frame,
        // and that leading bad frames may already have been marked as such;
        int indexPos = 0;
        while (indexPos < mFrameCnt &&
            (idx[indexPos].size <= 0 ||  // assumed to indicate frame validity
            idx[indexPos].flags != AVINDEX_KEYFRAME))
        {
            MarkBadFrame(indexPos);
            AddIndex(indexPos, -1, -1, DUMMY_FRAME_HASH);
            ILOG_DEBUG(indexPos << " -1 -1 " << DUMMY_FRAME_HASH << " (idx[indexPos].size=" << idx[indexPos].size << ", idx[indexPos].flags=" << idx[indexPos].flags << ", idx[indexPos].timestamp=" << idx[indexPos].timestamp << ")");
            indexPos++;
        }

        if (indexPos > 0)
        {
            mBlankFrames = mBufferedFrameNr = mCurrentFrameNr = indexPos;
            ILOG_INFO("Stream starts with " << mBlankFrames << " bad frame(s)");
        }

        // reset in order to make jumping back to the head of file reproducable also for mpeg4 files;
        // (without using the index)
        const int posZero = 0;
        const int flush = 2;
        const int no_sync = 1;
        const int sync = 2;
        Jump(posZero, mJumpFlags, flush, no_sync);
        Jump(mBlankFrames, mJumpFlags, flush, sync);
        ILOG_DEBUG("Jumped to head of file");

        int lastKeyPos = -1;
        int64_t keyPts = -1;
        for (; indexPos < mFrameCnt; indexPos++)
        //for (; indexPos < 100; indexPos++)
        {
            if (idx[indexPos].size <= 0)
            {
                ILOG_INFO("Bad frame at index position: " << indexPos << " (idx[indexPos].size=" << idx[indexPos].size << ", idx[indexPos].flags=" << idx[indexPos].flags << ", idx[indexPos].timestamp=" << idx[indexPos].timestamp << ")");
                AddIndex(indexPos, -1, -1, DUMMY_FRAME_HASH);
                ILOG_DEBUG(indexPos << " -1 -1 " << DUMMY_FRAME_HASH);
                MarkBadFrame(indexPos);
                mCurrentFrameNr++;
                mBufferedFrameNr++;
                continue;
            }

            if (indexPos > mBlankFrames) // the first valid (key-) frame is currently in the frame cache
                NextFrame();

            String frameHash;
            if (FrameValid(mCurrentFrameNr))
            {
                if (idx[indexPos].flags == AVINDEX_KEYFRAME )
                {
                    lastKeyPos = indexPos;
                    keyPts = idx[lastKeyPos].timestamp;
                }
                frameHash = CalcHash_protected();
            }
            else
                frameHash = DUMMY_FRAME_HASH;

            AddIndex(indexPos, lastKeyPos, keyPts, frameHash);
            ILOG_DEBUG(indexPos << " " << lastKeyPos
                        << " " << keyPts << " " << frameHash);
        }

        mIndexExists = true;
    }

    // SK: Don't access the stream before actually using it:
    // for asf's we are not able to properly reset the stream once we
    // have accessed it. So the number of frames remains an estimate based upon
    // the file's meta-data.
    //
    // No attempt made to identify seek positions
    void 
    PopulateTrivialIndex()
    {
        const int firstValidFrameNr = FrameNr();
        while (FrameNr() < mLastFrame)
        //while (FrameNr() < 10)
        {
            const int frameNr = FrameNr();
            // did reading a frame result in a valid frame?
            if  (frameNr > mBufferedFrameNr)
            {
                MarkBadFrame(frameNr);
                ILOG_DEBUG("Found a bad frame where mCurrentFrameNr = " << 
                    frameNr << " (and mBufferedFrameNr = " << 
                    mBufferedFrameNr << ")");
                //AddIndex(frameNr, -1, -1, DUMMY_FRAME_HASH);
                //ILOG_DEBUG(frameNr<< " -1 -1 " << DUMMY_FRAME_HASH);
            }
            else
            {
                // hashes calculated appear not to be reproducable and are
                //   therefore useless.
                //const String frameHash = CalcHash_protected();
                //const String frameHash = "0123456789abcdef0123456789abcdef";
                //const FixedString hashAsFixedStr(HASH_SIZE, (char*) hash.c_str(), false);
                //AddIndex(frameNr, firstValidFrameNr, 0, frameHash);
                //ILOG_DEBUG(frameNr << " 0 0 " << frameHash);
            }

            NextFrame();
        }

        //mIndexExists = true;
    }

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

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

//SK
try
{
        if (mTargetFrameNr < mBufferedFrameNr)
        {
            //Jump(GetPos(0), AVSEEK_FLAG_BYTE, 2, 1);
            //mBufferedFrameNr = mBlankFrames;

            Reset(); 
        }

        if ((mIndexExists) && (mTargetFrameNr - mBufferedFrameNr > mGopSize))
        {
            int key = GetSeekableFrame(mTargetFrameNr);
            ILOG_DEBUG("Jumping to Keyframe " << key << " for " << mTargetFrameNr);
            JumpToKeyFrame(key);
        }

        //ILOG_DEBUG("[DoReadFrameData] Going from mBufferedFrameNr=" << mBufferedFrameNr << " to mTargetFrameNr=" << mTargetFrameNr);
        const int target = mTargetFrameNr;
        while (mCurrentFrameNr < target)
        {
            //bool isValidFrame = mIndexExists ? (mIndex->Get2(mBufferedFrameNr + 1) >= 0) : true;
            const int nextFrameNr = mCurrentFrameNr + 1;
            bool isValidFrame = FrameValid(nextFrameNr);
            if (nextFrameNr != mBufferedFrameNr && isValidFrame)
            {
                bool isKeyFrame; // not used
                const bool gotFrame = (DecodeNextFrame(isValidFrame, isKeyFrame) == 0);
                if (gotFrame)
                {
                    if (!isValidFrame)
                    {
                        ILOG_DEBUG("[DoReadFrameData] Frame read is invalid: " << 
                            nextFrameNr);
                        MarkBadFrame(nextFrameNr);
                    }
                    else
                        mBufferedFrameNr = nextFrameNr;
                }
                else 
                {
                    // SK: following code needs a new home! Use return code instead of void?
                    if (mLastFrame == LASTFRAME_UNKNOWN)
                    {
                        mLastFrame = mCurrentFrameNr;
                        ILOG_INFO("Adjusted last frame nr to: " << mLastFrame);
                    }
                    else
                    {
                        // for avi/pts
                        MarkBadFrame(nextFrameNr); 
                        mCurrentFrameNr = nextFrameNr;
                    }
                    return true; 
                }
            }
            mCurrentFrameNr = nextFrameNr;
        }

        if (mBufferedFrameNr == mCurrentFrameNr)
        {
            ConvertFrameToRgb();
            if (mFormatName != "asf") // SK: dirty debug fix
                CheckMD5Hash(mBufferedFrameNr);
        }
}
catch (LAVCException e)
{
    ILOG_ERROR("Failure when going to frame: " << mTargetFrameNr << "; " << e.what());
    return false;
}
//SK

        return true;
    }

    void
    CheckMD5Hash(int frameNr)
    {
        if (!mIndexExists)
            return;

        String refHash = GetHash(frameNr);
        //if (refHash == "") //If it's an avi file there is no hash check
        //{
        //    mIsFrameAccurate = true;
        //    return;
        //}

        //Array2dVec3UInt8* arr = new Array2dVec3UInt8(FrameWidth(),
        //                                             FrameHeight(), 0, 0,
        //                                             DataPtr(),true,false);
        //String hash = Array::MD5Hash(arr);
        //delete arr;
        String hash = CalcHash_protected();

        ILOG_DEBUG("[CheckMD5Hash] frameNr=" << frameNr << " hash_calculated=" << hash << " hash_found=" << refHash);

        mIsFrameAccurate = (hash==refHash);
        if (!mFixIndexIfBroken)
        {
            if (!mIsFrameAccurate)
            {
                ILOG_ERROR("Jumping to Frame("<<frameNr<<") ends in Frame("
                            <<GetFrameFromHash(hash)<<")");
                
            }
            return;
        }
   
        //if it's not frame accurate, we have to relocate our position
        if (!mIsFrameAccurate)
        {
            if (true)
            {
                ILOG_ERROR("SK: Index is not correct for video: " << mSrcName);
                throw LAVCException("Index is not correct", 0);
            }


            if (frameNr==mLastFixNr)
            {
                mFixCnt++;
                if (mFixCnt>10)
                {
                    String msg = "Cannot Fix video: " + mSrcName;
                    ILOG_ERROR(msg << "; try with src=LAVC_NOIDX");
                    throw LAVCException(msg, 0);
                }
            }
            else{
                mFixCnt=0;
                mLastFixNr=frameNr;
            }

            ILOG_WARN("Fixing Frame Accuracy for frame "<<frameNr
                    <<" (ended in "<<GetFrameFromHash(hash)<<")");

            //Find the broken key frame that we couldn't jump to 
            //and discard it from the index
            int BrokenKey = GetSeekableFrame(frameNr);
            
            int fNr = frameNr;
            int cNr = mBufferedFrameNr;
            
            while (--fNr)
            {
                ILOG_DEBUG("Checking for previous Non-Broken @ "<< fNr);

                if (fNr < 0)
                {
                    ILOG_ERROR("fNr is negative (" << fNr << ") and cannot be used as a column index");
                    return;
                }

                if ( (UInt32) fNr < mBlankFrames)
                {
                    ILOG_DEBUG("fNr (" << fNr << ") is less than mBlankFrames (" << mBlankFrames << ")");
                    return;
                }
                if (fNr==mBlankFrames)
                    break;

                if (GetSeekableFrame(fNr) != BrokenKey)
                    break;
            }

            ILOG_DEBUG("Found Previous Non-Broken frame " << fNr);
            
            int     PrevKey    = GetSeekableFrame(fNr);
            if (PrevKey < 0)
            {
                ILOG_ERROR("PrevKey has negative value: " << PrevKey);
                return;
            }
            int64_t PrevKeyPos = GetPos(fNr);
            ILOG_DEBUG("Previous Non-Broken for Keyframe " << PrevKey);
        
            fNr++;
            while (GetSeekableFrame(fNr)==BrokenKey)
            {
                ILOG_DEBUG("Resetting keyframe Information for  "<<fNr);
                SetKey(fNr,PrevKey);
                SetPos(fNr,PrevKeyPos);                
                fNr++;
            }
            ILOG_DEBUG("Retrying...");
            
            //Jump(GetPos(0), AVSEEK_FLAG_BYTE, 2, 2);
            //mBufferedFrameNr = mBlankFrames;
            Reset();
            ReadFrameData();
        }
        else
        {
            ILOG_DEBUG("Frame Accuracy OK for frame "<<frameNr);
        }
    }


    String DetermineInfoName(CString srcName, IndexMode mode, Util::Database* db)
    {
        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;
    }

    // Returns zero if successful, a negative value otherwise.
    int
    DecodeNextFrame(bool& isValidFrame, bool& isKeyFrame)
    {
        //avcodec_get_frame_defaults(mFrame);

        const int MAX_READ_FAILURES = Impala::Max(15, 5 * mGopSize);
        int nrOfReadFailures = 0;

        int atEndOfFile = 
#ifdef FFMPEG_52
        url_feof(mFormatCtx->pb);
#else
        url_feof(&mFormatCtx->pb);
#endif
        //if (atEndOfFile != 0)
        //    return -1;

        bool readFrameFailed = false;

        isValidFrame = false;
        isKeyFrame = false;
        int rc = 0;
        while (true)
        {
            int readFrameResult = av_read_frame(mFormatCtx, mPacket);
            readFrameFailed = (readFrameResult < 0);
            if (readFrameFailed)
            {
                // upon a negative value, there may still be 
                // valid frames left to decode
                ILOG_DEBUG("av_read_frame failed and returned: " << readFrameResult);
            }

            //ILOG_DEBUG("  video stream's curdts=" << mVideoStream->cur_dts << " mPacket->dts=" << mPacket->dts);
            //ILOG_DEBUG("  [DecodeNextFrame] mPacket->size=" << mPacket->size << "; mPacket->flags=" << mPacket->flags << "; bp.pos=" << mFormatCtx->pb.pos);

            if (mPacket->stream_index == mVideoStreamIndex) 
            {
                int frameDecoded = -1;

                //int len = avcodec_decode_video(mCodecCtx, mFrame, &frameDecoded,
                //                           mPacket->data, mPacket->size);

                // provide buffer padding cf. definition of avcodec_decode_video;
                // unsure if required here, but rather safe than sorry...
                const int bufSize = mPacket->size;
                uint8_t *buf = new uint8_t[bufSize + FF_INPUT_BUFFER_PADDING_SIZE];
                for (int i = 0; i < bufSize; i++)
                    buf[i] = (mPacket->data)[i];
                for (int i = 0; i < FF_INPUT_BUFFER_PADDING_SIZE; i++)
                    buf[bufSize + i] = 0;
                int len = avcodec_decode_video(mCodecCtx, mFrame, &frameDecoded,
                                           buf, bufSize);
                delete [] buf;

                ILOG_DEBUG("mPacket->pts =  " << mPacket->pts << " ; mPacket->dts =  " << mPacket->dts);
                if (len < 0)
                    ILOG_DEBUG("  avcodec_decode_video returned: " << len); // implies: frameDecoded==false

                if (frameDecoded)
                {
                    isValidFrame = true;
                    isKeyFrame = (mFrame->pict_type==FF_I_TYPE && mFrame->key_frame==1);
                    break;
                }
                else
                {
#ifdef FFMPEG_52
                    ILOG_DEBUG(
                        "  [DecodeNextFrame] Frame not valid; mPacket->size=" << 
                        mPacket->size << "; mPacket->flags=" << 
                        mPacket->flags << "; bp->pos=" << mFormatCtx->pb->pos);
#else
                    ILOG_DEBUG(
                        "  [DecodeNextFrame] Frame not valid; mPacket->size=" << 
                        mPacket->size << "; mPacket->flags=" << 
                        mPacket->flags << "; bp.pos=" << mFormatCtx->pb.pos);
#endif

                    // don't 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 (mPacket->flags == 0)
                        break;
                }
            }

            av_free_packet(mPacket);
 
            // while the read buffer already reached the eof, there may
            // still be some valid frames left to decode!
            nrOfReadFailures++;
            if ((atEndOfFile || readFrameFailed) && (nrOfReadFailures > MAX_READ_FAILURES))
            {
                ILOG_WARN("Max. nr of frame read failures reached (" <<
                    MAX_READ_FAILURES << "); probably at end of file");
                rc = -1;
                break;
            }
        }

        av_free_packet(mPacket);
        return rc;
    }

    // Convert the image from its native format to RGB
    void
    ConvertFrameToRgb()
    {
        const int result = sws_scale(mSwsContext, 
            mFrame->data, mFrame->linesize, 
            0, mFrameHeight, 
            mFrameRGB->data, mFrameRGB->linesize);
    }


    int              mVideoStreamIndex;
    AVStream*        mVideoStream;
    AVFormatContext* mFormatCtx;
    AVCodecContext*  mCodecCtx;
    struct SwsContext* mSwsContext;
    AVCodec*         mCodec;
    AVFrame*         mFrame;
    AVFrame*         mFrameRGB;
    AVPacket*        mPacket;
    
    int              mBufferedFrameNr;
    bool             mValid;
    uint32_t         mFrameCnt;
    uint32_t         mFrameCountCalculated; // based on mDuration
    IndexMode        mMode;
    bool             mFixIndexIfBroken;
    String           mJumpMethod;
    int              mJumpFlags;
    int              mLastFixNr;
    int              mFixCnt;

    ILOG_VAR_DECL;

}; //class

ILOG_VAR_INIT(RgbDataSrcLavc_old, Impala.Core.Stream);

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

#endif

---