FrameEnumerator

Author: niboshi

FrameEnumerator.cpp

@@ -0,0 +1,71 @@
+
+#include "FrameEnumerator.hpp"
+#include <cassert>
+#include <cstdio>
+
+FrameEnumerator::FrameEnumerator(MediaDecoder* mediaDecoder, AVStream* stream)
+    : mMediaDecoder(mediaDecoder),
+      mStream(stream),
+      mLastTimestamp(AV_NOPTS_VALUE),
+      mLastIndex(-1),
+      mFramePred(FramePredicate_KeyFrames)
+{
+    if (mStream->nb_index_entries < mStream->nb_frames) {
+        mMediaDecoder->seek(0);
+        AVPacket pkt;
+        while (true) {
+            int ret = mMediaDecoder->readPacket(&pkt);
+            av_free_packet(&pkt);
+            if (ret == AVERROR_EOF) { break; }
+            if (ret < 0) { break; }
+        }
+    }
+}
+
+bool
+FrameEnumerator::moveNext()
+{
+    assert(-1 <= mLastIndex);
+    if (mLastIndex >= 0 &&
+        (mStream->nb_index_entries <= mLastIndex || mStream->index_entries[mLastIndex].timestamp != mLastTimestamp)) {
+        // The index has changed.
+        // It seems that something to handle this situation should be implemented.
+        assert(false);
+    }
+        
+    AVIndexEntry* entries = mStream->index_entries;
+    int nIndexEntries = mStream->nb_index_entries;
+    for (mLastIndex++; mLastIndex < nIndexEntries; ++mLastIndex) {
+        AVIndexEntry* ent = &entries[mLastIndex];
+        if (this->mFramePred(ent)) {
+            mLastTimestamp = ent->timestamp;
+            return true;
+        }
+    }
+    
+    mLastIndex = nIndexEntries;
+    mLastTimestamp = AV_NOPTS_VALUE;
+    return false;
+}
+
+void
+FrameEnumerator::reset()
+{
+    mLastIndex = -1;
+    mLastTimestamp = AV_NOPTS_VALUE;
+    av_seek_frame(mMediaDecoder->getFormatContext(), -1, 0, 0);
+}
+
+int
+FrameEnumerator::seek()
+{
+    if (mLastIndex < 0) { return -1; }
+    return mMediaDecoder->seekToIndex(mStream->index, mLastIndex);
+}
+
+bool
+FrameEnumerator::FramePredicate_KeyFrames(const AVIndexEntry* indexEntry)
+{
+    return 0 != (indexEntry->flags & AVINDEX_KEYFRAME);
+}
+

FrameEnumerator.hpp

@@ -0,0 +1,34 @@
+#ifndef FRAME_ENUMERATOR_H_
+#define FRAME_ENUMERATOR_H_
+
+#include "MediaDecoder.hpp"
+#include "libav.hpp"
+#include <iterator>
+
+class FrameEnumerator
+{
+public:
+    typedef bool(*FramePredicate)(const AVIndexEntry*);
+    
+private:
+    MediaDecoder*       mMediaDecoder;
+    AVStream*           mStream;
+    int64_t             mLastTimestamp;
+    int                 mLastIndex;
+    
+    FramePredicate      mFramePred;
+
+public:
+    FrameEnumerator(MediaDecoder* mediaDecoder, AVStream* stream);
+    bool moveNext();
+    int64_t timestamp() const { return mLastTimestamp; }
+    int index() const { return mLastIndex; }
+    void reset();
+
+    int seek();
+
+private:
+    static bool FramePredicate_KeyFrames(const AVIndexEntry* indexEntry);
+};
+
+#endif

MediaDecoder.cpp

@@ -1,5 +1,7 @@
 #include "MediaDecoder.hpp"
 
+#include <cassert>
+
 void
 MediaDecoder::initFfmpeg()
 {
@@ -68,18 +70,18 @@ MediaDecoder::openFile(const char* filename)
 	for (int i = 0; i < streamCount; ++i) {
 		if (0 > (intRet = this->prepareStream(i))) {
 			this->outputMessage(0, "prepareStream() failed: ret=%d", intRet);
-			return intRet;
 		}
 		if (mFirstVideoStreamIndex == -1 && mFormatContext->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 			mFirstVideoStreamIndex = i;
 		}
 	}
 
-	if (mFirstVideoStreamIndex != -1) {
-		AVCodecContext* codecContext = mFormatContext->streams[mFirstVideoStreamIndex]->codec;
-		this->setScaleParameters(codecContext->width, codecContext->height, PIX_FMT_RGB32, Stride_4bytes);
-	}
-	
+    if (mFirstVideoStreamIndex != -1) {
+        this->outputMessage(0, "Video stream is %d", mFirstVideoStreamIndex);
+        AVCodecContext* codecContext = mFormatContext->streams[mFirstVideoStreamIndex]->codec;
+        this->setScaleParameters(codecContext->width, codecContext->height, PIX_FMT_RGB32, Stride_4bytes);
+    }
+    
 	return 0;
 }
 
