ffmpeg4_modifications.diff

diff --git a/configure b/configure
index 06e3a7b..9f548b3 100755
--- a/configure
+++ b/configure
@@ -266,6 +266,7 @@ External library support:
   --enable-libspeex        enable Speex de/encoding via libspeex [no]
   --enable-libsrt          enable Haivision SRT protocol via libsrt [no]
   --enable-libssh          enable SFTP protocol via libssh [no]
+  --enable-libsvtav1       enable AV1 encoding via svt [no]
   --enable-libtensorflow   enable TensorFlow as a DNN module backend
                            for DNN based filters like sr [no]
   --enable-libtesseract    enable Tesseract, needed for ocr filter [no]
@@ -1799,6 +1800,7 @@ EXTERNAL_LIBRARY_LIST="
     libspeex
     libsrt
     libssh
+    libsvtav1
     libtensorflow
     libtesseract
     libtheora
@@ -3224,6 +3226,7 @@ libshine_encoder_select="audio_frame_queue"
 libspeex_decoder_deps="libspeex"
 libspeex_encoder_deps="libspeex"
 libspeex_encoder_select="audio_frame_queue"
+libsvt_av1_encoder_deps="libsvtav1"
 libtheora_encoder_deps="libtheora"
 libtwolame_encoder_deps="libtwolame"
 libvo_amrwbenc_encoder_deps="libvo_amrwbenc"
@@ -3530,6 +3533,8 @@ nnedi_filter_deps="gpl"
 ocr_filter_deps="libtesseract"
 ocv_filter_deps="libopencv"
 openclsrc_filter_deps="opencl"
+phqm_filter_deps="libopencv"
+phqm_filter_extralibs="-lstdc++ -lopencv_img_hash"
 overlay_opencl_filter_deps="opencl"
 overlay_qsv_filter_deps="libmfx"
 overlay_qsv_filter_select="qsvvpp"
@@ -6329,6 +6334,7 @@ enabled libsoxr           && require libsoxr soxr.h soxr_create -lsoxr
 enabled libssh            && require_pkg_config libssh libssh libssh/sftp.h sftp_init
 enabled libspeex          && require_pkg_config libspeex speex speex/speex.h speex_decoder_init
 enabled libsrt            && require_pkg_config libsrt "srt >= 1.3.0" srt/srt.h srt_socket
+enabled libsvtav1         && require_pkg_config libsvtav1 SvtAv1Enc EbSvtAv1Enc.h svt_av1_enc_init_handle
 enabled libtensorflow     && require libtensorflow tensorflow/c/c_api.h TF_Version -ltensorflow
 enabled libtesseract      && require_pkg_config libtesseract tesseract tesseract/capi.h TessBaseAPICreate
 enabled libtheora         && require libtheora theora/theoraenc.h th_info_init -ltheoraenc -ltheoradec -logg
diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 0fd374f..d362a83 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -1005,6 +1005,7 @@ OBJS-$(CONFIG_LIBRAV1E_ENCODER)           += librav1e.o
 OBJS-$(CONFIG_LIBSHINE_ENCODER)           += libshine.o
 OBJS-$(CONFIG_LIBSPEEX_DECODER)           += libspeexdec.o
 OBJS-$(CONFIG_LIBSPEEX_ENCODER)           += libspeexenc.o
+OBJS-$(CONFIG_LIBSVT_AV1_ENCODER)         += libsvt_av1.o
 OBJS-$(CONFIG_LIBTHEORA_ENCODER)          += libtheoraenc.o
 OBJS-$(CONFIG_LIBTWOLAME_ENCODER)         += libtwolame.o
 OBJS-$(CONFIG_LIBVO_AMRWBENC_ENCODER)     += libvo-amrwbenc.o
diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
index f4cf180..5ff2e60 100644
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -717,6 +717,7 @@ extern AVCodec ff_librsvg_decoder;
 extern AVCodec ff_libshine_encoder;
 extern AVCodec ff_libspeex_encoder;
 extern AVCodec ff_libspeex_decoder;
+extern AVCodec ff_libsvt_av1_encoder;
 extern AVCodec ff_libtheora_encoder;
 extern AVCodec ff_libtwolame_encoder;
 extern AVCodec ff_libvo_amrwbenc_encoder;
