replace libpostproc deinterlacer with internal implementation

* Mod: drop LinearBlend and Median deinterlacer
* Mod: drop libpostproc dependency
* Fix: Bob/LinearBob/CubicBob supports all pixel format now
* Fix: top and button pixels was blinking with Bob/LinearBob/CubicBob

Author: bylee20

README.md

@@ -28,7 +28,6 @@ You have to prepare next libraries, too:
   * libavcodec >= 55.34.1 (*)
   * libavutil >= 52.48.101 (*)
   * libavfilter (*)
-  * libpostproc (*)
   * libswresample (*)
   * libswscale (*)
 * chardet (*)

build-ffmpeg

@@ -2,8 +2,7 @@
 
 args="--prefix=`pwd`/build --enable-gpl --disable-debug --disable-shared --enable-static \
   --enable-runtime-cpudetect --disable-doc --disable-programs --enable-gnutls \
-  --disable-avdevice --enable-avfilter --enable-swresample \
-  --disable-avresample --enable-pthreads --enable-postproc \
+  --disable-avdevice --enable-avfilter --enable-swresample --disable-avresample --enable-pthreads \
   --disable-encoders --disable-muxers --disable-devices --enable-filters"
 
 kern=`uname -s`

configure

@@ -429,7 +429,7 @@ if has_arg "developer"; then
     transdir=$(pwd)/src/bomi/translations
 fi
 
-check_pkg_or_exit ffmpeg "libavformat >= 55.12.0" "libavutil >= 52.48.101" "libavcodec >= 55.34.1" "libswresample" "libswscale" "libavfilter" "libpostproc"
+check_pkg_or_exit ffmpeg "libavformat >= 55.12.0" "libavutil >= 52.48.101" "libavcodec >= 55.34.1" "libswresample" "libswscale" "libavfilter"
 check_pkg_or_exit "libmpg123"
 check_pkg_or_exit "libass"
 check_pkg_or_exit "dvdread"

src/bomi/enum/deintmethod.cpp

@@ -1,11 +1,9 @@
 #include "deintmethod.hpp"
 
