decoder.h

Go to the documentation of this file.

#ifndef decoder_HEADER_GUARD
#define decoder_HEADER_GUARD
/*
 * decoder.h : FFmpeg decoders
 * 
 * (c) Copyright 2017-2024 Sampsa Riikonen
 * 
 * Authors: Sampsa Riikonen <sampsa.riikonen@iki.fi>
 * 
 * This file is part of the Valkka library.
 * 
 * Valkka is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>
 *
 */
 
#include "frame.h"
#include <random>
 
// #define DECODE_VERBOSE
 
// AVThread has std::vector<Decoder*> decoders
// decoders[1]->output() returns reference to Decoder::out_frame
// (VideoDecoder*)(..) returns reference to VideoDecoder::out_frame, right? (Decoder::out_frame) is hidden
//
// decoders[1] .. is a VideoDecoder.. but decoders has been declared as a vector Decoder
// Decoder* decoder = VideoDecoder()
// .. so, decoder->getWhatever, where getWhatever is virtual method, will always give the correct object
// but decoder->out_frame returns frame that depends on the cast
 
// VideoDecoder->output() returns
 
class Decoder
{
 
public:
    Decoder();          
    virtual ~Decoder(); 
 
protected:
    BasicFrame in_frame; 
    bool has_frame;
 
public:
    void input(Frame *f);        
    long int getMsTimestamp();   
    virtual Frame *output() = 0; 
    virtual void releaseOutput();     
    virtual void flush() = 0;    
    virtual bool pull() = 0;     
    virtual bool isOk();         
    bool hasFrame();
};
 
class DummyDecoder : public Decoder
{
 
private:
    BasicFrame out_frame; 
 
public:
    virtual Frame *output(); 
    virtual void flush();
    virtual bool pull();
};
 
class AVDecoder : public Decoder
{
 
public:
    AVDecoder(AVCodecID av_codec_id, int n_threads = 1);
    virtual ~AVDecoder();
 
protected:
    int n_threads;
 
public:
    AVCodecID av_codec_id;            
    AVPacket *av_packet;              
    AVCodecContext *av_codec_context; 
    AVCodec *av_codec;                
 
public:
    // needs virtual void output, virtual void pull
    virtual void flush();
};
 
class VideoDecoder : public AVDecoder
{
 
public:
    VideoDecoder(AVCodecID av_codec_id, int n_threads = 1); 
    virtual ~VideoDecoder();                                
 
protected:
    AVBitmapFrame out_frame;
    int width;
    int height;
    AVFrame *aux_av_frame;
    AVPixelFormat current_pixel_format;
    SwsContext *sws_ctx;
    float secs_per_frame;
 
public:
    virtual Frame *output(); 
    virtual bool pull();
 
    /*
private: // for simulating decoder slow down
  std::random_device rd;  //Will be used to obtain a seed for the random number engine
  std::mt19937       gen; //Standard mersenne_twister_engine seeded with rd()
  std::uniform_int_distribution<> dis;
*/
};
 
#endif