SkVideoDecoder Class Reference

#include <SkVideoDecoder.h>

Public Member Functions
	SkVideoDecoder (GrRecordingContext *=nullptr)
	~SkVideoDecoder ()
void	reset ()
void	setGrContext (GrRecordingContext *rContext)
bool	loadStream (std::unique_ptr< SkStream >)
bool	rewind ()
SkISize	dimensions () const
double	duration () const
sk_sp< SkImage >	nextImage (double *timeStamp=nullptr)

Detailed Description

Definition at line 23 of file SkVideoDecoder.h.

Constructor & Destructor Documentation

SkVideoDecoder()

SkVideoDecoder::SkVideoDecoder

(

GrRecordingContext *

rContext = nullptr

)

Definition at line 314 of file SkVideoDecoder.cpp.

: fRecordingContext(rContext) {}

~SkVideoDecoder()

SkVideoDecoder::~SkVideoDecoder

(

)

Definition at line 316 of file SkVideoDecoder.cpp.

                                {
    this->reset();
}

Member Function Documentation

dimensions()

SkISize SkVideoDecoder::dimensions

(

)

const

Definition at line 412 of file SkVideoDecoder.cpp.

                                         {
    if (!fFormatCtx) {
        return {0, 0};
    }
 
    AVStream* strm = fFormatCtx->streams[fStreamIndex];
    return {strm->codecpar->width, strm->codecpar->height};
}

duration()

double SkVideoDecoder::duration

(

)

const

Definition at line 421 of file SkVideoDecoder.cpp.

                                      {
    if (!fFormatCtx) {
        return 0;
    }
 
    AVStream* strm = fFormatCtx->streams[fStreamIndex];
    AVRational base = strm->time_base;
    return 1.0 * strm->duration * base.num / base.den;
}

loadStream()

bool SkVideoDecoder::loadStream

(

std::unique_ptr< SkStream >

stream

)

Definition at line 344 of file SkVideoDecoder.cpp.

                                                              {
    this->reset();
    if (!stream) {
        return false;
    }
 
    int bufferSize = 4 * 1024;
    uint8_t* buffer = (uint8_t*)av_malloc(bufferSize);
    if (!buffer) {
        return false;
    }
 
    fStream = std::move(stream);
    fStreamCtx = avio_alloc_context(buffer, bufferSize, 0, fStream.get(),
                                    skstream_read_packet, nullptr, skstream_seek_packet);
    if (!fStreamCtx) {
        av_freep(buffer);
        this->reset();
        return false;
    }
 
    fFormatCtx = avformat_alloc_context();
    if (!fFormatCtx) {
        this->reset();
        return false;
    }
    fFormatCtx->pb = fStreamCtx;
 
    int err = avformat_open_input(&fFormatCtx, nullptr, nullptr, nullptr);
    if (err < 0) {
        SkDebugf("avformat_open_input failed %d\n", err);
        return false;
    }
 
    const AVCodec* codec;
    fStreamIndex = av_find_best_stream(fFormatCtx, AVMEDIA_TYPE_VIDEO, -1, -1, &codec, 0);
    if (fStreamIndex < 0) {
        SkDebugf("av_find_best_stream failed %d\n", fStreamIndex);
        this->reset();
        return false;
    }
 
    SkASSERT(codec);
    fDecoderCtx = avcodec_alloc_context3(codec);
 
    AVStream* strm = fFormatCtx->streams[fStreamIndex];
    if ((err = avcodec_parameters_to_context(fDecoderCtx, strm->codecpar)) < 0) {
        SkDebugf("avcodec_parameters_to_context failed %d\n", err);
        this->reset();
        return false;
    }
 
    if ((err = avcodec_open2(fDecoderCtx, codec, nullptr)) < 0) {
        SkDebugf("avcodec_open2 failed %d\n", err);
        this->reset();
        return false;
    }
 
    fFrame = av_frame_alloc();
    SkASSERT(fFrame);
 
    av_init_packet(&fPacket);   // is there a "free" call?
 
    fMode = kProcessing_Mode;
 
    return true;
}

nextImage()

sk_sp< SkImage > SkVideoDecoder::nextImage

(

double *

timeStamp = nullptr

)

Definition at line 260 of file SkVideoDecoder.cpp.

                                                          {
    double defaultTimeStampStorage = 0;
    if (!timeStamp) {
        timeStamp = &defaultTimeStampStorage;
    }
 
    if (fFormatCtx == nullptr) {
        return nullptr;
    }
 
    if (fMode == kProcessing_Mode) {
        // We sit in a loop, waiting for the codec to have received enough data (packets)
        // to have at least one frame available.
        // Treat non-zero return as EOF (or error, which we will decide is also EOF)
        while (!av_read_frame(fFormatCtx, &fPacket)) {
            if (fPacket.stream_index != fStreamIndex) {
                // got a packet for a stream other than our (video) stream, so continue
                continue;
            }
 
            int ret = avcodec_send_packet(fDecoderCtx, &fPacket);
            if (ret == AVERROR(EAGAIN)) {
                // may signal that we have plenty already, encouraging us to call receive_frame
                // so we don't treat this as an error.
                ret = 0;
            }
            (void)check_err(ret);   // we try to continue if there was an error
 
            int silentList[] = {
                -35,    // Resource temporarily unavailable (need more packets)
                0,
            };
            if (check_err(avcodec_receive_frame(fDecoderCtx, fFrame), silentList)) {
                // this may be just "needs more input", so we try to continue
            } else {
                *timeStamp = this->computeTimeStamp(fFrame);
                return this->convertFrame(fFrame);
            }
        }
 
        fMode = kDraining_Mode;
        (void)avcodec_send_packet(fDecoderCtx, nullptr);    // signal to start draining
    }
    if (fMode == kDraining_Mode) {
        if (avcodec_receive_frame(fDecoderCtx, fFrame) >= 0) {
            *timeStamp = this->computeTimeStamp(fFrame);
            return this->convertFrame(fFrame);
        }
        // else we decide we're done
        fMode = kDone_Mode;
    }
    return nullptr;
}

reset()

void SkVideoDecoder::reset

(

)

Definition at line 320 of file SkVideoDecoder.cpp.

                           {
    if (fFrame) {
        av_frame_free(&fFrame);
        fFrame = nullptr;
    }
    if (fDecoderCtx) {
        avcodec_free_context(&fDecoderCtx);
        fDecoderCtx = nullptr;
    }
    if (fFormatCtx) {
        avformat_close_input(&fFormatCtx);
        fFormatCtx = nullptr;
    }
    if (fStreamCtx) {
        av_freep(&fStreamCtx->buffer);
        avio_context_free(&fStreamCtx);
        fStreamCtx = nullptr;
    }
 
    fStream.reset(nullptr);
    fStreamIndex = -1;
    fMode = kDone_Mode;
}

rewind()

bool SkVideoDecoder::rewind

(

)

Definition at line 431 of file SkVideoDecoder.cpp.

                            {
    auto stream = std::move(fStream);
    this->reset();
    if (stream) {
        stream->rewind();
    }
    return this->loadStream(std::move(stream));
}

setGrContext()

void SkVideoDecoder::setGrContext ( GrRecordingContext *  rContext )

inline

Definition at line 29 of file SkVideoDecoder.h.

{ fRecordingContext = rContext; }

---

The documentation for this class was generated from the following files:

• third_party/skia/experimental/ffmpeg/SkVideoDecoder.h
• third_party/skia/experimental/ffmpeg/SkVideoDecoder.cpp