taskset_t eedi2_taskset; // Threads for eedi2 - one per plane
};
+typedef struct
+{
+ int tap[5];
+ int normalize;
+} filter_param_t;
+
static int hb_decomb_init( hb_filter_object_t * filter,
hb_filter_init_t * init );
.close = hb_decomb_close,
};
-int cubic_interpolate_pixel( int y0, int y1, int y2, int y3 )
+// Borrowed from libav
+#define times4(x) x, x, x, x
+#define times1024(x) times4(times4(times4(times4(times4(x)))))
+
+static const uint8_t hb_crop_table[256 + 2 * 1024] = {
+times1024(0x00),
+0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
+0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
+0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
+0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
+0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
+0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
+0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
+0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
+0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
+0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
+0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
+0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
+0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
+0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
+0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
+0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,
+times1024(0xFF)
+};
+
+static inline int cubic_interpolate_pixel( int y0, int y1, int y2, int y3 )
{
/* From http://www.neuron2.net/library/cubicinterp.html */
int result = ( y0 * -3 ) + ( y1 * 23 ) + ( y2 * 23 ) + ( y3 * -3 );
- result /= 40;
-
- if( result > 255 )
- {
- result = 255;
- }
- else if( result < 0 )
- {
- result = 0;
- }
+ result = hb_crop_table[(result / 40) + 1024];
return result;
}
}
}
-void draw_mask_box( hb_filter_private_t * pv )
+static void draw_mask_box( hb_filter_private_t * pv )
{
int x = pv->mask_box_x;
int y = pv->mask_box_y;
}
}
-void apply_mask_line( uint8_t * srcp,
- uint8_t * mskp,
- int width )
+static void apply_mask_line( uint8_t * srcp,
+ uint8_t * mskp,
+ int width )
{
int x;
}
}
-void apply_mask(hb_filter_private_t * pv, hb_buffer_t * b)
+static void apply_mask(hb_filter_private_t * pv, hb_buffer_t * b)
{
/* draw_boxes */
draw_mask_box( pv );
pv->ref[2] = b;
}
-int blend_filter_pixel( int up2, int up1, int current, int down1, int down2 )
+static inline int blend_filter_pixel(filter_param_t *filter, int up2, int up1, int current, int down1, int down2)
{
/* Low-pass 5-tap filter */
int result = 0;
- result += -up2;
- result += up1 * 2;
- result += current * 6;
- result += down1 *2;
- result += -down2;
- result /= 8;
- if( result > 255 )
- {
- result = 255;
- }
- if( result < 0 )
- {
- result = 0;
- }
+ result += up2 * filter->tap[0];
+ result += up1 * filter->tap[1];
+ result += current * filter->tap[2];
+ result += down1 * filter->tap[3];
+ result += down2 * filter->tap[4];
+ result >>= filter->normalize;
+ result = hb_crop_table[result + 1024];
return result;
}
-static void blend_filter_line( uint8_t *dst,
+static void blend_filter_line(filter_param_t *filter,
+ uint8_t *dst,
uint8_t *cur,
int width,
int height,
for( x = 0; x < w; x++)
{
- dst[0] = blend_filter_pixel( cur[up2], cur[up1], cur[0],
- cur[down1], cur[down2] );
-
+ /* Low-pass 5-tap filter */
+ dst[0] = blend_filter_pixel(filter, cur[up2], cur[up1], cur[0],
+ cur[down1], cur[down2] );
dst++;
cur++;
}
}
-void reset_combing_results( hb_filter_private_t * pv )
+static void reset_combing_results( hb_filter_private_t * pv )
{
pv->comb_check_complete = 0;
int ii;
}
}
-int check_combing_results( hb_filter_private_t * pv )
+static int check_combing_results( hb_filter_private_t * pv )
{
int threshold = pv->block_threshold;
int send_to_blend = 0;
}
}
-void check_filtered_combing_mask( hb_filter_private_t * pv, int segment, int start, int stop )
+static void check_filtered_combing_mask( hb_filter_private_t * pv, int segment, int start, int stop )
{
/* Go through the mask in X*Y blocks. If any of these windows
have threshold or more combed pixels, consider the whole
}
}
-void check_combing_mask( hb_filter_private_t * pv, int segment, int start, int stop )
+static void check_combing_mask( hb_filter_private_t * pv, int segment, int start, int stop )
{
/* Go through the mask in X*Y blocks. If any of these windows
have threshold or more combed pixels, consider the whole
}
}
-void build_gamma_lut( hb_filter_private_t * pv )
+static void build_gamma_lut( hb_filter_private_t * pv )
{
int i;
for( i = 0; i < 256; i++ )
}
}
-float scale_gamma( int pixel, hb_filter_private_t * pv )
-{
- return pv->gamma_lut[pixel];
-}
-
-void detect_gamma_combed_segment( hb_filter_private_t * pv, int segment_start, int segment_stop )
+static void detect_gamma_combed_segment( hb_filter_private_t * pv, int segment_start, int segment_stop )
{
/* A mish-mash of various comb detection tricks
picked up from neuron2's Decomb plugin for
fabs( pv->gamma_lut[prev[down_1]] - pv->gamma_lut[cur[down_1]] ) > mthresh )
motion++;
-// hb_log("prev->cur motion: %f, mthresh: %f", fabs( scale_gamma( prev[0] ) - scale_gamma( cur[0] ) ), mthresh);
}
else
{
}
-void detect_combed_segment( hb_filter_private_t * pv, int segment_start, int segment_stop )
+static void detect_combed_segment( hb_filter_private_t * pv, int segment_start, int segment_stop )
{
/* A mish-mash of various comb detection tricks
picked up from neuron2's Decomb plugin for
// This function calls all the eedi2 filters in sequence for a given plane.
// It outputs the final interpolated image to pv->eedi_full[DST2PF].
-void eedi2_interpolate_plane( hb_filter_private_t * pv, int plane )
+static void eedi2_interpolate_plane( hb_filter_private_t * pv, int plane )
{
/* We need all these pointers. No, seriously.
I swear. It's not a joke. They're used.
/*
* eedi2 interpolate this plane in a single thread.
*/
-void eedi2_filter_thread( void *thread_args_v )
+static void eedi2_filter_thread( void *thread_args_v )
{
hb_filter_private_t * pv;
int plane;
* Process plane
*/
eedi2_interpolate_plane( pv, plane );
-
+
/*
* Finished this segment, let everyone know.
*/
// Sets up the input field planes for EEDI2 in pv->eedi_half[SRCPF]
// and then runs eedi2_filter_thread for each plane.
-void eedi2_planer( hb_filter_private_t * pv )
+static void eedi2_planer( hb_filter_private_t * pv )
{
/* Copy the first field from the source to a half-height frame. */
int pp;
}
-void mask_dilate_thread( void *thread_args_v )
+static void mask_dilate_thread( void *thread_args_v )
{
hb_filter_private_t * pv;
int segment, segment_start, segment_stop;
* No more work to do, exit this thread.
*/
break;
- }
+ }
int xx, yy, pp;
taskset_thread_complete( &pv->mask_dilate_taskset, segment );
}
-void mask_erode_thread( void *thread_args_v )
+static void mask_erode_thread( void *thread_args_v )
{
hb_filter_private_t * pv;
int segment, segment_start, segment_stop;
* No more work to do, exit this thread.
*/
break;
- }
+ }
int xx, yy, pp;
taskset_thread_complete( &pv->mask_erode_taskset, segment );
}
-void mask_filter_thread( void *thread_args_v )
+static void mask_filter_thread( void *thread_args_v )
{
hb_filter_private_t * pv;
int segment, segment_start, segment_stop;
* No more work to do, exit this thread.
*/
break;
- }
+ }
int xx, yy, pp;
taskset_thread_complete( &pv->mask_filter_taskset, segment );
}
-void decomb_check_thread( void *thread_args_v )
+static void decomb_check_thread( void *thread_args_v )
{
hb_filter_private_t * pv;
int segment, segment_start, segment_stop;
* No more work to do, exit this thread.
*/
break;
- }
+ }
segment_start = thread_args->segment_start[0];
segment_stop = segment_start + thread_args->segment_height[0];
/*
* comb detect this segment of all three planes in a single thread.
*/
-void decomb_filter_thread( void *thread_args_v )
+static void decomb_filter_thread( void *thread_args_v )
{
hb_filter_private_t * pv;
int segment, segment_start, segment_stop;
* No more work to do, exit this thread.
*/
break;
- }
+ }
/*
* Process segment (for now just from luma)
taskset_thread_complete( &pv->decomb_filter_taskset, segment );
}
-int comb_segmenter( hb_filter_private_t * pv )
+static int comb_segmenter( hb_filter_private_t * pv )
{
/*
* Now that all data for decomb detection is ready for
* our threads, fire them off and wait for their completion.
*/
taskset_cycle( &pv->decomb_filter_taskset );
-
+
if( pv->mode & MODE_FILTER )
{
taskset_cycle( &pv->mask_filter_taskset );
/*
* deinterlace this segment of all three planes in a single thread.
*/
-void yadif_decomb_filter_thread( void *thread_args_v )
+static void yadif_decomb_filter_thread( void *thread_args_v )
{
yadif_arguments_t *yadif_work = NULL;
hb_filter_private_t * pv;
int segment, segment_start, segment_stop;
yadif_thread_arg_t *thread_args = thread_args_v;
+ filter_param_t filter;
+
+ filter.tap[0] = -1;
+ filter.tap[1] = 2;
+ filter.tap[2] = 6;
+ filter.tap[3] = 2;
+ filter.tap[4] = -1;
+ filter.normalize = 3;
pv = thread_args->pv;
segment = thread_args->segment;
* 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.
*/
break;
- }
+ }
yadif_work = &pv->yadif_arguments[segment];
for( yy = start; yy < segment_stop; yy += 2 )
{
/* This line gets blend filtered, not yadif filtered. */
- blend_filter_line(dst2, cur, width, height, stride, yy);
+ blend_filter_line(&filter, dst2, cur, width, height, stride, yy);
dst2 += stride * 2;
cur += stride * 2;
}
pv->yadif_ready = 0;
- pv->mode = MODE_YADIF | MODE_BLEND | MODE_CUBIC |
+ pv->mode = MODE_YADIF | MODE_BLEND | MODE_CUBIC |
MODE_GAMMA | MODE_FILTER;
pv->filter_mode = FILTER_ERODE_DILATE;
pv->spatial_metric = 2;
init->pix_fmt, init->width, init->height);
}
}
-
+
/*
* Setup yadif taskset.
*/
for( ii = 0; ii < pv->cpu_count; ii++ )
{
decomb_thread_arg_t *thread_args;
-
+
thread_args = taskset_thread_args( &pv->decomb_filter_taskset, ii );
thread_args->pv = pv;
thread_args->segment = ii;
for( ii = 0; ii < pv->comb_check_nthreads; ii++ )
{
decomb_thread_arg_t *thread_args, *decomb_prev_thread_args = NULL;
-
+
thread_args = taskset_thread_args( &pv->decomb_check_taskset, ii );
thread_args->pv = pv;
thread_args->segment = ii;
for( ii = 0; ii < pv->cpu_count; ii++ )
{
decomb_thread_arg_t *thread_args;
-
+
thread_args = taskset_thread_args( &pv->mask_filter_taskset, ii );
thread_args->pv = pv;
thread_args->segment = ii;
for( ii = 0; ii < pv->cpu_count; ii++ )
{
decomb_thread_arg_t *thread_args;
-
+
thread_args = taskset_thread_args( &pv->mask_erode_taskset, ii );
thread_args->pv = pv;
thread_args->segment = ii;
for( ii = 0; ii < pv->cpu_count; ii++ )
{
decomb_thread_arg_t *thread_args;
-
+
thread_args = taskset_thread_args( &pv->mask_dilate_taskset, ii );
thread_args->pv = pv;
thread_args->segment = ii;
}
}
}
-
+
return 0;
}
taskset_fini( &pv->eedi2_taskset );
}
-
+
/* Cleanup reference buffers. */
int ii;
for (ii = 0; ii < 3; ii++)
if (pv->cxy) eedi2_aligned_free(pv->cxy);
if (pv->tmpc) eedi2_aligned_free(pv->tmpc);
}
-
+
free(pv->block_score);
/*
* free memory for yadif structs
*/
free( pv->yadif_arguments );
-
+
free( pv );
filter->private_data = NULL;
}
{
num_frames = 2;
}
-
+
// Will need up to 2 buffers simultaneously
int idx = 0;
hb_buffer_t * o_buf[2] = {NULL,};
- /* Perform yadif filtering */
+ /* Perform yadif filtering */
for( frame = 0; frame < num_frames; frame++ )
{
int parity = frame ^ tff ^ 1;
return HB_FILTER_OK;
}
+
+void hb_deinterlace(hb_buffer_t *dst, hb_buffer_t *src)
+{
+ int pp;
+ filter_param_t filter;
+
+ filter.tap[0] = -1;
+ filter.tap[1] = 4;
+ filter.tap[2] = 2;
+ filter.tap[3] = 4;
+ filter.tap[4] = -1;
+ filter.normalize = 3;
+
+ for (pp = 0; pp < 3; pp++)
+ {
+ int yy;
+ int width = src->plane[pp].width;
+ int stride = src->plane[pp].stride;
+ int height = src->plane[pp].height;
+
+ // Filter parity lines
+ uint8_t *pdst = &dst->plane[pp].data[0];
+ uint8_t *psrc = &src->plane[pp].data[0];
+
+ /* These will be useful if we ever do temporal blending. */
+ for( yy = 0; yy < height; yy += 2 )
+ {
+ /* This line gets blend filtered, not yadif filtered. */
+ memcpy(pdst, psrc, width);
+ pdst += stride;
+ psrc += stride;
+ blend_filter_line(&filter, pdst, psrc, width, height, stride, yy);
+ pdst += stride;
+ psrc += stride;
+ }
+ }
+}
+
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;
hb_buffer_t * yadif_ref[3];
int cpu_count;
+ int segments;
+
+ int deint_nsegs;
- taskset_t yadif_taskset; // Threads for Yadif - one per CPU
+ 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
};
*/
run = 0;
goto report_completion;
- }
+ }
yadif_work = &pv->yadif_arguments[segment];
if( yadif_work->dst == NULL )
{
hb_error( "Thread started when no work available" );
- hb_snooze(500);
goto report_completion;
}
-
+
/*
* Process all three planes, but only this segment of it.
*/
int tff = yadif_work->tff;
int penultimate = h - 2;
- int segment_height = (h / pv->cpu_count) & ~1;
+ int segment_height = (h / pv->segments) & ~1;
segment_start = segment_height * segment;
- if( segment == pv->cpu_count - 1 )
+ if( segment == pv->segments - 1 )
{
/*
* Final segment
{
/* This isn't the top or bottom,
* proceed as normal to yadif. */
- yadif_filter_line(pv, dst2, prev, cur, next, w, s,
+ yadif_filter_line(pv, dst2, prev, cur, next, w, s,
parity ^ tff);
}
else
int segment;
- for( segment = 0; segment < pv->cpu_count; segment++ )
- {
+ for( segment = 0; segment < pv->segments; segment++ )
+ {
/*
* Setup the work for this plane.
*/
*/
}
+/*
+ * 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;
+
+ 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 );
+ }
+
+ hb_buffer_t *first = NULL, *last = NULL;
+ 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;
+ if (first == NULL)
+ {
+ first = dst;
+ }
+ if (last != NULL)
+ {
+ last->next = dst;
+ }
+ last = dst;
+
+ dst->s = src->s;
+ hb_buffer_move_subs(dst, src);
+ hb_buffer_close(&src);
+ }
+ if (in == NULL)
+ {
+ // Flushing final buffers. Append EOS marker buffer.
+ dst = hb_buffer_init(0);
+ if (first == NULL)
+ {
+ first = dst;
+ }
+ else
+ {
+ last->next = dst;
+ }
+ }
+ pv->deint_nsegs = 0;
+
+ return first;
+}
+
static int hb_deinterlace_init( hb_filter_object_t * filter,
hb_filter_init_t * init )
{
/*
* Setup yadif taskset.
*/
- pv->yadif_arguments = malloc( sizeof( yadif_arguments_t ) * pv->cpu_count );
+ 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->cpu_count,
- sizeof( yadif_arguments_t ) ) == 0 )
+ 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->cpu_count; ii++ )
+ for( ii = 0; ii < pv->segments; ii++ )
{
yadif_thread_arg_t *thread_args;
}
}
}
-
+ 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;
}
free( pv->yadif_arguments );
}
-
+ else
+ {
+ taskset_fini( &pv->deint_taskset );
+ free( pv->deint_arguments );
+ }
+
free( pv );
filter->private_data = NULL;
}
-static hb_buffer_t * deint_fast(hb_buffer_t * in)
-{
- AVPicture pic_in;
- AVPicture pic_out;
- hb_buffer_t * out;
-
- int w = (in->plane[0].width + 3) & ~0x3;
- int h = (in->plane[0].height + 3) & ~0x3;
-
- out = hb_frame_buffer_init(in->f.fmt, in->f.width, in->f.height);
-
- hb_avpicture_fill( &pic_in, in );
- hb_avpicture_fill( &pic_out, out );
-
- // avpicture_deinterlace requires 4 pixel aligned width and height
- // we have aligned all buffers to 16 byte width and height strides
- // so there is room in the buffers to accomodate a litte
- // overscan.
- avpicture_deinterlace(&pic_out, &pic_in, out->f.fmt, w, h);
-
- out->s = in->s;
- hb_buffer_move_subs(out, in);
-
- return out;
-}
-
static int hb_deinterlace_work( hb_filter_object_t * filter,
hb_buffer_t ** buf_in,
hb_buffer_t ** buf_out )
{
*buf_out = in;
*buf_in = NULL;
+ if( !( pv->yadif_mode & MODE_YADIF_ENABLE ) )
+ {
+ // Flush final frames
+ *buf_out = deint_fast(pv, NULL);
+ }
return HB_FILTER_DONE;
}
/* Use libavcodec deinterlace if yadif_mode < 0 */
if( !( pv->yadif_mode & MODE_YADIF_ENABLE ) )
{
- *buf_out = deint_fast(in);
+ *buf_in = NULL;
+ *buf_out = deint_fast(pv, in);
return HB_FILTER_OK;
}
projects / handbrake / commitdiff