mythavutil.h

Go to the documentation of this file.

//
//  mythavutil.h
//  MythTV
//
//  Created by Jean-Yves Avenard on 7/06/2014.
//  Copyright (c) 2014 Bubblestuff Pty Ltd. All rights reserved.
//

#ifndef MythTV_mythavutil_h
#define MythTV_mythavutil_h

#include "mythframe.h"
extern "C" {
#include "libavcodec/avcodec.h"
}

#include <QMap>
#include <QMutex>

struct AVFilterGraph;
struct AVFilterContext;
struct AVStream;
struct AVCodecContext;

class MythAVFrame
{
public:
    MythAVFrame(void)
    {
        m_frame = av_frame_alloc();
    }
    ~MythAVFrame(void)
    {
        av_frame_free(&m_frame);
    }
    bool operator !() const
    {
        return m_frame == nullptr;
    }
    AVFrame* operator->() const
    {
        return m_frame;
    }
    AVFrame& operator*() const
    {
        return *m_frame;
    }
    operator AVFrame*() const
    {
        return m_frame;
    }
    operator const AVFrame*() const
    {
        return m_frame;
    }

private:
    AVFrame *m_frame {nullptr};
};

class MTV_PUBLIC MythCodecMap
{
  public:
    MythCodecMap() = default;
    ~MythCodecMap();
    static MythCodecMap *getInstance();
    AVCodecContext *getCodecContext(const AVStream *stream,
        const AVCodec *pCodec = nullptr, bool nullCodec = false);
    AVCodecContext *hasCodecContext(const AVStream *stream);
    void freeCodecContext(const AVStream *stream);
    void freeAllCodecContexts();
  protected:
    QMap<const AVStream*, AVCodecContext*> m_streamMap;
    QMutex m_mapLock {QMutex::Recursive};
};

extern MTV_PUBLIC MythCodecMap *gCodecMap;


class MythAVCopyPrivate;

class MTV_PUBLIC MythAVCopy
{
public:
    explicit MythAVCopy(bool USWC=true);
    virtual ~MythAVCopy();
    MythAVCopy(const MythAVCopy &) = delete;            // not copyable
    MythAVCopy &operator=(const MythAVCopy &) = delete; // not copyable

    int Copy(VideoFrame *dst, const VideoFrame *src);
    int Copy(AVFrame *pic, const VideoFrame *frame,
             unsigned char *buffer = nullptr,
             AVPixelFormat fmt = AV_PIX_FMT_YUV420P);
    int Copy(VideoFrame *frame, const AVFrame *pic,
             AVPixelFormat fmt = AV_PIX_FMT_YUV420P);
    int Copy(AVFrame *dst, AVPixelFormat dst_pix_fmt,
             const AVFrame *src, AVPixelFormat pix_fmt,
             int width, int height);

private:
    static void FillFrame(VideoFrame *frame, const AVFrame *pic, int pitch,
                          int width, int height, AVPixelFormat pix_fmt);
    MythAVCopyPrivate *d {nullptr}; // NOLINT(readability-identifier-naming)
};

int MTV_PUBLIC AVPictureFill(AVFrame *pic, const VideoFrame *frame,
                             AVPixelFormat fmt = AV_PIX_FMT_NONE);

MTV_PUBLIC AVPixelFormat FrameTypeToPixelFormat(VideoFrameType type);
MTV_PUBLIC VideoFrameType PixelFormatToFrameType(AVPixelFormat fmt);

MTV_PUBLIC QString DeinterlacerName(MythDeintType Deint, bool DoubleRate, VideoFrameType Format = FMT_NONE);

MTV_PUBLIC QString DeinterlacerPref(MythDeintType Deint);

class MTV_PUBLIC MythPictureDeinterlacer
{
public:
    MythPictureDeinterlacer(AVPixelFormat pixfmt, int width, int height, float ar = 1.0F);
    ~MythPictureDeinterlacer();
    // Will deinterlace src into dst. If EAGAIN is returned, more frames
    // are needed to output a frame.
    // To drain the deinterlacer, call Deinterlace with src = nullptr until you
    // get no more frames. Once drained, you must call Flush() to start
    // deinterlacing again.
    int Deinterlace(AVFrame *dst, const AVFrame *src);
    int DeinterlaceSingle(AVFrame *dst, const AVFrame *src);
    // Flush and reset the deinterlacer.
    int Flush();
private:
    AVFilterGraph*      m_filterGraph   {nullptr};
    MythAVFrame         m_filterFrame;
    AVFilterContext*    m_bufferSinkCtx {nullptr};
    AVFilterContext*    m_bufferSrcCtx  {nullptr};
    AVPixelFormat       m_pixfmt        {AV_PIX_FMT_NONE};
    int                 m_width         {0};
    int                 m_height        {0};
    float               m_ar;
    bool                m_errored       {false};
};
#endif