Zac

bool VideoEncodeInternal::SetupFilters(bool bFlipH, bool bFlipV,
                       bool bCrop, int nCropX, int nCropY, int nCropWidth, int nCropHeight,
                       bool bScale, int nScaleWidth, int nScaleHeight,
                       bool bCropFirst)
{
    //Check that VideoEncodeInternal has been initialised
    if (!m_bInitialised)
        return false;

    //Check that VideoStream & CodecContext have been created
    if (!m_pVideoStream)
        return false;
    if (!m_pVideoStream->codec)
        return false;

    AVCodecContext* pCodecContext = m_pVideoStream->codec;
    int nReturn = 0;

    //Setup Filter Graph
    if (m_pFilterGraph)
        return false;

    m_pFilterGraph = avfilter_graph_alloc();
    if (!m_pFilterGraph)
        return false;

    //Setup Filter Input (buffer)
    char szBufferArgs[255];

    AVRational sample_aspect_ratio;
    sample_aspect_ratio.num = 1;
    sample_aspect_ratio.den = 1;

    sprintf_s(szBufferArgs, 255,
              "%d:%d:%d:%d:%d:%d:%d",
              m_nWidth,
              m_nHeight,
              PIX_FMT_YUV420P,
              1, AV_TIME_BASE,
              sample_aspect_ratio.num, sample_aspect_ratio.den);

    nReturn = avfilter_graph_create_filter(&m_pInputFilter, avfilter_get_by_name("buffer"),
                           "src", szBufferArgs, NULL, m_pFilterGraph);
    if (nReturn < 0)
        return false;

    //Setup Filter Output (buffersink)
    enum PixelFormat pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };
    AVBufferSinkParams* buffersink_params = av_buffersink_params_alloc();

    buffersink_params->pixel_fmts = pix_fmts;
    nReturn = avfilter_graph_create_filter(&m_pOutputFilter, avfilter_get_by_name("buffersink"),
                           "out", NULL, buffersink_params, m_pFilterGraph);

    av_freep(&buffersink_params);
    if (nReturn < 0)
        return false;

    //Setup sws_scale flags
    if (m_pSwsContext)
    {
        int64_t sws_flags = 0;
        char szSwsScaleArgs[64];
        memset(szSwsScaleArgs, 0, 64);
        av_opt_get_int(m_pSwsContext, "sws_flags", 0, &sws_flags);
        sprintf_s(szSwsScaleArgs, 64, "flags=0x%X", (unsigned)sws_flags);
        m_pFilterGraph->scale_sws_opts = av_strdup(szSwsScaleArgs);
    }


    AVFilterInOut *outputs = avfilter_inout_alloc();
    AVFilterInOut *inputs  = avfilter_inout_alloc();

    outputs->name    = av_strdup("in");
    outputs->filter_ctx = m_pInputFilter;//last_filter;
    outputs->pad_idx = 0;
    outputs->next    = NULL;

    inputs->name    = av_strdup("out");
    inputs->filter_ctx = m_pOutputFilter;
    inputs->pad_idx = 0;
    inputs->next    = NULL;

    if ((nReturn = avfilter_graph_parse(m_pFilterGraph, "hflip", &inputs, &outputs, NULL)) < 0)
        return false;

    fflush(stderr);

    if ((nReturn = avfilter_graph_config(m_pFilterGraph, NULL)) < 0)
    {
        char szError[255];
        av_strerror(nReturn, szError, 255);
        printf(szError);
        return false;
    }

    pCodecContext->width  = m_pOutputFilter->inputs[0]->w;
    pCodecContext->height = m_pOutputFilter->inputs[0]->h;
    pCodecContext->sample_aspect_ratio = m_pOutputFilter->inputs[0]->sample_aspect_ratio;

    return true;
}