@@ -117,6 +119,7 @@ MediaDecoder::setScaleParameters(int width, int height, PixelFormat pixelFormat,
 //		SWS_BILINEAR,
 		SWS_FAST_BILINEAR,
 		NULL, NULL, NULL);
+    
 	if (!mSwsContext) {
         this->outputMessage(0, "sws_getContext failed.");
         return -1;
@@ -147,32 +150,32 @@ MediaDecoder::setScaleParameters(int width, int height, PixelFormat pixelFormat,
     return 0;
 }
 
+int
+MediaDecoder::seek(int streamIndex, int64_t timestamp)
+{
+    return av_seek_frame(mFormatContext, streamIndex, timestamp, 0);
+}
+
 int
 MediaDecoder::seek(double timestamp)
 {
-    int intRet;
-    int streamCount = this->getStreamCount();
-    int failCount = 0;
-    for (int i = 0; i < streamCount; ++i) {
-        double timeBase = av_q2d(mFormatContext->streams[i]->time_base);
-        int64_t ts = static_cast<int64_t>(timestamp / timeBase);
-        intRet = av_seek_frame(mFormatContext, i, ts, 0);
-        if (0 > intRet) {
-            failCount ++;
-        }
-    }
-	return failCount;
+    return this->seek(-1, static_cast<uint64_t>(timestamp * AV_TIME_BASE));
 }
 
 int
 MediaDecoder::seekToIndex(int streamIndex, int index) {
     AVStream* stream = this->getStream(streamIndex);
-    if (!stream) { return -1; }
+    if (!stream) {
+        this->outputMessage(0, "Stream index %d not found.", streamIndex);
+        return -1; }
 
     AVIndexEntry* entries = stream->index_entries;
-    if (!entries) { return -1; }
+    if (!entries) {
+        this->outputMessage(0, "Tried to seek by index, but there is no index entries.");
+        return -1; }
 
-    if (0 < index || index <= stream->nb_index_entries) {
+    if (index < 0 || stream->nb_index_entries <= index) {
+        this->outputMessage(0, "Index out of bound: %d / %d", index, stream->nb_index_entries);
         return -1;
     }
 
@@ -234,6 +237,10 @@ MediaDecoder::decodeVideoFrame(AVPacket* packet, AVFrame* outFrame, double* outT
 int
 MediaDecoder::scaleVideoFrame(AVFrame* frame, uint8_t* buffer, int bufferSize)
 {
+    if (!mSwsContext) {
+        this->outputMessage(0, "sws context is not initialized.");
+        return -1; }
+    
     int      intRet;
     uint8_t* data[]     = { (uint8_t*)buffer, NULL, NULL, NULL };
     int      lineSize[] = { mScaleStride, 0, 0, 0 };
@@ -279,7 +286,6 @@ MediaDecoder::decodeVideo(AVPacket* packet, uint8_t* buffer, int bufferSize, dou
         goto CLEANUP;
     }
 
-
     // scale and transform
     intRet = this->scaleVideoFrame(mFrame, buffer, bufferSize);
     if (intRet < 0) {
@@ -343,9 +349,9 @@ MediaDecoder::prepareStream(int streamIndex)
 	AVStream*		stream			= mFormatContext->streams[streamIndex];
 	AVCodecContext*	codecContext	= stream->codec;
 	AVCodec*		codec			= avcodec_find_decoder(codecContext->codec_id);
-	
+
 	if (!codec) {
-		this->outputMessage(0, "Failed to find decoder: codec_id=%d", codecContext->codec_id);
+		this->outputMessage(0, "Failed to find decoder: streamIndex=%d codecId=%d codecType=%d", streamIndex, codecContext->codec_id, codecContext->codec_type);
 		return -1;
 	}
 

MediaDecoder.hpp

@@ -1,17 +1,7 @@
 #ifndef MEDIA_DECODER_H_
 #define MEDIA_DECODER_H_
 
-#ifndef __STDC_CONSTANT_MACROS
-#define __STDC_CONSTANT_MACROS
-#endif
-
-extern "C" {
-#include <libavutil/avutil.h>
-#include <libavformat/avformat.h>
-#include <libavcodec/avcodec.h>
-#include <libswscale/swscale.h>
-}
-
+#include "libav.hpp"
 
 typedef enum {
     Stride_Tight,
@@ -82,6 +72,7 @@ class MediaDecoder
 
     // decode
     int seek(double timestamp);
+    int seek(int streamIndex, int64_t timestamp);
     int seekToIndex(int streamIndex, int index);
     int decodeAudio(AVPacket* packet, uint8_t* buffer, int bufferSize, double* outTimestamp, int* outDataSize);
     int decodeVideo(AVPacket* packet, uint8_t* buffer, int bufferSize, double thresholdTimestamp, double* outTimestamp, int* outDataSize, bool* outSkipped);

libav.hpp

@@ -0,0 +1,10 @@
+#ifndef __STDC_CONSTANT_MACROS
+#define __STDC_CONSTANT_MACROS
+#endif
+
+extern "C" {
+#include <libavutil/avutil.h>
+#include <libavformat/avformat.h>
+#include <libavcodec/avcodec.h>
+#include <libswscale/swscale.h>
+}