diff --git a/libavcodec/libsvt_av1.c b/libavcodec/libsvt_av1.c
new file mode 100644
index 0000000..5f1d8e0
--- /dev/null
+++ b/libavcodec/libsvt_av1.c
@@ -0,0 +1,548 @@
+/*
+* Scalable Video Technology for AV1 encoder library plugin
+*
+* Copyright (c) 2018 Intel Corporation
+*
+* This file is part of FFmpeg.
+*
+* FFmpeg 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 2.1 of the License, or (at your option) any later version.
+*
+* FFmpeg 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, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#include <stdint.h>
+#include "EbSvtAv1ErrorCodes.h"
+#include "EbSvtAv1Enc.h"
+
+#include "libavutil/common.h"
+#include "libavutil/frame.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/avassert.h"
+
+#include "internal.h"
+#include "avcodec.h"
+
+typedef enum eos_status {
+    EOS_NOT_REACHED = 0,
+    EOS_SENT,
+    EOS_RECEIVED
+}EOS_STATUS;
+
+typedef struct SvtContext {
+    AVClass     *class;
+
+    EbSvtAv1EncConfiguration    enc_params;
+    EbComponentType            *svt_handle;
+
+    EbBufferHeaderType         *in_buf;
+    int                         raw_size;
+    int                         max_tu_size;
+
+    AVBufferPool* pool;
+
+    EOS_STATUS eos_flag;
+
+    // User options.
+    int hierarchical_level;
+    int la_depth;
+    int enc_mode;
+    int rc_mode;
+    int scd;
+    int qp;
+
+    int forced_idr;
+
+    int tier;
+    int level;
+    int profile;
+
+
+} SvtContext;
+
+static const struct {
+    EbErrorType    eb_err;
+    int            av_err;
+    const char     *desc;
+} svt_errors[] = {
+    { EB_ErrorNone,                             0,              "success"                   },
+    { EB_ErrorInsufficientResources,      AVERROR(ENOMEM),      "insufficient resources"    },
+    { EB_ErrorUndefined,                  AVERROR(EINVAL),      "undefined error"           },
+    { EB_ErrorInvalidComponent,           AVERROR(EINVAL),      "invalid component"         },
+    { EB_ErrorBadParameter,               AVERROR(EINVAL),      "bad parameter"             },
+    { EB_ErrorDestroyThreadFailed,        AVERROR_EXTERNAL,     "failed to destory thread"  },
+    { EB_ErrorSemaphoreUnresponsive,      AVERROR_EXTERNAL,     "semaphore unresponsive"    },
+    { EB_ErrorDestroySemaphoreFailed,     AVERROR_EXTERNAL,     "semaphore unresponsive"    },
+    { EB_ErrorCreateMutexFailed,          AVERROR_EXTERNAL,     "failed to creat mutex"     },
+    { EB_ErrorMutexUnresponsive,          AVERROR_EXTERNAL,     "mutex unresponsive"        },
+    { EB_ErrorDestroyMutexFailed,         AVERROR_EXTERNAL,     "failed to destory muxtex"  },
+    { EB_NoErrorEmptyQueue,               AVERROR(EAGAIN),      "empty queue"               },
+};
+
+static int svt_map_error(EbErrorType eb_err, const char **desc)
+{
+    int i;
+
+    av_assert0(desc);
+    for (i = 0; i < FF_ARRAY_ELEMS(svt_errors); i++) {
+        if (svt_errors[i].eb_err == eb_err) {
+            *desc = svt_errors[i].desc;
+            return svt_errors[i].av_err;
+        }
+    }
+    *desc = "unknown error";
+    return AVERROR_UNKNOWN;
+}
+
+static int svt_print_error(void *log_ctx, EbErrorType err,
+                           const char *error_string)
+{
+    const char *desc;
+    int ret;
+    ret = svt_map_error(err, &desc);
+    av_log(log_ctx, AV_LOG_ERROR, "%s: %s (0x%x)\n", error_string, desc, err);
+    return ret;
+}
+
+static void free_buffer(SvtContext *svt_enc)
+{
+    if (svt_enc->in_buf) {
+        EbSvtIOFormat *in_data = (EbSvtIOFormat *)svt_enc->in_buf->p_buffer;
+        av_freep(&in_data);
+        av_freep(&svt_enc->in_buf);
+    }
+    av_buffer_pool_uninit(&svt_enc->pool);
+}
+
+static int alloc_buffer(EbSvtAv1EncConfiguration *config, SvtContext *svt_enc)
+{
+    const int    pack_mode_10bit   =
+        (config->encoder_bit_depth > 8) && (config->compressed_ten_bit_format == 0) ? 1 : 0;
+    const size_t luma_size_8bit    =
+        config->source_width * config->source_height * (1 << pack_mode_10bit);
+    const size_t luma_size_10bit   =
+        (config->encoder_bit_depth > 8 && pack_mode_10bit == 0) ? luma_size_8bit : 0;
+
+    EbSvtIOFormat *in_data;
+
+    svt_enc->raw_size = (luma_size_8bit + luma_size_10bit) * 3 / 2;
+
+    // allocate buffer for in and out
+    svt_enc->in_buf           = av_mallocz(sizeof(*svt_enc->in_buf));
+    if (!svt_enc->in_buf)
+        return AVERROR(ENOMEM);
+
+    svt_enc->in_buf->p_buffer  = (unsigned char *)av_mallocz(sizeof(*in_data));
+    if (!svt_enc->in_buf->p_buffer)
+        return AVERROR(ENOMEM);
+
+    svt_enc->in_buf->size        = sizeof(*svt_enc->in_buf);
+    svt_enc->in_buf->p_app_private  = NULL;
+
+    return 0;
+
+}
+
+static int config_enc_params(EbSvtAv1EncConfiguration *param,
+                             AVCodecContext *avctx)
+{
+    SvtContext *svt_enc = avctx->priv_data;
+    const AVPixFmtDescriptor *desc;
+    int ret;
+
+    param->source_width     = avctx->width;
+    param->source_height    = avctx->height;
+
+    desc = av_pix_fmt_desc_get(avctx->pix_fmt);
+    param->encoder_bit_depth = desc->comp[0].depth;
+    av_log(avctx, AV_LOG_DEBUG , "Encoder %d bits depth input\n", param->encoder_bit_depth);
+
+    if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1)
+        param->encoder_color_format   = EB_YUV420;
+    else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 0)
+        param->encoder_color_format   = EB_YUV422;
+    else if (!desc->log2_chroma_w && !desc->log2_chroma_h)
+        param->encoder_color_format   = EB_YUV444;
+    else {
+        av_log(avctx, AV_LOG_ERROR , "Unsupported pixel format\n");
+        return AVERROR(EINVAL);
+    }
+    av_log(avctx, AV_LOG_DEBUG , "Encoder color format is %d \n", param->encoder_color_format);
+
+    param->profile = svt_enc->profile;
+
+    if ((param->encoder_color_format == EB_YUV422 || param->encoder_bit_depth > 10)
+         && param->profile != PROFESSIONAL_PROFILE ) {
+        av_log(avctx, AV_LOG_WARNING, "Force to be professional profile \n");
+        param->profile = PROFESSIONAL_PROFILE;
+    } else if (param->encoder_color_format == EB_YUV444 && param->profile != HIGH_PROFILE) {
+        av_log(avctx, AV_LOG_WARNING, "Force to be high profile \n");
+        param->profile = HIGH_PROFILE;
+    }
+
+    // Update param from options
+    param->hierarchical_levels     = svt_enc->hierarchical_level;
+    param->enc_mode                = svt_enc->enc_mode;
+    param->tier                   = svt_enc->tier;
+    param->level                  = svt_enc->level;
+    param->rate_control_mode        = svt_enc->rc_mode;
+    param->scene_change_detection   = svt_enc->scd;
+
+    param->qp                     = svt_enc->qp;
+
+
+    param->target_bit_rate          = avctx->bit_rate;
+    if (avctx->gop_size > 0)
+        param->intra_period_length  = avctx->gop_size - 1;
+
+    if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
+        param->frame_rate_numerator     = avctx->framerate.num;
+        param->frame_rate_denominator   = avctx->framerate.den * avctx->ticks_per_frame;
+    } else {
+        param->frame_rate_numerator     = avctx->time_base.den;
+        param->frame_rate_denominator   = avctx->time_base.num * avctx->ticks_per_frame;
+    }
+
+    if (param->rate_control_mode) {
+        param->max_qp_allowed       = avctx->qmax;
+        param->min_qp_allowed       = avctx->qmin;
+    }
+
+    param->intra_refresh_type       = svt_enc->forced_idr + 1;
+
+    if (svt_enc->la_depth != -1)
+        param->look_ahead_distance  = svt_enc->la_depth;
+
+    return 0;
+}
+
+static void read_in_data(const AVFrame *frame,
+                         EbBufferHeaderType *header_ptr)
+{
+    EbSvtIOFormat *in_data = (EbSvtIOFormat *)header_ptr->p_buffer;
+    const AVPixFmtDescriptor *desc;
+    int i, bytes_shift, plane_h;
+
+    desc = av_pix_fmt_desc_get(frame->format);
+    bytes_shift = desc->comp[0].depth > 8 ? 1 : 0;
+
+    in_data->luma = frame->data[0];
+    in_data->cb   = frame->data[1];
+    in_data->cr   = frame->data[2];
+
+    in_data->y_stride  = AV_CEIL_RSHIFT(frame->linesize[0], bytes_shift);
+    in_data->cb_stride = AV_CEIL_RSHIFT(frame->linesize[1], bytes_shift);
+    in_data->cr_stride = AV_CEIL_RSHIFT(frame->linesize[2], bytes_shift);
+
+    for (i = 0; i < desc->nb_components; i++) {
+        plane_h = frame->height;
+        if (i > 0)
+            plane_h = AV_CEIL_RSHIFT(plane_h, desc->log2_chroma_h);
+        header_ptr->n_filled_len += frame->linesize[i] * plane_h;
+    }
+}
+
+static av_cold int eb_enc_init(AVCodecContext *avctx)
+{
+    SvtContext   *svt_enc = avctx->priv_data;
+    EbErrorType svt_ret;
+    int ret;
+
+    svt_enc->eos_flag = EOS_NOT_REACHED;
+
+    svt_ret = svt_av1_enc_init_handle(&svt_enc->svt_handle, svt_enc, &svt_enc->enc_params);
+    if (svt_ret != EB_ErrorNone) {
+        return svt_print_error(avctx, svt_ret, "Error init encoder handle");
+    }
+
+    ret = config_enc_params(&svt_enc->enc_params, avctx);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error configure encoder parameters\n");
+        return ret;
+    }
+
+    svt_ret = svt_av1_enc_set_parameter(svt_enc->svt_handle, &svt_enc->enc_params);
+    if (svt_ret != EB_ErrorNone) {
+        return svt_print_error(avctx, svt_ret, "Error setting encoder parameters");
+    }
+
+    svt_ret = svt_av1_enc_init(svt_enc->svt_handle);
+    if (svt_ret != EB_ErrorNone) {
+        svt_av1_enc_deinit_handle(svt_enc->svt_handle);
+        svt_enc->svt_handle = NULL;
+        return svt_print_error(avctx, svt_ret, "Error init encoder");
+    }
+
+    if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
+        EbBufferHeaderType *headerPtr = NULL;
+
+        svt_ret = svt_av1_enc_stream_header(svt_enc->svt_handle, &headerPtr);
+        if (svt_ret != EB_ErrorNone) {
+            return svt_print_error(avctx, svt_ret, "Error when build stream header");
+        }
+
+        avctx->extradata_size = headerPtr->n_filled_len;
+        avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+        if (!avctx->extradata) {
+            av_log(avctx, AV_LOG_ERROR,
+                   "Cannot allocate AV1 header of size %d.\n", avctx->extradata_size);
+            return AVERROR(ENOMEM);
+        }
+
+        memcpy(avctx->extradata, headerPtr->p_buffer, avctx->extradata_size);
+
+        svt_ret = svt_av1_enc_stream_header_release(headerPtr);
+        if (svt_ret != EB_ErrorNone) {
+            return svt_print_error(avctx, svt_ret, "Error when destroy stream header");
+        }
+    }
+
+    ret = alloc_buffer(&svt_enc->enc_params, svt_enc);
+    if (ret < 0)
+        return ret;
+    return 0;
+
+}
+
+static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
+{
+    SvtContext           *svt_enc = avctx->priv_data;
+    EbBufferHeaderType  *headerPtr = svt_enc->in_buf;
+
+    if (!frame) {
+        EbBufferHeaderType headerPtrLast;
+        headerPtrLast.n_alloc_len   = 0;
+        headerPtrLast.n_filled_len  = 0;
+        headerPtrLast.n_tick_count  = 0;
+        headerPtrLast.p_app_private = NULL;
+        headerPtrLast.p_buffer     = NULL;
+        headerPtrLast.flags      = EB_BUFFERFLAG_EOS;
+
+        svt_av1_enc_send_picture(svt_enc->svt_handle, &headerPtrLast);
+        svt_enc->eos_flag = EOS_SENT;
+        av_log(avctx, AV_LOG_DEBUG, "Finish sending frames!!!\n");
+        return 0;
+    }
+
+    read_in_data(frame, headerPtr);
+
+    headerPtr->flags       = 0;
+    headerPtr->p_app_private  = NULL;
+    headerPtr->pts          = frame->pts;
+
+    svt_av1_enc_send_picture(svt_enc->svt_handle, headerPtr);
+
+    return 0;
+}
+
+static AVBufferRef* get_output_ref(AVCodecContext *avctx, SvtContext  *svt_enc, int filled_len)
+{
+    if (filled_len > svt_enc->max_tu_size) {
+        const int MAX_FRAMES = 8;
+        int max_tu_size;
+        if (filled_len > svt_enc->raw_size * MAX_FRAMES) {
+            av_log(avctx, AV_LOG_ERROR, "something wrong in libsvtav1, the tu size > %d raw frame size.\n", MAX_FRAMES);
+            return NULL;
+        }
+        max_tu_size = 1 << av_ceil_log2(filled_len);
+        av_buffer_pool_uninit(&svt_enc->pool);
+        svt_enc->pool = av_buffer_pool_init(max_tu_size, NULL);
+        if (!svt_enc->pool) {
+            return NULL;
+        }
+        svt_enc->max_tu_size = max_tu_size;
+    }
+    if (!svt_enc->pool) {
+         av_log(avctx, AV_LOG_ERROR, "bug, no buffer pool.\n");
+         return NULL;
+    }
+    return av_buffer_pool_get(svt_enc->pool);
+}
+
+static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
+{
+    SvtContext  *svt_enc = avctx->priv_data;
+    EbBufferHeaderType *headerPtr;
+    EbErrorType svt_ret;
+    int ret = 0, pict_type;
+    AVBufferRef* ref;
+
+    if (svt_enc->eos_flag == EOS_RECEIVED)
+        return AVERROR_EOF;
+
+    svt_ret = svt_av1_enc_get_packet(svt_enc->svt_handle, &headerPtr, svt_enc->eos_flag);
+    if (svt_ret == EB_NoErrorEmptyQueue)
+        return AVERROR(EAGAIN);
+
+    ref = get_output_ref(avctx, svt_enc, headerPtr->n_filled_len);
+    if (!ref) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");
+        svt_av1_enc_release_out_buffer(&headerPtr);
+        return AVERROR(ENOMEM);
+    }
+    pkt->buf = ref;
+    pkt->data = ref->data;
+
+    memcpy(pkt->data, headerPtr->p_buffer, headerPtr->n_filled_len);
+    pkt->size = headerPtr->n_filled_len;
+    pkt->pts  = headerPtr->pts;
+    pkt->dts  = headerPtr->dts;
+    if (headerPtr->pic_type == EB_AV1_KEY_PICTURE) {
+        pkt->flags |= AV_PKT_FLAG_KEY;
+        pict_type = AV_PICTURE_TYPE_I;
+    } else if (headerPtr->pic_type == EB_AV1_INTRA_ONLY_PICTURE) {
+        pict_type = AV_PICTURE_TYPE_I;
+    } else if (headerPtr->pic_type == EB_AV1_INVALID_PICTURE) {
+        pict_type = AV_PICTURE_TYPE_NONE;
+    } else
+        pict_type = AV_PICTURE_TYPE_P;
+
+    if (headerPtr->pic_type == EB_AV1_NON_REF_PICTURE)
+        pkt->flags |= AV_PKT_FLAG_DISPOSABLE;
+
+    if (headerPtr->flags & EB_BUFFERFLAG_EOS)
+        svt_enc->eos_flag = EOS_RECEIVED;
+
+    ff_side_data_set_encoder_stats(pkt, headerPtr->qp * FF_QP2LAMBDA, NULL, 0, pict_type);
+
+    svt_av1_enc_release_out_buffer(&headerPtr);
+
+    return ret;
+}
+
+static av_cold int eb_enc_close(AVCodecContext *avctx)
+{
+    SvtContext *svt_enc = avctx->priv_data;
+
+    if (svt_enc) {
+        if (svt_enc->svt_handle) {
+            svt_av1_enc_deinit(svt_enc->svt_handle);
+            svt_av1_enc_deinit_handle(svt_enc->svt_handle);
+        }
+
+        free_buffer(svt_enc);
+        svt_enc = NULL;
+    }
+    return 0;
+}
+
+#define OFFSET(x) offsetof(SvtContext, x)
+#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+static const AVOption options[] = {
+    { "hielevel", "Hierarchical prediction levels setting", OFFSET(hierarchical_level),
+      AV_OPT_TYPE_INT, { .i64 = 4 }, 3, 4, VE , "hielevel"},
+        { "3level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 },  INT_MIN, INT_MAX, VE, "hielevel" },
+        { "4level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 4 },  INT_MIN, INT_MAX, VE, "hielevel" },
+
+    { "la_depth", "Look ahead distance [0, 120]", OFFSET(la_depth),
+      AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 120, VE },
+
+    { "preset", "Encoding preset [0, 8]",
+      OFFSET(enc_mode), AV_OPT_TYPE_INT, { .i64 = MAX_ENC_PRESET }, 0, MAX_ENC_PRESET, VE },
+
+    { "profile", "Set profile restrictions", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = MAIN_PROFILE}, MAIN_PROFILE, PROFESSIONAL_PROFILE, VE, "profile" },
+    { "main" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MAIN_PROFILE}, INT_MIN, INT_MAX,     VE, "profile" },
+    { "high" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HIGH_PROFILE}, INT_MIN, INT_MAX,     VE, "profile" },
+    { "professional", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PROFESSIONAL_PROFILE }, INT_MIN, INT_MAX,     VE, "profile" },
+
+    { "tier", "Set tier (general_tier_flag)", OFFSET(tier),
+      AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, "tier" },
+        { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, VE, "tier" },
+        { "high", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, VE, "tier" },
+
+    { "level", "Set level (level_idc)", OFFSET(level),
+      AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 0x1f, VE, "level" },
+
+#define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
+      { .i64 = value }, 0, 0, VE, "level"
+        { LEVEL("2.0", 20) },
+        { LEVEL("2.1", 21) },
+        { LEVEL("2.2", 22) },
+        { LEVEL("2.3", 23) },
+        { LEVEL("3.0", 30) },
+        { LEVEL("3.1", 31) },
+        { LEVEL("3.2", 32) },
+        { LEVEL("3.3", 33) },
+        { LEVEL("4.0", 40) },
+        { LEVEL("4.1", 41) },
+        { LEVEL("4.2", 42) },
+        { LEVEL("4.3", 43) },
+        { LEVEL("5.0", 50) },
+        { LEVEL("5.1", 51) },
+        { LEVEL("5.2", 52) },
+        { LEVEL("5.3", 53) },
+        { LEVEL("6.0", 60) },
+        { LEVEL("6.1", 61) },
+        { LEVEL("6.2", 62) },
+        { LEVEL("6.3", 63) },
+        { LEVEL("7.0", 70) },
+        { LEVEL("7.1", 71) },
+        { LEVEL("7.2", 72) },
+        { LEVEL("7.3", 73) },
+#undef LEVEL
+
+    { "rc", "Bit rate control mode", OFFSET(rc_mode),
+      AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 3, VE , "rc"},
+        { "cqp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 },  INT_MIN, INT_MAX, VE, "rc" },
+        { "vbr", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 },  INT_MIN, INT_MAX, VE, "rc" },
+        { "cvbr", NULL, 0, AV_OPT_TYPE_CONST,{ .i64 = 3 },  INT_MIN, INT_MAX, VE, "rc" },
+
+    { "qp", "QP value for intra frames", OFFSET(qp),
+      AV_OPT_TYPE_INT, { .i64 = 50 }, 0, 63, VE },
+
+    { "sc_detection", "Scene change detection", OFFSET(scd),
+      AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
+
+
+
+
+    { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr),
+      AV_OPT_TYPE_BOOL,   { .i64 = 0 }, 0, 1, VE },
+
+    {NULL},
+};
+
+static const AVClass class = {
+    .class_name = "libsvt_av1",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+static const AVCodecDefault eb_enc_defaults[] = {
+    { "b",         "7M"    },
+    { "g",         "-2"    },
+    { "qmin",      "0"     },
+    { "qmax",      "63"    },
+    { NULL },
+};
+
+AVCodec ff_libsvt_av1_encoder = {
+    .name           = "libsvt_av1",
+    .long_name      = NULL_IF_CONFIG_SMALL("SVT-AV1(Scalable Video Technology for AV1) encoder"),
+    .priv_data_size = sizeof(SvtContext),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_AV1,
+    .init           = eb_enc_init,
+    .send_frame     = eb_send_frame,
+    .receive_packet = eb_receive_packet,
+    .close          = eb_enc_close,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS,
+    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
+                                                    AV_PIX_FMT_YUV420P10,
+                                                    AV_PIX_FMT_NONE },
+    .priv_class     = &class,
+    .defaults       = eb_enc_defaults,
+    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
+    .wrapper_name   = "libsvt_av1",
+};
diff --git a/libavcodec/libx264.c b/libavcodec/libx264.c
index a08fe0c..fc9f94f 100644
--- a/libavcodec/libx264.c
+++ b/libavcodec/libx264.c
@@ -207,24 +207,76 @@ static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
         x264_encoder_reconfig(x4->enc, &x4->params);
     }
 
-    if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
-        x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate    / 1000) {
-        x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
-        x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate    / 1000;
-        x264_encoder_reconfig(x4->enc, &x4->params);
+    if (frame->perceptual_score == -1) {
+        if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
+            x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate    / 1000) {
+            x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
+            x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate    / 1000;
+            x264_encoder_reconfig(x4->enc, &x4->params);
+        }
     }
 
     if (x4->params.rc.i_rc_method == X264_RC_ABR &&
-        x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
-        x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
-        x264_encoder_reconfig(x4->enc, &x4->params);
+        (frame->perceptual_score > -1 ||
+         x4->params.rc.i_bitrate != ctx->bit_rate / 1000)) {
+        if (frame->perceptual_score > -1) {
+            int bitrate = 0;
+            /* set ABR bitrate value from perceptual score */
+            /* decrease compression by raising the avg bitrate up to N times */
+            bitrate = (ctx->bit_rate / 1000) + ((frame->perceptual_score * frame->perceptual_score_factor) * (ctx->bit_rate / 1000.0));
+            x4->params.rc.i_bitrate = bitrate;
+            x4->params.rc.i_vbv_max_bitrate = bitrate * 1.5;
+            x4->params.rc.i_vbv_buffer_size = bitrate * 1.5 * 1.5;
+            av_log(ctx, AV_LOG_DEBUG,
+               "Perceptual: [%0.2f] bitrate %d maxbitrate %d from %"PRIu64"\n",
+               frame->perceptual_score,
+               x4->params.rc.i_bitrate,
+               x4->params.rc.i_vbv_max_bitrate,
+               ctx->bit_rate / 1000);
+
+            /* tag this frame with this specific config */
+            x4->pic.param = &x4->params;
+            x264_encoder_reconfig(x4->enc, &x4->params);
+        } else {
+            x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
+            x264_encoder_reconfig(x4->enc, &x4->params);
+        }
     }
 
     if (x4->crf >= 0 &&
         x4->params.rc.i_rc_method == X264_RC_CRF &&
-        x4->params.rc.f_rf_constant != x4->crf) {
-        x4->params.rc.f_rf_constant = x4->crf;
-        x264_encoder_reconfig(x4->enc, &x4->params);
+        (frame->perceptual_score > -1 ||
+         x4->params.rc.f_rf_constant != x4->crf)) {
+        if (frame->perceptual_score > -1) {
+            float crf_value = 0.0;
+
+            /* set crf value from perceptual score */
+            /* decrease compression by lowering the score by up to N CRF points */
+            crf_value = x4->crf - ((frame->perceptual_score * 100.0) / (frame->perceptual_score_factor * 2.0));
+            x4->params.rc.f_rf_constant = crf_value;
+
+            if (ctx->rc_max_rate) {
+                int bitrate = 0;
+                /* set ABR bitrate value from perceptual score */
+                /* decrease compression by raising the avg bitrate up to N times */
+                bitrate = (ctx->rc_max_rate / 1000) + ((frame->perceptual_score * frame->perceptual_score_factor) * (ctx->rc_max_rate / 1000.0));
+                x4->params.rc.i_vbv_max_bitrate = bitrate;
+                x4->params.rc.i_vbv_buffer_size = bitrate * 1.5 * 1.5;
+            }
+            av_log(ctx, AV_LOG_DEBUG,
+               "Perceptual: [%0.2f] crf: %0.2f bitrate %d maxbitrate %d from %"PRIu64"\n",
+               frame->perceptual_score,
+               x4->params.rc.f_rf_constant,
+               x4->params.rc.i_bitrate,
+               x4->params.rc.i_vbv_max_bitrate,
+               ctx->rc_max_rate / 1000);
+
+            /* tag this frame with this specific config */
+            x4->pic.param = &x4->params;
+        } else {
+            x4->params.rc.f_rf_constant = x4->crf;
+            x264_encoder_reconfig(x4->enc, &x4->params);
+        }
     }
 
     if (x4->params.rc.i_rc_method == X264_RC_CQP &&
diff --git a/libavfilter/Makefile b/libavfilter/Makefile
index e6cfcd9..f6fe208 100644
--- a/libavfilter/Makefile
+++ b/libavfilter/Makefile
@@ -337,6 +337,7 @@ OBJS-$(CONFIG_PERMS_FILTER)                  += f_perms.o
 OBJS-$(CONFIG_PERSPECTIVE_FILTER)            += vf_perspective.o
 OBJS-$(CONFIG_PHASE_FILTER)                  += vf_phase.o
 OBJS-$(CONFIG_PHOTOSENSITIVITY_FILTER)       += vf_photosensitivity.o
+OBJS-$(CONFIG_PHQM_FILTER)                   += vf_phqm.o img_hash.o
 OBJS-$(CONFIG_PIXDESCTEST_FILTER)            += vf_pixdesctest.o
 OBJS-$(CONFIG_PIXSCOPE_FILTER)               += vf_datascope.o
 OBJS-$(CONFIG_PP_FILTER)                     += vf_pp.o
@@ -513,6 +514,7 @@ SKIPHEADERS-$(CONFIG_LIBVIDSTAB)             += vidstabutils.h
 
 OBJS-$(CONFIG_SHARED)                        += log2_tab.o
 
+SKIPHEADERS-$(CONFIG_LIBOPENCV)              += img_hash.h
 SKIPHEADERS-$(CONFIG_QSVVPP)                 += qsvvpp.h
 SKIPHEADERS-$(CONFIG_OPENCL)                 += opencl.h
 SKIPHEADERS-$(CONFIG_VAAPI)                  += vaapi_vpp.h
diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c
index 501e5d0..126ca66 100644
--- a/libavfilter/allfilters.c
+++ b/libavfilter/allfilters.c
@@ -325,6 +325,7 @@ extern AVFilter ff_vf_pixdesctest;
 extern AVFilter ff_vf_pixscope;
 extern AVFilter ff_vf_pp;
 extern AVFilter ff_vf_pp7;
+extern AVFilter ff_vf_phqm;
 extern AVFilter ff_vf_premultiply;
 extern AVFilter ff_vf_prewitt;
 extern AVFilter ff_vf_prewitt_opencl;
diff --git a/libavfilter/img_hash.cpp b/libavfilter/img_hash.cpp
new file mode 100644
index 0000000..4d5843d
--- /dev/null
+++ b/libavfilter/img_hash.cpp
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2019 Christopher Kennedy
+ *
+ * OpenCV img_hash
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/ocl.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/img_hash.hpp>
+#include <opencv2/imgproc.hpp>
+
+#include <iostream>
+
+#include "img_hash.h"
+#include "libavutil/pixdesc.h"
+extern "C" {
+#include "avfilter.h"
+}
+
+// convert from avframe to iplimage format
+static int fill_iplimage_from_frame(IplImage *img, const AVFrame *frame, enum AVPixelFormat pixfmt)
+{
+    IplImage *tmpimg;
+    int depth = IPL_DEPTH_8U, channels_nb;
+
+    switch (pixfmt) {
+        case AV_PIX_FMT_GRAY8:      channels_nb = 1; break;
+        case AV_PIX_FMT_BGRA:       channels_nb = 4; break;
+        case AV_PIX_FMT_BGR24:      channels_nb = 3; break;
+        default: return -1;
+    }
+
+    tmpimg = cvCreateImageHeader((CvSize){frame->width, frame->height}, depth, channels_nb);
+    *img = *tmpimg;
+    img->imageData = img->imageDataOrigin = (char *) frame->data[0];
+    img->dataOrder = IPL_DATA_ORDER_PIXEL;
+    img->origin    = IPL_ORIGIN_TL;
+    img->widthStep = frame->linesize[0];
+
+    return 0;
+}
+
+// Get the score of two Video Frames by comparing the perceptual hashes and deriving a hamming distance
+// showing how similar they are or different. lower score is better for most algorithms
+extern "C" double getScore(const AVFrame *frame1, const AVFrame *frame2, enum AVPixelFormat pixfmt, int hash_type) {
+    cv::Ptr<cv::img_hash::ImgHashBase> algo;
+    IplImage ipl1, ipl2;
+    cv::Mat h1;
+    cv::Mat h2;
+    cv::Mat m1;
+    cv::Mat m2;
+
+    // Take FFmpeg video frame and convert into an IplImage for OpenCV
+    if (fill_iplimage_from_frame(&ipl1, frame1, pixfmt) != 0 ||
+        fill_iplimage_from_frame(&ipl2, frame2, pixfmt) != 0)
+        return DBL_MAX; // Return an invalid value if either fails
+
+    // Convert an IplImage to an Mat Image for OpenCV (newer format)
+    m1 = cv::cvarrToMat(&ipl1);
+    m2 = cv::cvarrToMat(&ipl2);
+
+    // substantiate the hash type algorithm
+    switch (hash_type) {
+        case PHASH:             algo = cv::img_hash::PHash::create();               break;
+        case AVERAGE:           algo = cv::img_hash::AverageHash::create();         break;
+        case MARRHILDRETH:      algo = cv::img_hash::MarrHildrethHash::create();    break;
+        case RADIALVARIANCE:    algo = cv::img_hash::RadialVarianceHash::create();  break;
+        // BlockMeanHash support mode 0 and mode 1, they associate to
+        // mode 1 and mode 2 of PHash library
+        case BLOCKMEAN1:        algo = cv::img_hash::BlockMeanHash::create(0);      break;
+        case BLOCKMEAN2:        algo = cv::img_hash::BlockMeanHash::create(1);      break;
+        case COLORMOMENT:       algo = cv::img_hash::ColorMomentHash::create();     break;
+    }
+
+    // Compute the hash
+    algo->compute(m1, h1);
+    algo->compute(m2, h2);
+
+    // Compare the hashes and return the hamming distance
+    return algo->compare(h1, h2);
+}
diff --git a/libavfilter/img_hash.h b/libavfilter/img_hash.h
new file mode 100644
index 0000000..76f55c3
--- /dev/null
+++ b/libavfilter/img_hash.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2019 Christopher Kennedy
+ *
+ * PHQM Perceptual Hash Quality Metric
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVFILTER_IMG_HASH_H
+#define AVFILTER_IMG_HASH_H
+
+#include "avfilter.h"
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+
+#define AVERAGE 0
+#define BLOCKMEAN1 1
+#define BLOCKMEAN2 2
+#define COLORMOMENT 3
+#define MARRHILDRETH 4
+#define PHASH 5
+#define RADIALVARIANCE 6
+
+double getScore(const AVFrame *frame1, const AVFrame *frame2, enum AVPixelFormat pixfmt, int hash_type);
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
diff --git a/libavfilter/vf_phqm.c b/libavfilter/vf_phqm.c
new file mode 100644
index 0000000..a7b73cf
--- /dev/null
+++ b/libavfilter/vf_phqm.c
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) 2019 Christopher Kennedy
+ *
+ * PHQM Perceptual Hash Quality Metric
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * PHQM: Calculate the Image Hash Hamming Difference between two input videos.
+ */
+
+#include <float.h>
+#include "libavutil/avstring.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "avfilter.h"
+#include "drawutils.h"
+#include "formats.h"
+#include "framesync.h"
+#include "internal.h"
+#include "video.h"
+
+#include "img_hash.h"
+#include "scene_sad.h"
+
+typedef struct PHQMContext {
+    const AVClass *class;
+    FFFrameSync fs;
+    double shd, hd, min_hd, max_hd, smin_hd, smax_hd;
+    double hft, sft, phd, psad;
+    uint64_t nb_shd;
+    uint64_t nb_frames;
+    FILE *stats_file;
+    char *stats_file_str;
+    int hash_type;
+    ff_scene_sad_fn sad_ref;            ///< Sum of the absolute difference function (scene detect only)
+    ff_scene_sad_fn sad_enc;            ///< Sum of the absolute difference function (scene detect only)
+    double prev_mafd_ref;               ///< previous MAFD                           (scene detect only)
+    double prev_mafd_enc;               ///< previous MAFD                           (scene detect only)
+    AVFrame *prev_pic_ref;           ///< ref previous frame                          (scene detect only)
+    AVFrame *prev_pic_enc;           ///< enc previous frame                          (scene detect only)
+    double scd_thresh;
+    double scene_score_ref;
+    double scene_score_enc;
+    double prev_hamm_ref;
+    double prev_hamm_enc;
+} PHQMContext;
+
+#define OFFSET(x) offsetof(PHQMContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption phqm_options[] = {
+    { "stats_file", "Set file where to store per-frame difference information.", OFFSET(stats_file_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
+    { "f",          "Set file where to store per-frame difference information.", OFFSET(stats_file_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
+    { "scd_thresh", "Scene Change Detection Threshold.",                         OFFSET(scd_thresh),     AV_OPT_TYPE_DOUBLE, {.dbl=0.5},  0, 1, FLAGS },
+    { "hash_type",  "Type of Image Hash to use from OpenCV.",                    OFFSET(hash_type),      AV_OPT_TYPE_INT,    {.i64 = PHASH}, 0, 6, FLAGS, "hash_type" },
+    {     "average",        "Average Hash",             0, AV_OPT_TYPE_CONST, {.i64 = AVERAGE},        0, 0, FLAGS, "hash_type" },
+    {     "blockmean1",     "Block Mean Hash 1",        0, AV_OPT_TYPE_CONST, {.i64 = BLOCKMEAN1},     0, 0, FLAGS, "hash_type" },
+    {     "blockmean2",     "Block Mean Hash 2",        0, AV_OPT_TYPE_CONST, {.i64 = BLOCKMEAN2},     0, 0, FLAGS, "hash_type" },
+    {     "colormoment",    "Color Moment Hash",        0, AV_OPT_TYPE_CONST, {.i64 = COLORMOMENT},    0, 0, FLAGS, "hash_type" },
+    {     "marrhildreth",   "Marr Hildreth Hash",       0, AV_OPT_TYPE_CONST, {.i64 = MARRHILDRETH},   0, 0, FLAGS, "hash_type" },
+    {     "phash",          "Perceptual Hash (PHash)",  0, AV_OPT_TYPE_CONST, {.i64 = PHASH},          0, 0, FLAGS, "hash_type" },
+    {     "radialvariance", "Radial Variance Hash",     0, AV_OPT_TYPE_CONST, {.i64 = RADIALVARIANCE}, 0, 0, FLAGS, "hash_type" },
+    { NULL }
+};
+
+FRAMESYNC_DEFINE_CLASS(phqm, PHQMContext, fs);
+
+static void set_meta(AVDictionary **metadata, const char *key, char comp, float d)
+{
+    char value[128];
+    snprintf(value, sizeof(value), "%0.2f", d);
+    if (comp) {
+        char key2[128];
+        snprintf(key2, sizeof(key2), "%s%c", key, comp);
+        av_dict_set(metadata, key2, value, 0);
+    } else {
+        av_dict_set(metadata, key, value, 0);
+    }
+}
+
+static void get_scene_score(AVFilterContext *ctx, AVFrame *ref, AVFrame *enc)
+{
+    PHQMContext *s = ctx->priv;
+    AVFrame *prev_pic_ref = s->prev_pic_ref;
+    AVFrame *prev_pic_enc = s->prev_pic_enc;
+
+    /* reference */
+    if (prev_pic_ref &&
+        ref->height == prev_pic_ref->height &&
+        ref->width  == prev_pic_ref->width) {
+        uint64_t sad;
+        double mafd, diff;
+
+        /* scene change sad score */
+        s->sad_ref(prev_pic_ref->data[0], prev_pic_ref->linesize[0], ref->data[0], ref->linesize[0], ref->width * 3, ref->height, &sad);
+        emms_c();
+        mafd = (double)sad / (ref->width * 3 * ref->height);
+        diff = fabs(mafd - s->prev_mafd_ref);
+        s->scene_score_ref  = av_clipf(FFMIN(mafd, diff) / 100., 0, 1);
+        s->prev_mafd_ref = mafd;
+
+        /* get prev/current frame hamming difference */
+        s->prev_hamm_ref = getScore(s->prev_pic_ref, ref, ref->format, s->hash_type);
+
+        av_frame_free(&prev_pic_ref);
+    }
+    s->prev_pic_ref = av_frame_clone(ref);
+
+    if (prev_pic_enc &&
+        enc->height == prev_pic_enc->height &&
+        enc->width  == prev_pic_enc->width) {
+        uint64_t sad;
+        double mafd, diff;
+
+        /* scene change sad score */
+        s->sad_enc(prev_pic_enc->data[0], prev_pic_enc->linesize[0], enc->data[0], enc->linesize[0], enc->width * 3, enc->height, &sad);
+        emms_c();
+        mafd = (double)sad / (enc->width * 3 * enc->height);
+        diff = fabs(mafd - s->prev_mafd_enc);
+        s->scene_score_enc  = av_clipf(FFMIN(mafd, diff) / 100., 0, 1);
+        s->prev_mafd_enc = mafd;
+
+        /* get prev/current frame hamming difference */
+        s->prev_hamm_enc = getScore(s->prev_pic_enc, enc, enc->format, s->hash_type);
+
+        av_frame_free(&prev_pic_enc);
+    }
+    s->prev_pic_enc = av_frame_clone(enc);
+}
+
+static int do_phqm(FFFrameSync *fs)
+{
+    AVFilterContext *ctx = fs->parent;
+    PHQMContext *s = ctx->priv;
+    AVFrame *master, *ref;
+    double hd = 0.;
+    int ret;
+    double hd_limit = 1000000.;
+    AVDictionary **metadata;
+
+    ret = ff_framesync_dualinput_get(fs, &master, &ref);
+    if (ret < 0)
+        return ret;
+    if (!ref)
+        return ff_filter_frame(ctx->outputs[0], master);
+    metadata = &master->metadata;
+
+    s->nb_frames++;
+
+    /* scene change detection score */
+    get_scene_score(ctx, ref, master);
+    if (s->scene_score_ref >= s->scd_thresh && s->nb_shd >= 48) {
+        av_log(s, AV_LOG_WARNING, "ImgHashScene: n:%"PRId64"-%"PRId64" hd_avg:%0.3lf hd_min:%0.3lf hd_max:%0.3lf scd:%0.2lf hft:%0.3lf sft:%0.3lf\n",
+               (s->nb_frames - s->nb_shd), s->nb_frames - 1, (s->shd / s->nb_shd), s->smin_hd, s->smax_hd, s->scene_score_ref, (s->hft / s->nb_shd), (s->sft / s->nb_shd));
+        s->shd = 0.;
+        s->sft = 0.;
+        s->hft = 0.;
+        s->nb_shd = 0;
+        s->smin_hd = 0.;
+        s->smax_hd = 0.;
+    }
+
+    /* frame perceptual score, normalize to percentage, read by x264 for crf/vbr */
+    master->perceptual_score           = ref->perceptual_score        = .01 * FFMIN((s->prev_hamm_ref * 2.0), 100);
+    master->perceptual_score_factor    = ref->perceptual_score_factor = 2.0;
+    set_meta(metadata, "lavfi.phqm.hamm", 0, s->prev_hamm_ref);
+
+    /* limit the highest value so we cut off at perceptual difference match */
+    switch (s->hash_type) {
+        case PHASH:
+        case AVERAGE:           hd_limit = 5;   break;
+        case MARRHILDRETH:      hd_limit = 30;  break;
+        case RADIALVARIANCE:    hd_limit = 0.9; break;
+        case BLOCKMEAN1:        hd_limit = 12;  break;
+        case BLOCKMEAN2:        hd_limit = 48;  break;
+        case COLORMOMENT:       hd_limit = 8;   break;
+    }
+
+    /* get ref / enc perceptual hashes and calc hamming distance difference value */
+    hd = getScore(ref, master, ref->format, s->hash_type);
+    if (hd == DBL_MAX) {
+        av_log(s, AV_LOG_ERROR, "Failure with handling pix_fmt of AVFrame for conversion to IPLimage.\n");
+        return AVERROR(EINVAL);
+    }
+    s->hd += FFMIN(hd, hd_limit);
+    s->phd += FFMIN(s->prev_hamm_ref, hd_limit);
+    s->psad += FFMIN(s->scene_score_ref, hd_limit);
+    set_meta(metadata, "lavfi.phqm.phqm", 0, hd);
+
+    /* scene hamming distance avg */
+    s->shd += FFMIN(hd, hd_limit);
+    s->hft += s->prev_hamm_ref;
+    s->sft += s->scene_score_ref;
+    s->nb_shd++;
+    av_log(s, AV_LOG_DEBUG, "ImgHashFrame: hd:%0.3lf sad:%0.2lf hamm:%0.3lf\n", hd, s->scene_score_ref, s->prev_hamm_ref);
+
+    s->min_hd = FFMIN(s->min_hd, hd);
+    s->max_hd = FFMAX(s->max_hd, hd);
+    s->smin_hd = FFMIN(s->smin_hd, hd);
+    s->smax_hd = FFMAX(s->smax_hd, hd);
+
+    if (s->stats_file) {
+        fprintf(s->stats_file,
+                "n:%"PRId64" phqm:%0.3f phqm_min:%0.3f phqm_max:%0.3f sad:%0.2f ref_hamm:%0.2f enc_hamm:%0.2f",
+                s->nb_frames, hd, s->min_hd, s->max_hd, s->scene_score_ref, s->prev_hamm_ref, s->prev_hamm_enc);
+        fprintf(s->stats_file, "\n");
+    }
+
+    return ff_filter_frame(ctx->outputs[0], master);
+}
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    PHQMContext *s = ctx->priv;
+
+    if (s->stats_file_str) {
+        if (!strcmp(s->stats_file_str, "-")) {
+            s->stats_file = stdout;
+        } else {
+            s->stats_file = fopen(s->stats_file_str, "w");
+            if (!s->stats_file) {
+                int err = AVERROR(errno);
+                char buf[128];
+                av_strerror(err, buf, sizeof(buf));
+                av_log(ctx, AV_LOG_ERROR, "Could not open stats file %s: %s\n",
+                       s->stats_file_str, buf);
+                return err;
+            }
+        }
+    }
+
+    s->sad_ref = ff_scene_sad_get_fn(8);
+    if (!s->sad_ref)
+        return AVERROR(EINVAL);
+    s->sad_enc = ff_scene_sad_get_fn(8);
+    if (!s->sad_enc)
+        return AVERROR(EINVAL);
+
+    s->fs.on_event = do_phqm;
+    return 0;
+}
+
+static int query_formats(AVFilterContext *ctx)
+{
+    PHQMContext *s = ctx->priv;
+    AVFilterFormats *fmts_list = NULL;
+    static const enum AVPixelFormat gray8_pix_fmts[] = {
+        AV_PIX_FMT_GRAY8,
+        AV_PIX_FMT_NONE
+    };
+    static const enum AVPixelFormat bgr24_pix_fmts[] = {
+        AV_PIX_FMT_BGR24,
+        AV_PIX_FMT_NONE
+    };
+    static const enum AVPixelFormat bgra_pix_fmts[] = {
+        AV_PIX_FMT_BGRA,
+        AV_PIX_FMT_NONE
+    };
+
+    switch (s->hash_type) {
+        case COLORMOMENT: fmts_list = ff_make_format_list(bgr24_pix_fmts); break;
+        case MARRHILDRETH: fmts_list = ff_make_format_list(bgra_pix_fmts); break;
+        /* all other hashes take the gray8 format */
+        default: fmts_list = ff_make_format_list(gray8_pix_fmts); break;
+    }
+    if (!fmts_list)
+        return AVERROR(ENOMEM);
+    return ff_set_common_formats(ctx, fmts_list);
+}
+
+static int config_input_ref(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx  = inlink->dst;
+
+    if (ctx->inputs[0]->w != ctx->inputs[1]->w ||
+        ctx->inputs[0]->h != ctx->inputs[1]->h) {
+        av_log(ctx, AV_LOG_ERROR, "Width and height of input videos must be same.\n");
+        return AVERROR(EINVAL);
+    }
+    if (ctx->inputs[0]->format != ctx->inputs[1]->format) {
+        av_log(ctx, AV_LOG_ERROR, "Inputs must be of same pixel format.\n");
+        return AVERROR(EINVAL);
+    }
+
+    return 0;
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    PHQMContext *s = ctx->priv;
+    AVFilterLink *mainlink = ctx->inputs[0];
+    int ret;
+
+    ret = ff_framesync_init_dualinput(&s->fs, ctx);
+    if (ret < 0)
+        return ret;
+    outlink->w = mainlink->w;
+    outlink->h = mainlink->h;
+    outlink->time_base = mainlink->time_base;
+    outlink->sample_aspect_ratio = mainlink->sample_aspect_ratio;
+    outlink->frame_rate = mainlink->frame_rate;
+    if ((ret = ff_framesync_configure(&s->fs)) < 0)
+        return ret;
+
+    return 0;
+}
+
+static int activate(AVFilterContext *ctx)
+{
+    PHQMContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    PHQMContext *s = ctx->priv;
+
+    if (s->nb_frames > 0)
+        av_log(ctx, AV_LOG_WARNING, "PHQM average:%f min:%f max:%f hamm:%f sad:%f\n",
+               s->hd / s->nb_frames, s->min_hd, s->max_hd,
+               s->phd / s->nb_frames, s->psad / s->nb_frames);
+
+    ff_framesync_uninit(&s->fs);
+
+    if (s->stats_file && s->stats_file != stdout)
+        fclose(s->stats_file);
+    av_frame_free(&s->prev_pic_ref);
+    av_frame_free(&s->prev_pic_enc);
+}
+
+static const AVFilterPad phqm_inputs[] = {
+    {
+        .name         = "main",
+        .type         = AVMEDIA_TYPE_VIDEO,
+    },{
+        .name         = "reference",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = config_input_ref,
+    },
+    { NULL }
+};
+
+static const AVFilterPad phqm_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .config_props  = config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_phqm= {
+    .name          = "phqm",
+    .description   = NULL_IF_CONFIG_SMALL("PHQM: Calculate the Perceptual Hash Hamming Difference between two video streams."),
+    .preinit       = phqm_framesync_preinit,
+    .init          = init,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .activate      = activate,
+    .priv_size     = sizeof(PHQMContext),
+    .priv_class    = &phqm_class,
+    .inputs        = phqm_inputs,
+    .outputs       = phqm_outputs,
+};
diff --git a/libavformat/mpegenc.c b/libavformat/mpegenc.c
index 669ff9d..b58e3b6 100644
--- a/libavformat/mpegenc.c
+++ b/libavformat/mpegenc.c
@@ -979,7 +979,7 @@ static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
                scr > pkt_desc->dts) { // FIXME: > vs >=
             if (stream->buffer_index < pkt_desc->size ||
                 stream->predecode_packet == stream->premux_packet) {
-                av_log(ctx, AV_LOG_ERROR,
+                av_log(ctx, AV_LOG_WARNING,
                        "buffer underflow st=%d bufi=%d size=%d\n",
                        i, stream->buffer_index, pkt_desc->size);
                 break;
@@ -1058,7 +1058,7 @@ retry:
                     scr / 90000.0, best_dts / 90000.0);
 
             if (scr >= best_dts + 1 && !ignore_constraints) {
-                av_log(ctx, AV_LOG_ERROR,
+                av_log(ctx, AV_LOG_WARNING,
                     "packet too large, ignoring buffer limits to mux it\n");
                 ignore_constraints = 1;
             }
diff --git a/libavutil/frame.c b/libavutil/frame.c
index e403809..cd29f10 100644
--- a/libavutil/frame.c
+++ b/libavutil/frame.c
@@ -163,6 +163,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
     frame->color_range         = AVCOL_RANGE_UNSPECIFIED;
     frame->chroma_location     = AVCHROMA_LOC_UNSPECIFIED;
     frame->flags               = 0;
+    frame->perceptual_score    = -1;
+    frame->perceptual_score_factor    = 2.0;
 }
 
 static void free_side_data(AVFrameSideData **ptr_sd)
@@ -373,6 +375,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
     dst->colorspace             = src->colorspace;
     dst->color_range            = src->color_range;
     dst->chroma_location        = src->chroma_location;
+    dst->perceptual_score       = src->perceptual_score;
+    dst->perceptual_score_factor       = src->perceptual_score_factor;
 
     av_dict_copy(&dst->metadata, src->metadata, 0);
 
@@ -453,6 +457,8 @@ int av_frame_ref(AVFrame *dst, const AVFrame *src)
     dst->channels       = src->channels;
     dst->channel_layout = src->channel_layout;
     dst->nb_samples     = src->nb_samples;
+    dst->perceptual_score = src->perceptual_score;
+    dst->perceptual_score_factor = src->perceptual_score_factor;
 
     ret = frame_copy_props(dst, src, 0);
     if (ret < 0)
diff --git a/libavutil/frame.h b/libavutil/frame.h
index b5afb58..4ebcccf 100644
--- a/libavutil/frame.h
+++ b/libavutil/frame.h
@@ -672,6 +672,13 @@ typedef struct AVFrame {
      * for the target frame's private_ref field.
      */
     AVBufferRef *private_ref;
+
+    /**
+     * perceptual score
+     * 0.00 - 1.00 percentage of perceptual match to the previous frame
+     */
+    float perceptual_score;
+    float perceptual_score_factor;
 } AVFrame;
 
 #if FF_API_FRAME_GET_SET