-const std::array<DeintMethodInfo::Item, 7> DeintMethodInfo::info{{
+const std::array<DeintMethodInfo::Item, 5> DeintMethodInfo::info{{
     {DeintMethod::None, u"None"_q, u""_q, (int)0},
     {DeintMethod::Bob, u"Bob"_q, u""_q, (int)1},
     {DeintMethod::LinearBob, u"LinearBob"_q, u""_q, (int)2},
     {DeintMethod::CubicBob, u"CubicBob"_q, u""_q, (int)3},
-    {DeintMethod::Median, u"Median"_q, u""_q, (int)4},
-    {DeintMethod::LinearBlend, u"LinearBlend"_q, u""_q, (int)5},
-    {DeintMethod::Yadif, u"Yadif"_q, u""_q, (int)6}
+    {DeintMethod::Yadif, u"Yadif"_q, u""_q, (int)4}
 }};

src/bomi/enum/deintmethod.hpp

@@ -9,9 +9,7 @@ enum class DeintMethod : int {
     Bob = (int)1,
     LinearBob = (int)2,
     CubicBob = (int)3,
-    Median = (int)4,
-    LinearBlend = (int)5,
-    Yadif = (int)6
+    Yadif = (int)4
 };
 
 Q_DECLARE_METATYPE(DeintMethod)
@@ -51,9 +49,9 @@ class EnumInfo<DeintMethod> {
         QString name, key;
         QVariant data;
     };
-    using ItemList = std::array<Item, 7>;
+    using ItemList = std::array<Item, 5>;
     static constexpr auto size() -> int
-    { return 7; }
+    { return 5; }
     static constexpr auto typeName() -> const char*
     { return "DeintMethod"; }
     static constexpr auto typeKey() -> const char*
@@ -77,8 +75,6 @@ class EnumInfo<DeintMethod> {
         case Enum::Bob: return qApp->translate("EnumInfo", "");
         case Enum::LinearBob: return qApp->translate("EnumInfo", "");
         case Enum::CubicBob: return qApp->translate("EnumInfo", "");
-        case Enum::Median: return qApp->translate("EnumInfo", "");
-        case Enum::LinearBlend: return qApp->translate("EnumInfo", "");
         case Enum::Yadif: return qApp->translate("EnumInfo", "");
         default: return QString();
         }

src/bomi/prebuild/enum-list

@@ -137,8 +137,6 @@ ${ return EnumFlags<SpeakerId>((int)lhs | (int)rhs); }
 -Bob
 -LinearBob
 -CubicBob
--Median
--LinearBlend
 -Yadif
 
 +Interpolator[:QByteArray:]

src/bomi/video/deintcaps.cpp

@@ -27,9 +27,7 @@ auto DeintCaps::list() -> const QList<DeintCaps>&
     push(DeintMethod::Bob           , true , true, true );
     push(DeintMethod::LinearBob     , true , true, true );
     push(DeintMethod::CubicBob      , true , true, true );
-    push(DeintMethod::LinearBlend   , true , true, false);
     push(DeintMethod::Yadif         , true , true, true );
-    push(DeintMethod::Median        , true , true, true );
     return caps;
 }
 

src/bomi/video/ffmpegfilters.cpp

@@ -137,56 +137,101 @@ auto FFmpegFilterGraph::release() -> void
 
 /******************************************************************************/
 
-auto FFmpegPostProc::process(MpImage &di, const MpImage&si) const -> bool
+auto BobDeinterlacer::field(DeintMethod method, const MpImage &src, bool top) const -> MpImage
 {
-    if (!m_context)
-        return false;
-    const uint8_t *src[3]  = {si->planes[0], si->planes[1], si->planes[2]};
-          uint8_t *dst[3]  = {di->planes[0], di->planes[1], di->planes[2]};
-    const int srcStride[3] = {si->stride[0], si->stride[1], si->stride[2]};
-    const int dstStride[3] = {di->stride[0], di->stride[1], di->stride[2]};
-    pp_postprocess(src, srcStride, dst, dstStride, si->w, si->h,
-                   nullptr, 0, m_mode, m_context, si->pict_type);
-    return true;
-}
+    if (src->num_planes < 1)
+        return src;
+    const int h = src->plane_h[0];
+    if (h < 4)
+        return src;
 
-auto FFmpegPostProc::initialize(const QString &option, const QSize &size,
-                                mp_imgfmt imgfmt) -> bool
-{
-    if (m_option == option && m_size == size && m_imgfmt == imgfmt)
-        return m_context;
-    release();
-    m_option = option;
-    m_size = size;
-    m_imgfmt = imgfmt;
-    if (m_option.isEmpty() || m_size.isEmpty())
-        return false;
-    int flags = PP_CPU_CAPS_AUTO;
-    switch (imgfmt) {
-    case IMGFMT_420P:
-        flags |= PP_FORMAT_420;
+    MpImage dst = std::move(newImage(src));
+    const int stride = src->stride[0];
+    auto in = src->planes[0], out = dst->planes[0];
+    auto copy = [=] (int src, int dst)
+        { memcpy(out + dst * stride, in + src * stride, stride); };
+
+    switch (method) {
+    case DeintMethod::Bob: {
+        const int srcOffset = !top;
+        const int count = src->plane_h[0] / 2;
+        for (int i = 0; i < count ; ++i) {
+            auto src = in + srcOffset * stride;
+            memcpy(out, src, stride);
+            out += stride;
+            memcpy(out, src, stride);
+            out += stride;
+            in += 2 * stride;
+        }
         break;
-    case IMGFMT_411P:
-        flags |= PP_FORMAT_411;
+    } case DeintMethod::LinearBob: {
+        const int count = h / 2 - 1;
+
+        if (top) {
+            copy(h - 2, h - 1);
+            copy(h - 2, h - 2);
+        } else {
+            copy(1, 0);
+            copy(h - 1, h - 1);
+            in += stride;
+            out += stride;
+        }
+
+        for (int i = 0; i < count ; ++i) {
+            memcpy(out, in, stride);
+            out += stride;
+            auto in1 = in;
+            auto in2 = in += stride * 2;
+            for (int x = 0; x < stride; ++x)
+                *out++ = (*in1++ + *in2++) / 2 ;
+        }
         break;
-    case IMGFMT_422P:
-        flags |= PP_FORMAT_422;
+    } case DeintMethod::CubicBob: {
+        const int count = h / 2 - 2;
+
+        if (top) {
+            copy(0, 0);
+            copy(0, 1);
+            copy(h - 2, h - 1);
+            copy(h - 2, h - 2);
+            in += stride * 2;
+            out += stride * 2;
+        } else {
+            copy(1, 0);
+            copy(1, 1);
+            copy(3, 2);
+            copy(h - 1, h - 1);
+            in += stride * 3;
+            out += stride * 3;
+        }
+
+        for (int i = 0; i < count ; ++i) {
+            memcpy(out, in, stride);
+            out += stride;
+            auto in0 = in - stride * 2;
+            auto in1 = in;
+            auto in2 = in += stride * 2;
+            auto in3 = in + stride * 2;
+            for (int x = 0; x < stride; ++x) {
+                const int p0 = *in0++, p1 = *in1++, p2 = *in2++, p3 = *in3++;
+                const auto a =  -p0 + 3*p1 - 3*p2 + p3;
+                const auto b = 2*p0 - 5*p1 + 4*p2 - p3;
+                const auto c =  -p0        +   p2;
+                const auto d =        2*p1;
+                *out++ = (uchar)qBound(0, (a + 2*b + 4*c + 8*d)/16, 255);
+            }
+        }
         break;
-    case IMGFMT_444P:
-        flags |= PP_FORMAT_444;
+    } default:
+        memcpy(dst->planes[0], src->planes[0], src->plane_h[0]*src->stride[0]);
         break;
-    default:
-        return false;
     }
-    m_mode = pp_get_mode_by_name_and_quality(m_option.toLatin1().constData(),
-                                             PP_QUALITY_MAX);
-    if (!m_mode)
-        return false;
-    m_context = pp_get_context(size.width(), size.height(), flags);
-    return m_context;
+    for (int i = 1; i < src->num_planes; ++i)
+        memcpy(dst->planes[i], src->planes[i], src->plane_h[i]*src->stride[i]);
+    return dst;
 }
 
-auto FFmpegPostProc::newImage(const MpImage &mpi) const -> MpImage
+auto BobDeinterlacer::newImage(const MpImage &mpi) const -> MpImage
 {
     auto tmp = mp_image_pool_get(m_pool, mpi->imgfmt, mpi->stride[0], mpi->h);
     auto img = mp_image_new_ref(tmp);
@@ -200,11 +245,3 @@ auto FFmpegPostProc::newImage(const MpImage &mpi) const -> MpImage
     mp_image_copy_attributes(img, (mp_image*)mpi.data());
     return MpImage::wrap(img);
 }
-
-auto FFmpegPostProc::release() -> void
-{
-    if (m_context)
-        pp_free_context(m_context);
-    if (m_mode)
-        pp_free_mode(m_mode);
-}

src/bomi/video/ffmpegfilters.hpp

@@ -3,13 +3,13 @@
 
 #include <QString>
 #include <QSize>
-
 extern "C" {
 #include <video/mp_image_pool.h>
 #include <video/img_format.h>
 #include <libavfilter/avfiltergraph.h>
 #include <libpostproc/postprocess.h>
 }
+#include "enum/deintmethod.hpp"
 #include "mpimage.hpp"
 
 #ifdef bool
@@ -34,22 +34,13 @@ class FFmpegFilterGraph {
     AVFilterContext *m_src = nullptr, *m_sink = nullptr;
 };
 
-class FFmpegPostProc {
+class BobDeinterlacer {
 public:
-    FFmpegPostProc() { m_pool = mp_image_pool_new(10); }
-    ~FFmpegPostProc() { release(); mp_image_pool_clear(m_pool); }
-    auto process(MpImage &dst, const MpImage &src) const -> bool;
-    auto initialize(const QString &opt, const QSize &s, mp_imgfmt fmt) -> bool;
-    auto initialize(const QString &opt, const MpImage &mpi) -> bool
-        { return initialize(opt, {mpi->w, mpi->h}, mpi->imgfmt); }
-    auto newImage(const MpImage &mpi) const -> MpImage;
+    BobDeinterlacer() { m_pool = mp_image_pool_new(10); }
+    ~BobDeinterlacer() { mp_image_pool_clear(m_pool); }
+    auto field(DeintMethod method, const MpImage &src, bool top) const -> MpImage;
 private:
-    auto release() -> void;
-    QString m_option;
-    mp_imgfmt m_imgfmt = IMGFMT_NONE;
-    QSize m_size = {0, 0};
-    pp_context *m_context = nullptr;
-    pp_mode *m_mode = nullptr;
+    auto newImage(const MpImage &mpi) const -> MpImage;
     mp_image_pool *m_pool = nullptr;
 };
 

src/bomi/video/softwaredeinterlacer.cpp

@@ -9,36 +9,16 @@ struct SoftwareDeinterlacer::Data {
     bool rebuild = true, pass = false;
     DeintOption deint;
     FFmpegFilterGraph graph;
-    FFmpegPostProc pp;
+    BobDeinterlacer bob;
     Type type = Pass;
     MpImage input;
     int processed = 0, count = 1;
     mutable int i_pts = 0;
     double pts = MP_NOPTS_VALUE, prev = MP_NOPTS_VALUE;
     std::deque<MpImage> queue;
 
-    auto topField() const -> MpImage
-    {
-        auto out = pp.newImage(input);
-        pp.process(out, input);
-        return out;
-    }
-    auto bottomField() const -> MpImage
-    {
-        auto inm = const_cast<MpImage&>(input);
-        auto out = pp.newImage(input);
-        inm->planes[0] += inm->stride[0];
-        out->planes[0] += out->stride[0];
-        inm->h -= 2;
-        out->h -= 2;
-        pp.process(out, inm);
-        out->planes[0] -= out->stride[0];
-        inm->planes[0] -= inm->stride[0];
-        out->h += 2;
-        inm->h += 2;
-        return out;
-    }
-
+    auto bobField(bool top) const -> MpImage
+        { return bob.field(deint.method, input, top); }
     auto step(int split) const -> double
     {
         if (pts == MP_NOPTS_VALUE || prev == MP_NOPTS_VALUE)
@@ -86,18 +66,16 @@ auto SoftwareDeinterlacer::push(MpImage &&mpi) -> void
     d->processed = 0;
     d->pass = true;
     if (d->input->fields & MP_IMGFIELD_INTERLACED) {
+        d->pass = false;
         switch (d->type) {
-        case Mark: {
-            d->pass = false;
+        case Mark: case Bob:
             break;
-        } case Graph:
+        case Graph:
             if (!(d->pass = !d->graph.initialize(d->option, d->input)))
                 d->graph.push(d->input);
             break;
-        case PP:
-            d->pass = !d->pp.initialize(d->option, d->input);
-            break;
         default:
+            d->pass = true;
             break;
         }
     }
@@ -129,12 +107,9 @@ auto SoftwareDeinterlacer::pop() -> MpImage
                 ret->pts = d->nextPts();
             }
             break;
-        } case PP: {
+        } case Bob: {
             const bool topFirst = d->input->fields & MP_IMGFIELD_TOP_FIRST;
-            if (d->processed == 0)
-                ret = topFirst ? d->topField() : d->bottomField();
-            else if (d->processed == 1)
-                ret = topFirst ? d->bottomField() : d->topField();
+            ret = d->bobField(topFirst == !d->processed);
             break;
         } default:
             break;
@@ -162,20 +137,11 @@ auto SoftwareDeinterlacer::setOption(const DeintOption &deint) -> void
     } else if (deint.processor == Processor::GPU) {
         d->type = Mark;
     } else {
-        d->type = PP;
         switch (d->deint.method) {
         case DeintMethod::Bob:
         case DeintMethod::LinearBob:
-            d->option = u"li"_q;
-            break;
-        case DeintMethod::LinearBlend:
-            d->option = u"lb"_q;
-            break;
         case DeintMethod::CubicBob:
-            d->option = u"ci"_q;
-            break;
-        case DeintMethod::Median:
-            d->option = u"md"_q;
+            d->type = Bob;
             break;
         case DeintMethod::Yadif:
             d->option = "yadif"_a % (d->deint.doubler ? "=mode=1"_a : ""_a);