deinterlace: use avfilter yadif deinterlacer

6 files changed, 207 insertions, 679 deletions

diff --git a/libhb/avfilter.c b/libhb/avfilter.c
index b145b7a0d..4c1f1d165 100644
--- a/libhb/avfilter.c
+++ b/libhb/avfilter.c
@@ -74,6 +74,18 @@ hb_filter_object_t hb_filter_rotate =
     .info          = avfilter_info,
 };
 
+hb_filter_object_t hb_filter_deinterlace =
+{
+    .id            = HB_FILTER_DEINTERLACE,
+    .enforce_order = 1,
+    .name          = "avfilter",
+    .settings      = NULL,
+    .init          = avfilter_init,
+    .work          = avfilter_work,
+    .close         = avfilter_close,
+    .info          = avfilter_info,
+};
+
 static AVFilterContext * append_filter( hb_filter_private_t * pv,
                                         const char * name, const char * args)
 {
@@ -429,6 +441,7 @@ void hb_avfilter_combine( hb_list_t * list )
         {
             case HB_FILTER_AVFILTER:
             case HB_FILTER_ROTATE:
+            case HB_FILTER_DEINTERLACE:
             case HB_FILTER_PAD:
                 if (avfilter != NULL)
                 {
diff --git a/libhb/builtin_presets.h b/libhb/builtin_presets.h
index fa4236e3f..5ab646f19 100644
--- a/libhb/builtin_presets.h
+++ b/libhb/builtin_presets.h
@@ -858,6 +858,6 @@ const char hb_builtin_presets_json[] =
 "        }, \n"
 "        \"VersionMajor\": 11, \n"
 "        \"VersionMicro\": 0, \n"
-"        \"VersionMinor\": 0\n"
+"        \"VersionMinor\": 1\n"
 "    }\n"
 "}\n";
diff --git a/libhb/deinterlace.c b/libhb/deinterlace.c
deleted file mode 100644
index a402a5253..000000000
--- a/libhb/deinterlace.c
+++ /dev/null
@@ -1,667 +0,0 @@
-/*
- Copyright (C) 2006 Michael Niedermayer <[email protected]>
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 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 General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-#include "hb.h"
-#include "hbffmpeg.h"
-#include "taskset.h"
-
-// yadif_mode is a bit vector with the following flags
-#define MODE_YADIF_ENABLE       1
-#define MODE_YADIF_SPATIAL      2
-#define MODE_YADIF_2PASS        4
-#define MODE_YADIF_BOB          8
-
-#define YADIF_MODE_DEFAULT      0
-#define YADIF_PARITY_DEFAULT   -1
-
-#define ABS(a) ((a) > 0 ? (a) : (-(a)))
-#define MIN3(a,b,c) MIN(MIN(a,b),c)
-#define MAX3(a,b,c) MAX(MAX(a,b),c)
-
-typedef struct yadif_arguments_s {
-    hb_buffer_t * dst;
-    int parity;
-    int tff;
-} yadif_arguments_t;
-
-typedef struct deint_arguments_s {
-    hb_buffer_t * src;
-    hb_buffer_t * dst;
-} deint_arguments_t;
-
-typedef struct deint_thread_arg_s {
-    hb_filter_private_t *pv;
-    int segment;
-} deint_thread_arg_t;
-
-struct hb_filter_private_s
-{
-    int              width;
-    int              height;
-
-    int              yadif_mode;
-    int              yadif_parity;
-    int              yadif_ready;
-
-    hb_buffer_t      * yadif_ref[3];
-
-    int              cpu_count;
-    int              segments;
-
-    int              deint_nsegs;
-
-    taskset_t        deint_taskset;         // Threads for fast deint
-    taskset_t        yadif_taskset;         // Threads for Yadif
-
-    deint_arguments_t *deint_arguments;     // Arguments to thread for work
-    yadif_arguments_t *yadif_arguments;     // Arguments to thread for work
-};
-
-static int hb_deinterlace_init( hb_filter_object_t * filter,
-                                hb_filter_init_t * init );
-
-static int hb_deinterlace_work( hb_filter_object_t * filter,
-                                hb_buffer_t ** buf_in,
-                                hb_buffer_t ** buf_out );
-
-static void hb_deinterlace_close( hb_filter_object_t * filter );
-
-hb_filter_object_t hb_filter_deinterlace =
-{
-    .id            = HB_FILTER_DEINTERLACE,
-    .enforce_order = 1,
-    .name          = "Deinterlace",
-    .settings      = NULL,
-    .init          = hb_deinterlace_init,
-    .work          = hb_deinterlace_work,
-    .close         = hb_deinterlace_close,
-};
-
-
-static void yadif_store_ref(hb_filter_private_t *pv, hb_buffer_t *b)
-{
-
-    hb_buffer_close(&pv->yadif_ref[0]);
-    memmove(&pv->yadif_ref[0], &pv->yadif_ref[1], sizeof(hb_buffer_t *) * 2 );
-    pv->yadif_ref[2] = b;
-}
-
-static void yadif_filter_line(
-    hb_filter_private_t * pv,
-    uint8_t             * dst,
-    uint8_t             * prev,
-    uint8_t             * cur,
-    uint8_t             * next,
-    int                   width,
-    int                   stride,
-    int                   parity)
-{
-    uint8_t *prev2 = parity ? prev : cur ;
-    uint8_t *next2 = parity ? cur  : next;
-
-    int x;
-    for( x = 0; x < width; x++)
-    {
-        int c              = cur[-stride];
-        int d              = (prev2[0] + next2[0])>>1;
-        int e              = cur[+stride];
-        int temporal_diff0 = ABS(prev2[0] - next2[0]);
-        int temporal_diff1 = ( ABS(prev[-stride] - c) + ABS(prev[+stride] - e) ) >> 1;
-        int temporal_diff2 = ( ABS(next[-stride] - c) + ABS(next[+stride] - e) ) >> 1;
-        int diff           = MAX3(temporal_diff0>>1, temporal_diff1, temporal_diff2);
-        int spatial_pred   = (c+e)>>1;
-        int spatial_score  = ABS(cur[-stride-1] - cur[+stride-1]) + ABS(c-e) +
-                             ABS(cur[-stride+1] - cur[+stride+1]) - 1;
-
-#define YADIF_CHECK(j)\
-        {   int score = ABS(cur[-stride-1+j] - cur[+stride-1-j])\
-                      + ABS(cur[-stride  +j] - cur[+stride  -j])\
-                      + ABS(cur[-stride+1+j] - cur[+stride+1-j]);\
-            if( score < spatial_score ){\
-                spatial_score = score;\
-                spatial_pred  = (cur[-stride  +j] + cur[+stride  -j])>>1;\
-
-        YADIF_CHECK(-1) YADIF_CHECK(-2) }} }}
-        YADIF_CHECK( 1) YADIF_CHECK( 2) }} }}
-
-        if( pv->yadif_mode & MODE_YADIF_SPATIAL )
-        {
-            int b = (prev2[-2*stride] + next2[-2*stride])>>1;
-            int f = (prev2[+2*stride] + next2[+2*stride])>>1;
-
-            int max = MAX3(d-e, d-c, MIN(b-c, f-e));
-            int min = MIN3(d-e, d-c, MAX(b-c, f-e));
-
-            diff = MAX3( diff, min, -max );
-        }
-
-        if( spatial_pred > d + diff )
-        {
-            spatial_pred = d + diff;
-        }
-        else if( spatial_pred < d - diff )
-        {
-            spatial_pred = d - diff;
-        }
-
-        dst[0] = spatial_pred;
-
-        dst++;
-        cur++;
-        prev++;
-        next++;
-        prev2++;
-        next2++;
-    }
-}
-
-typedef struct yadif_thread_arg_s {
-    hb_filter_private_t *pv;
-    int segment;
-} yadif_thread_arg_t;
-
-/*
- * deinterlace this segment of all three planes in a single thread.
- */
-void yadif_filter_thread( void *thread_args_v )
-{
-    yadif_arguments_t *yadif_work = NULL;
-    hb_filter_private_t * pv;
-    int run = 1;
-    int segment, segment_start, segment_stop;
-    yadif_thread_arg_t *thread_args = thread_args_v;
-
-    pv = thread_args->pv;
-    segment = thread_args->segment;
-
-    hb_log("Yadif Deinterlace thread started for segment %d", segment);
-
-    while( run )
-    {
-        /*
-         * Wait here until there is work to do.
-         */
-        taskset_thread_wait4start( &pv->yadif_taskset, segment );
-
-
-        if( taskset_thread_stop( &pv->yadif_taskset, segment ) )
-        {
-            /*
-             * No more work to do, exit this thread.
-             */
-            run = 0;
-            goto report_completion;
-        }
-
-        yadif_work = &pv->yadif_arguments[segment];
-
-        if( yadif_work->dst == NULL )
-        {
-            hb_error( "Thread started when no work available" );
-            goto report_completion;
-        }
-
-        /*
-         * Process all three planes, but only this segment of it.
-         */
-        int pp;
-        for(pp = 0; pp < 3; pp++)
-        {
-            hb_buffer_t *dst = yadif_work->dst;
-            int w = dst->plane[pp].width;
-            int s = dst->plane[pp].stride;
-            int h = dst->plane[pp].height;
-            int yy;
-            int parity = yadif_work->parity;
-            int tff = yadif_work->tff;
-            int penultimate = h - 2;
-
-            int segment_height = (h / pv->segments) & ~1;
-            segment_start = segment_height * segment;
-            if( segment == pv->segments - 1 )
-            {
-                /*
-                 * Final segment
-                 */
-                segment_stop = h;
-            } else {
-                segment_stop = segment_height * ( segment + 1 );
-            }
-
-            uint8_t *dst2 = &dst->plane[pp].data[segment_start * s];
-            uint8_t *prev = &pv->yadif_ref[0]->plane[pp].data[segment_start * s];
-            uint8_t *cur  = &pv->yadif_ref[1]->plane[pp].data[segment_start * s];
-            uint8_t *next = &pv->yadif_ref[2]->plane[pp].data[segment_start * s];
-            for( yy = segment_start; yy < segment_stop; yy++ )
-            {
-                if(((yy ^ parity) &  1))
-                {
-                    /* This is the bottom field when TFF and vice-versa.
-                       It's the field that gets filtered. Because yadif
-                       needs 2 lines above and below the one being filtered,
-                       we need to mirror the edges. When TFF, this means
-                       replacing the 2nd line with a copy of the 1st,
-                       and the last with the second-to-last.                  */
-                    if( yy > 1 && yy < penultimate )
-                    {
-                        /* This isn't the top or bottom,
-                         * proceed as normal to yadif. */
-                        yadif_filter_line(pv, dst2, prev, cur, next, w, s,
-                                          parity ^ tff);
-                    }
-                    else
-                    {
-                        // parity == 0 (TFF), y1 = y0
-                        // parity == 1 (BFF), y0 = y1
-                        // parity == 0 (TFF), yu = yp
-                        // parity == 1 (BFF), yp = yu
-                        uint8_t *src  = &pv->yadif_ref[1]->plane[pp].data[(yy^parity)*s];
-                        memcpy(dst2, src, w);
-                    }
-                }
-                else
-                {
-                    /* Preserve this field unfiltered */
-                    memcpy(dst2, cur, w);
-                }
-                dst2 += s;
-                prev += s;
-                cur += s;
-                next += s;
-            }
-        }
-
-report_completion:
-        /*
-         * Finished this segment, let everyone know.
-         */
-        taskset_thread_complete( &pv->yadif_taskset, segment );
-    }
-}
-
-
-/*
- * threaded yadif - each thread deinterlaces a single segment of all
- * three planes. Where a segment is defined as the frame divided by
- * the number of CPUs.
- *
- * This function blocks until the frame is deinterlaced.
- */
-static void yadif_filter( hb_filter_private_t * pv,
-                          hb_buffer_t * dst, int parity, int tff)
-{
-
-    int segment;
-
-    for( segment = 0; segment < pv->segments; segment++ )
-    {
-        /*
-         * Setup the work for this plane.
-         */
-        pv->yadif_arguments[segment].parity = parity;
-        pv->yadif_arguments[segment].tff = tff;
-        pv->yadif_arguments[segment].dst = dst;
-    }
-
-    /* Allow the taskset threads to make one pass over the data. */
-    taskset_cycle( &pv->yadif_taskset );
-
-    /*
-     * Entire frame is now deinterlaced.
-     */
-}
-
-/*
- * deinterlace a frame in a single thread.
- */
-void deint_filter_thread( void *thread_args_v )
-{
-    deint_arguments_t *args = NULL;
-    hb_filter_private_t * pv;
-    int run = 1;
-    int segment;
-    deint_thread_arg_t *thread_args = thread_args_v;
-
-    pv = thread_args->pv;
-    segment = thread_args->segment;
-
-    hb_log("Fast Deinterlace thread started for segment %d", segment);
-
-    while( run )
-    {
-        /*
-         * Wait here until there is work to do.
-         */
-        taskset_thread_wait4start( &pv->deint_taskset, segment );
-
-
-        if( taskset_thread_stop( &pv->deint_taskset, segment ) )
-        {
-            /*
-             * No more work to do, exit this thread.
-             */
-            run = 0;
-            goto report_completion;
-        }
-
-        args = &pv->deint_arguments[segment];
-
-        if( args->dst == NULL )
-        {
-            // This can happen when flushing final buffers.
-            goto report_completion;
-        }
-
-        /*
-         * Process all three planes, but only this segment of it.
-         */
-        hb_deinterlace(args->dst, args->src);
-
-report_completion:
-        /*
-         * Finished this segment, let everyone know.
-         */
-        taskset_thread_complete( &pv->deint_taskset, segment );
-    }
-}
-
-/*
- * threaded fast deint - each thread deinterlaces a single frame.
- *
- * This function blocks until all frames are deinterlaced.
- */
-static hb_buffer_t * deint_fast(hb_filter_private_t * pv, hb_buffer_t * in)
-{
-
-    int ii;
-    hb_buffer_t *dst, *src;
-    hb_buffer_list_t list;
-
-    hb_buffer_list_clear(&list);
-    if (in != NULL)
-    {
-        dst = hb_frame_buffer_init(in->f.fmt, in->f.width, in->f.height);
-        pv->deint_arguments[pv->deint_nsegs].src = in;
-        pv->deint_arguments[pv->deint_nsegs].dst = dst;
-        pv->deint_nsegs++;
-    }
-    if (in != NULL && pv->deint_nsegs < pv->segments)
-    {
-        return NULL;
-    }
-
-    if (pv->deint_nsegs > 0)
-    {
-        /* Allow the taskset threads to make one pass over the data. */
-        taskset_cycle( &pv->deint_taskset );
-    }
-
-    for (ii = 0; ii < pv->deint_nsegs; ii++)
-    {
-        src = pv->deint_arguments[ii].src;
-        dst = pv->deint_arguments[ii].dst;
-        pv->deint_arguments[ii].src = NULL;
-        pv->deint_arguments[ii].dst = NULL;
-        hb_buffer_list_append(&list, dst);
-
-        dst->s = src->s;
-        hb_buffer_close(&src);
-    }
-    pv->deint_nsegs = 0;
-
-    return hb_buffer_list_clear(&list);
-}
-
-static int hb_deinterlace_init( hb_filter_object_t * filter,
-                                hb_filter_init_t * init )
-{
-    filter->private_data = calloc( 1, sizeof(struct hb_filter_private_s) );
-    hb_filter_private_t * pv = filter->private_data;
-
-    pv->width = init->geometry.width;
-    pv->height = init->geometry.height;
-
-    pv->yadif_ready    = 0;
-    pv->yadif_mode     = YADIF_MODE_DEFAULT;
-    pv->yadif_parity   = YADIF_PARITY_DEFAULT;
-
-    if( filter->settings )
-    {
-        sscanf( filter->settings, "%d:%d",
-                &pv->yadif_mode,
-                &pv->yadif_parity);
-    }
-
-    pv->cpu_count = hb_get_cpu_count();
-
-    /* Allocate yadif specific buffers */
-    if( pv->yadif_mode & MODE_YADIF_ENABLE )
-    {
-        /*
-         * Setup yadif taskset.
-         */
-        pv->segments = pv->cpu_count;
-        pv->yadif_arguments = malloc( sizeof( yadif_arguments_t ) * pv->segments );
-        if( pv->yadif_arguments == NULL ||
-            taskset_init( &pv->yadif_taskset, /*thread_count*/pv->segments,
-                          sizeof( yadif_thread_arg_t ) ) == 0 )
-        {
-            hb_error( "yadif could not initialize taskset" );
-        }
-
-        int ii;
-        for( ii = 0; ii < pv->segments; ii++ )
-        {
-            yadif_thread_arg_t *thread_args;
-
-            thread_args = taskset_thread_args( &pv->yadif_taskset, ii );
-
-            thread_args->pv = pv;
-            thread_args->segment = ii;
-            pv->yadif_arguments[ii].dst = NULL;
-
-            if( taskset_thread_spawn( &pv->yadif_taskset, ii,
-                                      "yadif_filter_segment",
-                                      yadif_filter_thread,
-                                      HB_NORMAL_PRIORITY ) == 0 )
-            {
-                hb_error( "yadif could not spawn thread" );
-            }
-        }
-    }
-    else
-    {
-        /*
-         * Setup fast deint taskset.
-         */
-        pv->segments = pv->cpu_count;
-        pv->deint_arguments = malloc( sizeof( deint_arguments_t ) * pv->segments );
-        if( pv->deint_arguments == NULL ||
-            taskset_init( &pv->deint_taskset, pv->segments,
-                          sizeof( deint_thread_arg_t ) ) == 0 )
-        {
-            hb_error( "deint could not initialize taskset" );
-        }
-
-        int ii;
-        for( ii = 0; ii < pv->segments; ii++ )
-        {
-            deint_thread_arg_t *thread_args;
-
-            thread_args = taskset_thread_args( &pv->deint_taskset, ii );
-
-            thread_args->pv = pv;
-            thread_args->segment = ii;
-            pv->deint_arguments[ii].dst = NULL;
-
-            if( taskset_thread_spawn( &pv->deint_taskset, ii,
-                                      "deint_filter_segment",
-                                      deint_filter_thread,
-                                      HB_NORMAL_PRIORITY ) == 0 )
-            {
-                hb_error( "deint could not spawn thread" );
-            }
-        }
-    }
-
-    return 0;
-}
-
-static void hb_deinterlace_close( hb_filter_object_t * filter )
-{
-    hb_filter_private_t * pv = filter->private_data;
-
-    if( !pv )
-    {
-        return;
-    }
-
-    /* Cleanup yadif specific buffers */
-    if( pv->yadif_mode & MODE_YADIF_ENABLE )
-    {
-        taskset_fini( &pv->yadif_taskset );
-
-        int ii;
-        for(ii = 0; ii < 3; ii++)
-        {
-            hb_buffer_close(&pv->yadif_ref[ii]);
-        }
-
-        free( pv->yadif_arguments );
-    }
-    else
-    {
-        taskset_fini( &pv->deint_taskset );
-        free( pv->deint_arguments );
-    }
-
-    free( pv );
-    filter->private_data = NULL;
-}
-
-static int hb_deinterlace_work( hb_filter_object_t * filter,
-                                hb_buffer_t ** buf_in,
-                                hb_buffer_t ** buf_out )
-{
-    hb_filter_private_t * pv = filter->private_data;
-    hb_buffer_t * in = *buf_in;
-    hb_buffer_list_t list;
-
-    *buf_in = NULL;
-    hb_buffer_list_clear(&list);
-    if (in->s.flags & HB_BUF_FLAG_EOF)
-    {
-        if( !( pv->yadif_mode & MODE_YADIF_ENABLE ) )
-        {
-            // Flush final frames
-            hb_buffer_list_append(&list, deint_fast(pv, NULL));
-        }
-        hb_buffer_list_append(&list, in);
-
-        *buf_out = hb_buffer_list_clear(&list);
-        return HB_FILTER_DONE;
-    }
-
-    /* Use fast deinterlace if yadif_mode < 0 */
-    if( !( pv->yadif_mode & MODE_YADIF_ENABLE ) )
-    {
-        *buf_out = deint_fast(pv, in);
-        return HB_FILTER_OK;
-    }
-
-    /* Store current frame in yadif cache */
-    yadif_store_ref(pv, in);
-
-    // yadif requires 3 buffers, prev, cur, and next.  For the first
-    // frame, there can be no prev, so we duplicate the first frame.
-    if (!pv->yadif_ready)
-    {
-        // If yadif is not ready, store another ref and return HB_FILTER_DELAY
-        yadif_store_ref(pv, hb_buffer_dup(in));
-        pv->yadif_ready = 1;
-        // Wait for next
-        return HB_FILTER_DELAY;
-    }
-
-    /* Determine if top-field first layout */
-    int tff;
-    if( pv->yadif_parity < 0 )
-    {
-        tff = !!(in->s.flags & PIC_FLAG_TOP_FIELD_FIRST);
-    }
-    else
-    {
-        tff = (pv->yadif_parity & 1) ^ 1;
-    }
-
-    /* deinterlace both fields if yadif 2 pass or bob */
-    int frame, num_frames = 1;
-    if ((pv->yadif_mode & MODE_YADIF_2PASS) ||
-        (pv->yadif_mode & MODE_YADIF_BOB))
-    {
-        num_frames = 2;
-    }
-
-    // Will need up to 2 buffers simultaneously
-    int idx = 0;
-    hb_buffer_t * o_buf[2] = {NULL,};
-
-    /* Perform yadif filtering */
-    for( frame = 0; frame < num_frames; frame++ )
-    {
-        int parity = frame ^ tff ^ 1;
-
-        if (o_buf[idx] == NULL)
-        {
-            o_buf[idx] = hb_frame_buffer_init(in->f.fmt,
-                                              in->f.width, in->f.height);
-        }
-        yadif_filter(pv, o_buf[idx], parity, tff);
-
-        // If bob, add both frames
-        // else, add only final frame
-        if (( pv->yadif_mode & MODE_YADIF_BOB ) || frame == num_frames - 1)
-        {
-            /* Copy buffered settings to output buffer settings */
-            o_buf[idx]->s = pv->yadif_ref[1]->s;
-            o_buf[idx]->next = NULL;
-            hb_buffer_list_append(&list, o_buf[idx]);
-
-            // Indicate that buffer was consumed
-            o_buf[idx] = NULL;
-            idx ^= 1;
-        }
-    }
-    hb_buffer_close(&o_buf[0]);
-    hb_buffer_close(&o_buf[1]);
-
-    /* if bob mode is engaged, halve the duration of the
-     * timestamps. */
-    if (pv->yadif_mode & MODE_YADIF_BOB)
-    {
-        hb_buffer_t *first = hb_buffer_list_head(&list);
-        hb_buffer_t *second = hb_buffer_list_tail(&list);
-        first->s.stop -= (first->s.stop - first->s.start) / 2LL;
-        second->s.start = first->s.stop;
-        second->s.new_chap = 0;
-    }
-
-    *buf_out = hb_buffer_list_clear(&list);
-    return HB_FILTER_OK;
-}
-
diff --git a/libhb/libhb_presets.list b/libhb/libhb_presets.list
index cc972f0f2..4afc94091 100644
--- a/libhb/libhb_presets.list
+++ b/libhb/libhb_presets.list
@@ -1,7 +1,7 @@
 <resources>
     <section name="PresetTemplate">
         <integer name="VersionMajor" value="11" />
-        <integer name="VersionMinor" value="0" />
+        <integer name="VersionMinor" value="1" />
         <integer name="VersionMicro" value="0" />
         <json name="Preset" file="preset_template.json" />
     </section>
diff --git a/libhb/param.c b/libhb/param.c
index 8deaed3c3..3a9402021 100644
--- a/libhb/param.c
+++ b/libhb/param.c
@@ -67,13 +67,14 @@ static hb_filter_param_t decomb_presets[] =
 
 static hb_filter_param_t deinterlace_presets[] =
 {
-    { 1, "Custom",      "custom",     NULL              },
-    { 2, "Fast",        "fast",       "0:-1:-1:0:1"     },
-    { 3, "Slow",        "slow",       "1:-1:-1:0:1"     },
-    { 4, "Slower",      "slower",     "3:-1:-1:0:1"     },
-    { 5, "Bob",         "bob",        "15:-1:-1:0:1"    },
-    { 0,  NULL,         NULL,         NULL              },
-    { 2, "Default",     "default",    "0:-1:-1:0:1"     }
+    { 1, "Custom",             "custom",       NULL              },
+    { 3, "Default",            "default",      "3:-1"            },
+    { 2, "Skip Spatial Check", "skip-spatial", "1:-1"            },
+    { 5, "Bob",                "bob",          "7:-1"            },
+    { 0,  NULL,                NULL,           NULL              },
+    { 2, "Fast",               "fast",         "1:-1:"           },
+    { 3, "Slow",               "slow",         "3:-1:"           },
+    { 4, "Slower",             "slower",       "3:-1:"           }
 };
 
 typedef struct
@@ -104,7 +105,58 @@ static filter_param_map_t param_map[] =
     { HB_FILTER_INVALID,     NULL,                NULL, 0        }
 };
 
-/* Settings:
+#define MODE_YADIF_ENABLE       1
+#define MODE_YADIF_SPATIAL      2
+#define MODE_YADIF_BOB          4
+
+/* Deinterlace Settings
+ *  mode:parity
+ *
+ *  mode   - yadif deinterlace mode
+ *  parity - field parity
+ *
+ *  Modes:
+ *      1 = Enabled
+ *      2 = Spatial
+ *      4 = Bob
+ *
+ *  Parity:
+ *      0  = Top Field First
+ *      1  = Bottom Field First
+ *      -1 = Automatic detection of field parity
+ */
+char *
+generate_deinterlace_settings(const char * settings)
+{
+    char       ** args;
+    char       * result;
+    int          ii, mode = 3, parity = -1;
+
+    args = hb_str_vsplit(settings, ':');
+    for (ii = 0; ii < 2 && args[ii]; ii++)
+    {
+        switch (ii)
+        {
+            case 0:
+                mode   = strtol(args[ii], &result, 0);
+                break;
+            case 1:
+                parity = strtol(args[ii], &result, 0);
+                break;
+        }
+    }
+    if (!(mode & MODE_YADIF_ENABLE))
+    {
+        return (char*)hb_filter_off;
+    }
+    int bob        = !!(mode & MODE_YADIF_BOB);
+    int no_spatial = !(mode & MODE_YADIF_SPATIAL);
+    mode = bob | (no_spatial << 1);
+
+    return hb_strdup_printf("yadif='mode=%d:parity=%d'", mode, parity);
+}
+
+/* Rotate Settings:
  *  degrees:mirror
  *
  *  degrees - Rotation angle, may be one of 90, 180, or 270
@@ -700,12 +752,22 @@ hb_generate_filter_settings_by_index(int filter_id, int preset,
                 filter_param = hb_strdup_printf("%d", preset);
             break;
         case HB_FILTER_DECOMB:
-        case HB_FILTER_DEINTERLACE:
         case HB_FILTER_DETELECINE:
         case HB_FILTER_HQDN3D:
             filter_param = generate_generic_settings_by_index(filter_id,
                                                               preset, custom);
             break;
+        case HB_FILTER_DEINTERLACE:
+        {
+            char * s;
+            s = generate_generic_settings_by_index(filter_id, preset, custom);
+            if (s == NULL || hb_validate_filter_settings(filter_id, s))
+            {
+                free(s);
+                return NULL;
+            }
+            return generate_deinterlace_settings(s);
+        } break;
         default:
             fprintf(stderr,
                     "hb_generate_filter_settings: Unrecognized filter (%d).\n",
@@ -754,11 +816,21 @@ hb_generate_filter_settings(int filter_id, const char *preset, const char *tune)
                 filter_param = strdup(preset);
             break;
         case HB_FILTER_DECOMB:
-        case HB_FILTER_DEINTERLACE:
         case HB_FILTER_DETELECINE:
         case HB_FILTER_HQDN3D:
             filter_param = generate_generic_settings(filter_id, preset, tune);
             break;
+        case HB_FILTER_DEINTERLACE:
+        {
+            char * s;
+            s = generate_generic_settings(filter_id, preset, tune);
+            if (s == NULL || hb_validate_filter_settings(filter_id, s))
+            {
+                free(s);
+                return NULL;
+            }
+            return generate_deinterlace_settings(s);
+        } break;
         default:
             fprintf(stderr,
                     "hb_generate_filter_settings: Unrecognized filter (%d).\n",
diff --git a/libhb/preset.c b/libhb/preset.c
index bc84965e1..1670b469b 100644
--- a/libhb/preset.c
+++ b/libhb/preset.c
@@ -1969,6 +1969,79 @@ void hb_presets_clean(hb_value_t *preset)
     presets_clean(preset, hb_preset_template);
 }
 
+static void import_deint_11_0_0(hb_value_t *preset)
+{
+    hb_value_t *val = hb_dict_get(preset, "PictureDeinterlaceFilter");
+    if (val == NULL)
+    {
+        return;
+    }
+    const char * deint = hb_value_get_string(val);
+    if (deint == NULL)
+    {
+        // This really shouldn't happen for a valid preset
+        return;
+    }
+    if (strcasecmp(deint, "deinterlace"))
+    {
+        return;
+    }
+    val = hb_dict_get(preset, "PictureDeinterlacePreset");
+    if (val == NULL)
+    {
+        hb_dict_set(preset, "PictureDeinterlacePreset",
+                    hb_value_string("default"));
+        return;
+    }
+    deint = hb_value_get_string(val);
+    if (deint == NULL)
+    {
+        // This really shouldn't happen for a valid preset
+        return;
+    }
+    if (!strcasecmp(deint, "fast") || !strcasecmp(deint, "slow"))
+    {
+        // fast and slow -> skip-spatial
+        hb_dict_set(preset, "PictureDeinterlacePreset",
+                    hb_value_string("skip-spatial"));
+        return;
+    }
+    else if (!strcasecmp(deint, "bob") || !strcasecmp(deint, "default"))
+    {
+        return;
+    }
+    else if (strcasecmp(deint, "custom"))
+    {
+        // not custom -> default
+        hb_dict_set(preset, "PictureDeinterlacePreset",
+                    hb_value_string("default"));
+        return;
+    }
+    val = hb_dict_get(preset, "PictureDeinterlaceCustom");
+    if (val == NULL)
+    {
+        hb_dict_set(preset, "PictureDeinterlacePreset",
+                    hb_value_string("default"));
+        return;
+    }
+    // Translate custom values
+    deint = hb_value_get_string(val);
+    if (deint == NULL)
+    {
+        // This really shouldn't happen for a valid preset
+        return;
+    }
+    int bob, spatial, yadif, mode = 3, parity = -1;
+    sscanf(deint, "%d:%d", &mode, &parity);
+    yadif   = !!(mode & 1);
+    spatial = !!(mode & 2);
+    bob     = !!(mode & 8);
+    mode = yadif + (yadif && spatial) * 2 + bob * 4;
+    char * custom = hb_strdup_printf("%d:%d", mode, parity);
+    hb_dict_set(preset, "PictureDeinterlaceCustom", hb_value_string(custom));
+    free(custom);
+}
+
 static void import_deint_10_0_0(hb_value_t *preset)
 {
     hb_value_t *val = hb_dict_get(preset, "PictureDecombDeinterlace");
@@ -2002,6 +2075,7 @@ static void import_deint_10_0_0(hb_value_t *preset)
                         hb_value_string("default"));
         }
     }
+    import_deint_11_0_0(preset);
 }
 
 static const char* import_indexed_filter(int filter_id, int index)
@@ -2277,6 +2351,11 @@ static void import_10_0_0(hb_value_t *preset)
     import_deint_10_0_0(preset);
 }
 
+static void import_11_0_0(hb_value_t *preset)
+{
+    import_deint_11_0_0(preset);
+}
+
 static int preset_import(hb_value_t *preset, int major, int minor, int micro)
 {
     int result = 0;
@@ -2294,6 +2373,11 @@ static int preset_import(hb_value_t *preset, int major, int minor, int micro)
             import_10_0_0(preset);
             result = 1;
         }
+        else if (major == 11 && minor == 0 && micro == 0)
+        {
+            import_11_0_0(preset);
+            result = 1;
+        }
         preset_clean(preset, hb_preset_template);
     }
     return result;
@@ -2321,6 +2405,28 @@ int hb_presets_version(hb_value_t *preset, int *major, int *minor, int *micro)
     return -1;
 }
 
+void hb_presets_update_version(hb_value_t *preset)
+{
+    if (hb_value_type(preset) == HB_VALUE_TYPE_DICT)
+    {
+        // Is this a single preset or a packaged collection of presets?
+        hb_value_t *val = hb_dict_get(preset, "PresetName");
+        if (val == NULL)
+        {
+            val = hb_dict_get(preset, "VersionMajor");
+            if (val != NULL)
+            {
+                hb_dict_set(preset, "VersionMajor",
+                            hb_value_int(hb_preset_version_major));
+                hb_dict_set(preset, "VersionMinor",
+                            hb_value_int(hb_preset_version_minor));
+                hb_dict_set(preset, "VersionMicro",
+                            hb_value_int(hb_preset_version_micro));
+            }
+        }
+    }
+}
+
 int hb_presets_import(hb_value_t *preset)
 {
     preset_import_context_t ctx;
@@ -2329,6 +2435,10 @@ int hb_presets_import(hb_value_t *preset)
     ctx.result = 0;
     hb_presets_version(preset, &ctx.major, &ctx.minor, &ctx.micro);
     presets_do(do_preset_import, preset, (preset_do_context_t*)&ctx);
+    if (ctx.result)
+    {
+        hb_presets_update_version(preset);
+    }
 
     return ctx.result;
 }