/*
 * filter_telecide.c -- Donald Graft's Inverse Telecine Filter
 * Copyright (C) 2003 Donald A. Graft
 * Copyright (C) 2008 Dan Dennedy <dan@dennedy.org>
 * Author: Dan Dennedy <dan@dennedy.org>
 *
 * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <framework/mlt.h>

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

//#define DEBUG_PATTERN_GUIDANCE

#define MAX_CYCLE 6
#define BLKSIZE 24
#define BLKSIZE_TIMES2 (2 * BLKSIZE)
#define GUIDE_32 1
#define GUIDE_22 2
#define GUIDE_32322 3
#define AHEAD 0
#define BEHIND 1
#define POST_METRICS 1
#define POST_FULL 2
#define POST_FULL_MAP 3
#define POST_FULL_NOMATCH 4
#define POST_FULL_NOMATCH_MAP 5
#define CACHE_SIZE 100000
#define P 0
#define C 1
#define N 2
#define PBLOCK 3
#define CBLOCK 4

#define NO_BACK 0
#define BACK_ON_COMBED 1
#define ALWAYS_BACK 2

struct CACHE_ENTRY
{
	unsigned int frame;
	unsigned int metrics[5];
	unsigned int chosen;
};

struct PREDICTION
{
	unsigned int metric;
	unsigned int phase;
	unsigned int predicted;
	unsigned int predicted_metric;
};

struct context_s {
	int is_configured;
	mlt_properties image_cache;
	int out;
	
	int tff, chroma, blend, hints, show, debug;
	float dthresh, gthresh, vthresh, vthresh_saved, bthresh;
	int y0, y1, nt, guide, post, back, back_saved;
	int pitch, dpitch, pitchover2, pitchtimes4;
	int w, h, wover2, hover2, hplus1over2, hminus2;
  	int xblocks, yblocks;
#ifdef WINDOWED_MATCH
	unsigned int *matchc, *matchp, highest_matchc, highest_matchp;
#endif
	unsigned int *sumc, *sump, highest_sumc, highest_sump;
	int vmetric;
	unsigned int *overrides, *overrides_p;
	int film, override, inpattern, found;
	int force;

	// Used by field matching.
	unsigned char *fprp, *fcrp, *fcrp_saved, *fnrp;
//	unsigned char *fprpU, *fcrpU, *fcrp_savedU, *fnrpU;
//	unsigned char *fprpV, *fcrpV, *fcrp_savedV, *fnrpV;
	unsigned char *dstp, *finalp;
//	unsigned char *dstpU, *dstpV;
	int chosen;
	unsigned int p, c, pblock, cblock, lowest, predicted, predicted_metric;
	unsigned int np, nc, npblock, ncblock, nframe;
	float mismatch;
	int pframe, x, y;
	unsigned char *crp, *prp;
	unsigned char *crpU, *prpU;
	unsigned char *crpV, *prpV;
	int hard;
	char status[80];

	// Metrics cache.
	struct CACHE_ENTRY *cache;

	// Pattern guidance data.
	int cycle;
	struct PREDICTION pred[MAX_CYCLE+1];
};
typedef struct context_s *context;


static inline
void BitBlt(uint8_t* dstp, int dst_pitch, const uint8_t* srcp,
            int src_pitch, int row_size, int height)
{
	uint32_t y;
	for(y=0;y<height;y++)
	{
		memcpy(dstp,srcp,row_size);
		dstp+=dst_pitch;
		srcp+=src_pitch;
	}
}

static void Show(context cx, int frame, mlt_properties properties)
{
	char use;
	char buf[512];

	if (cx->chosen == P) use = 'p';
	else if (cx->chosen == C) use = 'c';
	else use = 'n';
	snprintf(buf, sizeof(buf), "Telecide: frame %d: matches: %d %d %d\n", frame, cx->p, cx->c, cx->np);
	if ( cx->post )
		snprintf(buf, sizeof(buf), "%sTelecide: frame %d: vmetrics: %d %d %d [chosen=%d]\n", buf, frame, cx->pblock, cx->cblock, cx->npblock, cx->vmetric);
	if ( cx->guide )
		snprintf(buf, sizeof(buf), "%spattern mismatch=%0.2f%%\n", buf, cx->mismatch);
	snprintf(buf, sizeof(buf), "%sTelecide: frame %d: [%s %c]%s %s\n", buf, frame, cx->found ? "forcing" : "using", use,
		cx->post ? (cx->film ? " [progressive]" : " [interlaced]") : "",
		cx->guide ? cx->status : "");
	mlt_properties_set( properties, "meta.attr.telecide.markup", buf );
}

static void Debug(context cx, int frame)
{
	char use;

	if (cx->chosen == P) use = 'p';
	else if (cx->chosen == C) use = 'c';
	else use = 'n';
	fprintf(stderr, "Telecide: frame %d: matches: %d %d %d\n", frame, cx->p, cx->c, cx->np);
	if ( cx->post )
		fprintf(stderr, "Telecide: frame %d: vmetrics: %d %d %d [chosen=%d]\n", frame, cx->pblock, cx->cblock, cx->npblock, cx->vmetric);
	if ( cx->guide )
		fprintf(stderr, "pattern mismatch=%0.2f%%\n", cx->mismatch); 
	fprintf(stderr, "Telecide: frame %d: [%s %c]%s %s\n", frame, cx->found ? "forcing" : "using", use,
		cx->post ? (cx->film ? " [progressive]" : " [interlaced]") : "",
		cx->guide ? cx->status : "");
}

static void WriteHints(int film, int inpattern, mlt_properties frame_properties)
{
	mlt_properties_set_int( frame_properties, "telecide.progressive", film);
	mlt_properties_set_int( frame_properties, "telecide.in_pattern", inpattern);
}

static void PutChosen(context cx, int frame, unsigned int chosen)
{
	int f = frame % CACHE_SIZE;
	if (frame < 0 || frame > cx->out || cx->cache[f].frame != frame)
		return;
	cx->cache[f].chosen = chosen;
}

static void CacheInsert(context cx, int frame, unsigned int p, unsigned int pblock,
					 unsigned int c, unsigned int cblock)
{
	int f = frame % CACHE_SIZE;
	if (frame < 0 || frame > cx->out)
		fprintf( stderr, "%s: internal error: invalid frame %d for CacheInsert", __FUNCTION__, frame);
	cx->cache[f].frame = frame;
	cx->cache[f].metrics[P] = p;
	if (f) cx->cache[f-1].metrics[N] = p;
	cx->cache[f].metrics[C] = c;
	cx->cache[f].metrics[PBLOCK] = pblock;
	cx->cache[f].metrics[CBLOCK] = cblock;
	cx->cache[f].chosen = 0xff;
}

static int CacheQuery(context cx, int frame, unsigned int *p, unsigned int *pblock,
					unsigned int *c, unsigned int *cblock)
{
	int f;

	f = frame % CACHE_SIZE;
	if (frame < 0 || frame > cx->out)
		fprintf( stderr, "%s: internal error: invalid frame %d for CacheQuery", __FUNCTION__, frame);
	if (cx->cache[f].frame != frame)
	{
		return 0;
	}
	*p = cx->cache[f].metrics[P];
	*c = cx->cache[f].metrics[C];
	*pblock = cx->cache[f].metrics[PBLOCK];
	*cblock = cx->cache[f].metrics[CBLOCK];
	return 1;
}

static int PredictHardYUY2(context cx, int frame, unsigned int *predicted, unsigned int *predicted_metric)
{
	// Look for pattern in the actual delivered matches of the previous cycle of frames.
	// If a pattern is found, use that to predict the current match.
	if ( cx->guide == GUIDE_22 )
	{
		if (cx->cache[(frame- cx->cycle)%CACHE_SIZE  ].chosen == 0xff ||
			cx->cache[(frame- cx->cycle+1)%CACHE_SIZE].chosen == 0xff)
			return 0;
		switch ((cx->cache[(frame- cx->cycle)%CACHE_SIZE  ].chosen << 4) +
				(cx->cache[(frame- cx->cycle+1)%CACHE_SIZE].chosen))
		{
		case 0x11:
			*predicted = C;
			*predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C];
			break;
		case 0x22:
			*predicted = N;
			*predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N];
			break;
		default: return 0;
		}
	}
	else if ( cx->guide == GUIDE_32 )
	{
		if (cx->cache[(frame-cx->cycle)%CACHE_SIZE  ].chosen == 0xff ||
			cx->cache[(frame-cx->cycle+1)%CACHE_SIZE].chosen == 0xff ||
			cx->cache[(frame-cx->cycle+2)%CACHE_SIZE].chosen == 0xff ||
			cx->cache[(frame-cx->cycle+3)%CACHE_SIZE].chosen == 0xff ||
			cx->cache[(frame-cx->cycle+4)%CACHE_SIZE].chosen == 0xff)
			return 0;

		switch ((cx->cache[(frame-cx->cycle)%CACHE_SIZE  ].chosen << 16) +
				(cx->cache[(frame-cx->cycle+1)%CACHE_SIZE].chosen << 12) +
				(cx->cache[(frame-cx->cycle+2)%CACHE_SIZE].chosen <<  8) +
				(cx->cache[(frame-cx->cycle+3)%CACHE_SIZE].chosen <<  4) +
				(cx->cache[(frame-cx->cycle+4)%CACHE_SIZE].chosen))
		{
		case 0x11122:
		case 0x11221:
		case 0x12211:
		case 0x12221: 
		case 0x21122: 
		case 0x11222: 
			*predicted = C;
			*predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C];
			break;
		case 0x22111:
		case 0x21112:
		case 0x22112: 
		case 0x22211: 
			*predicted = N;
			*predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N];
			break;
		default: return 0;
		}
	}
	else if ( cx->guide == GUIDE_32322 )
	{
		if (cx->cache[(frame- cx->cycle)%CACHE_SIZE  ].chosen == 0xff ||
			cx->cache[(frame- cx->cycle +1)%CACHE_SIZE].chosen == 0xff ||
			cx->cache[(frame- cx->cycle +2)%CACHE_SIZE].chosen == 0xff ||
			cx->cache[(frame- cx->cycle +3)%CACHE_SIZE].chosen == 0xff ||
			cx->cache[(frame- cx->cycle +4)%CACHE_SIZE].chosen == 0xff ||
			cx->cache[(frame- cx->cycle +5)%CACHE_SIZE].chosen == 0xff)
			return 0;

		switch ((cx->cache[(frame- cx->cycle)%CACHE_SIZE  ].chosen << 20) +
				(cx->cache[(frame- cx->cycle +1)%CACHE_SIZE].chosen << 16) +
				(cx->cache[(frame- cx->cycle +2)%CACHE_SIZE].chosen << 12) +
				(cx->cache[(frame- cx->cycle +3)%CACHE_SIZE].chosen <<  8) +
				(cx->cache[(frame- cx->cycle +4)%CACHE_SIZE].chosen <<  4) +
				(cx->cache[(frame- cx->cycle +5)%CACHE_SIZE].chosen))
		{
		case 0x111122:
		case 0x111221:
		case 0x112211:
		case 0x122111:
		case 0x111222: 
		case 0x112221:
		case 0x122211:
		case 0x222111: 
			*predicted = C;
			*predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C];
			break;
		case 0x221111:
		case 0x211112:

		case 0x221112: 
		case 0x211122: 
			*predicted = N;
			*predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N];
			break;
		default: return 0;
		}
	}
#ifdef DEBUG_PATTERN_GUIDANCE
	fprintf( stderr, "%s: pos=%d HARD: predicted=%d\n", __FUNCTION__, frame, *predicted);
#endif
	return 1;
}

static struct PREDICTION *PredictSoftYUY2(context cx, int frame )
{
	// Use heuristics to look forward for a match.
	int i, j, y, c, n, phase;
	unsigned int metric;

	cx->pred[0].metric = 0xffffffff;
	if (frame < 0 || frame > cx->out - cx->cycle) return cx->pred;

	// Look at the next cycle of frames.
	for (y = frame + 1; y <= frame + cx->cycle; y++)
	{
		// Look for a frame where the current and next match values are
		// very close. Those are candidates to predict the phase, because
		// that condition should occur only once per cycle. Store the candidate
		// phases and predictions in a list sorted by goodness. The list will
		// be used by the caller to try the phases in order.
		c = cx->cache[y%CACHE_SIZE].metrics[C]; 
		n = cx->cache[y%CACHE_SIZE].metrics[N];
		if (c == 0) c = 1;
		metric = (100 * abs (c - n)) / c;
		phase = y % cx->cycle;
		if (metric < 5)
		{
			// Place the new candidate phase in sorted order in the list.
			// Find the insertion point.
			i = 0;
			while (metric > cx->pred[i].metric) i++;
			// Find the end-of-list marker.
			j = 0;
			while (cx->pred[j].metric != 0xffffffff) j++;
			// Shift all items below the insertion point down by one to make
			// room for the insertion.
			j++;
			for (; j > i; j--)
			{
				cx->pred[j].metric = cx->pred[j-1].metric;
				cx->pred[j].phase = cx->pred[j-1].phase;
				cx->pred[j].predicted = cx->pred[j-1].predicted;
				cx->pred[j].predicted_metric = cx->pred[j-1].predicted_metric;
			}
			// Insert the new candidate data.
			cx->pred[j].metric = metric;
			cx->pred[j].phase = phase;
			if ( cx->guide == GUIDE_32 )
			{
				switch ((frame % cx->cycle) - phase)
				{
				case -4: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break; 
				case -3: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break; 
				case -2: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				case -1: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				case  0: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				case +1: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break; 
				case +2: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break; 
				case +3: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				case +4: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				}
			}
			else if ( cx->guide == GUIDE_32322 )
			{
				switch ((frame % cx->cycle) - phase)
				{
				case -5: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break; 
				case -4: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break; 
				case -3: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				case -2: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				case -1: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				case  0: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				case +1: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break; 
				case +2: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break; 
				case +3: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				case +4: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				case +5: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break; 
				}
			}
		}
#ifdef DEBUG_PATTERN_GUIDANCE
		fprintf( stderr, "%s: pos=%d metric=%d phase=%d\n", __FUNCTION__, frame, metric, phase);
#endif
	}
	return cx->pred;
}

static
void CalculateMetrics(context cx, int frame, unsigned char *fcrp, unsigned char *fcrpU, unsigned char *fcrpV,
					unsigned char *fprp, unsigned char *fprpU, unsigned char *fprpV)
{
	int x, y, p, c, tmp1, tmp2, skip;
	int vc;
    unsigned char *currbot0, *currbot2, *prevbot0, *prevbot2;
	unsigned char *prevtop0, *prevtop2, *prevtop4, *currtop0, *currtop2, *currtop4;
	unsigned char *a0, *a2, *b0, *b2, *b4;
	unsigned int diff, index;
#	define T 4

	/* Clear the block sums. */
 	for (y = 0; y < cx->yblocks; y++)
	{
 		for (x = 0; x < cx->xblocks; x++)
		{
#ifdef WINDOWED_MATCH
			matchp[y*xblocks+x] = 0;
			matchc[y*xblocks+x] = 0;
#endif
			cx->sump[y * cx->xblocks + x] = 0;
			cx->sumc[y * cx->xblocks + x] = 0;
		}
	}

	/* Find the best field match. Subsample the frames for speed. */
	currbot0  = fcrp + cx->pitch;
	currbot2  = fcrp + 3 * cx->pitch;
	currtop0 = fcrp;
	currtop2 = fcrp + 2 * cx->pitch;
	currtop4 = fcrp + 4 * cx->pitch;
	prevbot0  = fprp + cx->pitch;
	prevbot2  = fprp + 3 * cx->pitch;
	prevtop0 = fprp;
	prevtop2 = fprp + 2 * cx->pitch;
	prevtop4 = fprp + 4 * cx->pitch;
	if ( cx->tff )
	{
		a0 = prevbot0;
		a2 = prevbot2;
		b0 = currtop0;
		b2 = currtop2;
		b4 = currtop4;
	}
	else
	{
		a0 = currbot0;
		a2 = currbot2;
		b0 = prevtop0;
		b2 = prevtop2;
		b4 = prevtop4;
	}
	p = c = 0;

	// Calculate the field match and film/video metrics.
//	if (vi.IsYV12()) skip = 1;
//	else 
	skip = 1 + ( !cx->chroma );
	for (y = 0, index = 0; y < cx->h - 4; y+=4)
	{
		/* Exclusion band. Good for ignoring subtitles. */
		if (cx->y0 == cx->y1 || y < cx->y0 || y > cx->y1)
		{
			for (x = 0; x < cx->w;)
			{
//				if (vi.IsYV12())
//					index = (y/BLKSIZE)*xblocks + x/BLKSIZE;
//				else
					index = (y/BLKSIZE) * cx->xblocks + x/BLKSIZE_TIMES2;

				// Test combination with current frame.
				tmp1 = ((long)currbot0[x] + (long)currbot2[x]);
//				diff = abs((long)currtop0[x] - (tmp1 >> 1));
				diff = abs((((long)currtop0[x] + (long)currtop2[x] + (long)currtop4[x])) - (tmp1 >> 1) - tmp1);
				if (diff > cx->nt)
				{
					c += diff;
#ifdef WINDOWED_MATCH
					matchc[index] += diff;
#endif
				}

				tmp1 = currbot0[x] + T;
				tmp2 = currbot0[x] - T;
				vc = (tmp1 < currtop0[x] && tmp1 < currtop2[x]) ||
					 (tmp2 > currtop0[x] && tmp2 > currtop2[x]);
				if (vc)
				{
					cx->sumc[index]++;
				}

				// Test combination with previous frame.
				tmp1 = ((long)a0[x] + (long)a2[x]);
				diff = abs((((long)b0[x] + (long)b2[x] + (long)b4[x])) - (tmp1 >> 1) - tmp1);
				if (diff > cx->nt)
				{
					p += diff;
#ifdef WINDOWED_MATCH
					matchp[index] += diff;
#endif
				}

				tmp1 = a0[x] + T;
				tmp2 = a0[x] - T;
				vc = (tmp1 < b0[x] && tmp1 < b2[x]) ||
					 (tmp2 > b0[x] && tmp2 > b2[x]);
				if (vc)
				{
					cx->sump[index]++;
				}

				x += skip;
				if (!(x&3)) x += 4;
			}
		}
		currbot0 += cx->pitchtimes4;
		currbot2 += cx->pitchtimes4;
		currtop0 += cx->pitchtimes4;
		currtop2 += cx->pitchtimes4;
		currtop4 += cx->pitchtimes4;
		a0		 += cx->pitchtimes4;
		a2		 += cx->pitchtimes4;
		b0		 += cx->pitchtimes4;
		b2		 += cx->pitchtimes4;
		b4		 += cx->pitchtimes4;
	}

//	if (vi.IsYV12() && chroma == true)
//	{
//		int z;
//
//		for (z = 0; z < 2; z++)
//		{
//			// Do the same for the U plane.
//			if (z == 0)
//			{
//				currbot0  = fcrpU + pitchover2;
//				currbot2  = fcrpU + 3 * pitchover2;
//				currtop0 = fcrpU;
//				currtop2 = fcrpU + 2 * pitchover2;
//				currtop4 = fcrpU + 4 * pitchover2;
//				prevbot0  = fprpU + pitchover2;
//				prevbot2  = fprpU + 3 * pitchover2;
//				prevtop0 = fprpU;
//				prevtop2 = fprpU + 2 * pitchover2;
//				prevtop4 = fprpU + 4 * pitchover2;
//			}
//			else
//			{
//				currbot0  = fcrpV + pitchover2;
//				currbot2  = fcrpV + 3 * pitchover2;
//				currtop0 = fcrpV;
//				currtop2 = fcrpV + 2 * pitchover2;
//				currtop4 = fcrpV + 4 * pitchover2;
//				prevbot0  = fprpV + pitchover2;
//				prevbot2  = fprpV + 3 * pitchover2;
//				prevtop0 = fprpV;
//				prevtop2 = fprpV + 2 * pitchover2;
//				prevtop4 = fprpV + 4 * pitchover2;
//			}
//			if (tff == true)
//			{
//				a0 = prevbot0;
//				a2 = prevbot2;
//				b0 = currtop0;
//				b2 = currtop2;
//				b4 = currtop4;
//			}
//			else
//			{
//				a0 = currbot0;
//				a2 = currbot2;
//				b0 = prevtop0;
//				b2 = prevtop2;
//				b4 = prevtop4;
//			}
//
//			for (y = 0, index = 0; y < hover2 - 4; y+=4)
//			{
//				/* Exclusion band. Good for ignoring subtitles. */
//				if (y0 == y1 || y < y0/2 || y > y1/2)
//				{
//					for (x = 0; x < wover2;)
//					{
//						if (vi.IsYV12())
//							index = (y/BLKSIZE)*xblocks + x/BLKSIZE;
//						else
//							index = (y/BLKSIZE)*xblocks + x/BLKSIZE_TIMES2;
//
//						// Test combination with current frame.
//						tmp1 = ((long)currbot0[x] + (long)currbot2[x]);
//						diff = abs((((long)currtop0[x] + (long)currtop2[x] + (long)currtop4[x])) - (tmp1 >> 1) - tmp1);
//						if (diff > nt)
//						{
//							c += diff;
//#ifdef WINDOWED_MATCH
//							matchc[index] += diff;
//#endif
//						}
//
//						tmp1 = currbot0[x] + T;
//						tmp2 = currbot0[x] - T;
//						vc = (tmp1 < currtop0[x] && tmp1 < currtop2[x]) ||
//							 (tmp2 > currtop0[x] && tmp2 > currtop2[x]);
//						if (vc)
//						{
//							sumc[index]++;
//						}
//
//						// Test combination with previous frame.
//						tmp1 = ((long)a0[x] + (long)a2[x]);
//						diff = abs((((long)b0[x] + (long)b2[x] + (long)b4[x])) - (tmp1 >> 1) - tmp1);
//						if (diff > nt)
//						{
//							p += diff;
//#ifdef WINDOWED_MATCH
//							matchp[index] += diff;
//#endif
//						}
//
//						tmp1 = a0[x] + T;
//						tmp2 = a0[x] - T;
//						vc = (tmp1 < b0[x] && tmp1 < b2[x]) ||
//							 (tmp2 > b0[x] && tmp2 > b2[x]);
//						if (vc)
//						{
//							sump[index]++;
//						}
//
//						x ++;
//						if (!(x&3)) x += 4;
//					}
//				}
//				currbot0 += 4*pitchover2;
//				currbot2 += 4*pitchover2;
//				currtop0 += 4*pitchover2;
//				currtop2 += 4*pitchover2;
//				currtop4 += 4*pitchover2;
//				a0		 += 4*pitchover2;
//				a2		 += 4*pitchover2;
//				b0		 += 4*pitchover2;
//				b2		 += 4*pitchover2;
//				b4		 += 4*pitchover2;
//			}
//		}
//	}
//
//	// Now find the blocks that have the greatest differences.
//#ifdef WINDOWED_MATCH
//	highest_matchp = 0;
//	for (y = 0; y < yblocks; y++)
//	{
//		for (x = 0; x < xblocks; x++)
//		{
//if (frame == 45 && matchp[y * xblocks + x] > 2500)
//{
//	sprintf(buf, "%d/%d = %d\n", x, y, matchp[y * xblocks + x]);
//	OutputDebugString(buf);
//}
//			if (matchp[y * xblocks + x] > highest_matchp)
//			{
//				highest_matchp = matchp[y * xblocks + x];
//			}
//		}
//	}
//	highest_matchc = 0;
//	for (y = 0; y < yblocks; y++)
//	{
//		for (x = 0; x < xblocks; x++)
//		{
//if (frame == 44 && matchc[y * xblocks + x] > 2500)
//{
//	sprintf(buf, "%d/%d = %d\n", x, y, matchc[y * xblocks + x]);
//	OutputDebugString(buf);
//}
//			if (matchc[y * xblocks + x] > highest_matchc)
//			{
//				highest_matchc = matchc[y * xblocks + x];
//			}
//		}
//	}
//#endif
	if ( cx->post )
	{
		cx->highest_sump = 0;
		for (y = 0; y < cx->yblocks; y++)
		{
			for (x = 0; x < cx->xblocks; x++)
			{
				if (cx->sump[y * cx->xblocks + x] > cx->highest_sump)
				{
					cx->highest_sump = cx->sump[y * cx->xblocks + x];
				}
			}
		}
		cx->highest_sumc = 0;
		for (y = 0; y < cx->yblocks; y++)
		{
			for (x = 0; x < cx->xblocks; x++)
			{
				if (cx->sumc[y * cx->xblocks + x] > cx->highest_sumc)
				{
					cx->highest_sumc = cx->sumc[y * cx->xblocks + x];
				}
			}
		}
	}
#ifdef WINDOWED_MATCH
	CacheInsert(frame, highest_matchp, highest_sump, highest_matchc, highest_sumc);
#else
	CacheInsert( cx, frame, p, cx->highest_sump, c, cx->highest_sumc);
#endif
}


/** Process the image.
*/

static int get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
	// Get the filter service
	mlt_filter filter = mlt_frame_pop_service( frame );
	mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
	mlt_properties frame_properties = mlt_frame_properties( frame );
	context cx = mlt_properties_get_data( properties, "context", NULL );
	mlt_service producer = mlt_service_producer( mlt_filter_service( filter ) );
	cx->out = producer? mlt_producer_get_playtime( MLT_PRODUCER( producer ) ) : 999999;

	if ( ! cx->is_configured )
	{
		cx->back = mlt_properties_get_int( properties, "back" );
		cx->chroma = mlt_properties_get_int( properties, "chroma" );
		cx->guide = mlt_properties_get_int( properties, "guide" );
		cx->gthresh = mlt_properties_get_double( properties, "gthresh" );
		cx->post = mlt_properties_get_int( properties, "post" );
		cx->vthresh = mlt_properties_get_double( properties, "vthresh" );
		cx->bthresh = mlt_properties_get_double( properties, "bthresh" );
		cx->dthresh = mlt_properties_get_double( properties, "dthresh" );
		cx->blend = mlt_properties_get_int( properties, "blend" );
		cx->nt = mlt_properties_get_int( properties, "nt" );
		cx->y0 = mlt_properties_get_int( properties, "y0" );
		cx->y1 = mlt_properties_get_int( properties, "y1" );
		cx->hints = mlt_properties_get_int( properties, "hints" );
		cx->debug = mlt_properties_get_int( properties, "debug" );
		cx->show = mlt_properties_get_int( properties, "show" );
	}

	// Get the image
	int error = mlt_frame_get_image( frame, image, format, width, height, 1 );

	if ( ! cx->sump )
	{
		int guide = mlt_properties_get_int( properties, "guide" );
		cx->cycle = 0;
		if ( guide == GUIDE_32 )
		{
			// 24fps to 30 fps telecine.
			cx->cycle = 5;
		}
		else if ( guide == GUIDE_22 )
		{
			// PAL guidance (expect the current match to be continued).
			cx->cycle = 2;
		}
		else if ( guide == GUIDE_32322 )
		{
			// 25fps to 30 fps telecine.
			cx->cycle = 6;
		}

		cx->xblocks = (*width+BLKSIZE-1) / BLKSIZE;
		cx->yblocks = (*height+BLKSIZE-1) / BLKSIZE;
		cx->sump = (unsigned int *) mlt_pool_alloc( cx->xblocks * cx->yblocks * sizeof(unsigned int) );
		cx->sumc = (unsigned int *) mlt_pool_alloc( cx->xblocks * cx->yblocks * sizeof(unsigned int) );
		mlt_properties_set_data( properties, "sump", cx->sump, cx->xblocks * cx->yblocks * sizeof(unsigned int), (mlt_destructor)mlt_pool_release, NULL );
		mlt_properties_set_data( properties, "sumc", cx->sumc, cx->xblocks * cx->yblocks * sizeof(unsigned int), (mlt_destructor)mlt_pool_release, NULL );
		cx->tff = mlt_properties_get_int( frame_properties, "top_field_first" );
	//	fprintf(stderr, "%s: TOP FIELD FIRST %d\n", __FUNCTION__, cx->tff );
	}

	// Only process if we have no error and a valid colour space
	if ( error == 0 && *format == mlt_image_yuv422 )
	{
		// Put the current image into the image cache, keyed on position
		size_t image_size = (*width * *height) << 1;
		mlt_position pos = mlt_frame_get_position( frame );
		uint8_t *image_copy = mlt_pool_alloc( image_size );
		memcpy( image_copy, *image, image_size );
		char key[20];
		sprintf( key, "%d", pos );
		mlt_properties_set_data( cx->image_cache, key, image_copy, image_size, (mlt_destructor)mlt_pool_release, NULL );
		
		// Only if we have enough frame images cached
		if ( pos > 1 && pos > cx->cycle + 1 )
		{
			pos -= cx->cycle + 1;
			// Get the current frame image
			sprintf( key, "%d", pos );
			cx->fcrp = mlt_properties_get_data( cx->image_cache, key, NULL );
			if (!cx->fcrp) return error;
			 
			// Get the previous frame image
			cx->pframe = pos == 0 ? 0 : pos - 1;
			sprintf( key, "%d", cx->pframe );
			cx->fprp = mlt_properties_get_data( cx->image_cache, key, NULL );
			if (!cx->fprp) return error;
			
			// Get the next frame image
			cx->nframe = pos > cx->out ? cx->out : pos + 1;
			sprintf( key, "%d", cx->nframe );
			cx->fnrp = mlt_properties_get_data( cx->image_cache, key, NULL );
			if (!cx->fnrp) return error;
			
			cx->pitch = *width << 1;
			cx->pitchover2 = cx->pitch >> 1;
			cx->pitchtimes4 = cx->pitch << 2;
			cx->w = *width << 1;
			cx->h = *height;
			if ((cx->w/2) & 1)
				fprintf( stderr, "%s: width must be a multiple of 2\n", __FUNCTION__ );
			if (cx->h & 1)
				fprintf( stderr, "%s: height must be a multiple of 2\n", __FUNCTION__ );
			cx->wover2 = cx->w/2;
			cx->hover2 = cx->h/2;
			cx->hplus1over2 = (cx->h+1)/2;
			cx->hminus2 = cx->h - 2;
			cx->dpitch = cx->pitch;
			
			// Ensure that the metrics for the frames
			// after the current frame are in the cache. They will be used for
			// pattern guidance.
			if ( cx->guide )
			{
				for ( cx->y = pos + 1; (cx->y <= pos + cx->cycle + 1) && (cx->y <= cx->out); cx->y++ )
				{
					if ( ! CacheQuery( cx, cx->y, &cx->p, &cx->pblock, &cx->c, &cx->cblock ) )
					{
						sprintf( key, "%d", cx->y );
						cx->crp = (unsigned char *) mlt_properties_get_data( cx->image_cache, key, NULL );
						sprintf( key, "%d", cx->y ? cx->y - 1 : 1 );
						cx->prp = (unsigned char *) mlt_properties_get_data( cx->image_cache, key, NULL );
						CalculateMetrics( cx, cx->y, cx->crp, NULL, NULL, cx->prp, NULL, NULL );					}
				}
			}
			
			// Check for manual overrides of the field matching.
			cx->found = 0;
			cx->film = 1;
			cx->override = 0;
			cx->inpattern = 0;
			cx->vthresh = cx->vthresh;
			cx->back = cx->back_saved;
			
			// Get the metrics for the current-previous (p), current-current (c), and current-next (n) match candidates.
			if ( ! CacheQuery( cx, pos, &cx->p, &cx->pblock, &cx->c, &cx->cblock ) )
			{
				CalculateMetrics( cx, pos, cx->fcrp, NULL, NULL, cx->fprp, NULL, NULL );
				CacheQuery( cx, pos, &cx->p, &cx->pblock, &cx->c, &cx->cblock );
			}				
			if ( ! CacheQuery( cx, cx->nframe, &cx->np, &cx->npblock, &cx->nc, &cx->ncblock ) )
			{
				CalculateMetrics( cx, cx->nframe, cx->fnrp, NULL, NULL, cx->fcrp, NULL, NULL );
				CacheQuery( cx, cx->nframe, &cx->np, &cx->npblock, &cx->nc, &cx->ncblock );
			}				
			
			// Determine the best candidate match.
			if ( !cx->found )
			{
				cx->lowest = cx->c;
				cx->chosen = C;
				if ( cx->back == ALWAYS_BACK && cx->p < cx->lowest )
				{
					cx->lowest = cx->p;
					cx->chosen = P;
				}
				if ( cx->np < cx->lowest )
				{
					cx->lowest = cx->np;
					cx->chosen = N;
				}
			}
			if ((pos == 0 && cx->chosen == P) || (pos == cx->out && cx->chosen == N))
			{
				cx->chosen = C;
				cx->lowest = cx->c;
			}

			// See if we can apply pattern guidance.
			cx->mismatch = 100.0;
			if ( cx->guide )
			{
				cx->hard = 0;
				if ( pos >= cx->cycle && PredictHardYUY2( cx, pos, &cx->predicted, &cx->predicted_metric) )
				{
					cx->inpattern = 1;
					cx->mismatch = 0.0;
					cx->hard = 1;
					if ( cx->chosen != cx->predicted )
					{
						// The chosen frame doesn't match the prediction.
						if ( cx->predicted_metric == 0 )
							cx->mismatch = 0.0;
						else
							cx->mismatch = (100.0 * abs( cx->predicted_metric - cx->lowest ) ) / cx->predicted_metric;
						if ( cx->mismatch < cx->gthresh )
						{
							// It's close enough, so use the predicted one.
							if ( !cx->found )
							{
								cx->chosen = cx->predicted;
								cx->override = 1;
							}
						}
						else
						{
							cx->hard = 0;
							cx->inpattern = 0;
						}
					}
				}
		
				if ( !cx->hard && cx->guide != GUIDE_22 )
				{
					int i;
					struct PREDICTION *pred = PredictSoftYUY2( cx, pos );
		
					if ( ( pos <= cx->out - cx->cycle) && ( pred[0].metric != 0xffffffff ) )
					{
						// Apply pattern guidance.
						// If the predicted match metric is within defined percentage of the
						// best calculated one, then override the calculated match with the
						// predicted match.
						i = 0;
						while ( pred[i].metric != 0xffffffff )
						{
							cx->predicted = pred[i].predicted;
							cx->predicted_metric = pred[i].predicted_metric;
#ifdef DEBUG_PATTERN_GUIDANCE
							fprintf(stderr, "%s: pos=%d predicted=%d\n", __FUNCTION__, pos, cx->predicted);
#endif
							if ( cx->chosen != cx->predicted )
							{
								// The chosen frame doesn't match the prediction.
								if ( cx->predicted_metric == 0 )
									cx->mismatch = 0.0;
								else
									cx->mismatch = (100.0 * abs( cx->predicted_metric - cx->lowest )) / cx->predicted_metric;
								if ( (int) cx->mismatch <= cx->gthresh )
								{
									// It's close enough, so use the predicted one.
									if ( !cx->found )
									{
										cx->chosen = cx->predicted;
										cx->override = 1;
									}
									cx->inpattern = 1;
									break;
								}
								else
								{
									// Looks like we're not in a predictable pattern.
									cx->inpattern = 0;
								}
							}
							else
							{
								cx->inpattern = 1;
								cx->mismatch = 0.0;
								break;
							}
							i++;
						}
					}
				}
			}

			// Check the match for progressive versus interlaced.
			if ( cx->post )
			{
				if (cx->chosen == P) cx->vmetric = cx->pblock;
				else if (cx->chosen == C) cx->vmetric = cx->cblock;
				else if (cx->chosen == N) cx->vmetric = cx->npblock;
		
				if ( !cx->found && cx->back == BACK_ON_COMBED && cx->vmetric > cx->bthresh && cx->p < cx->lowest )
				{
					// Backward match.
					cx->vmetric = cx->pblock;
					cx->chosen = P;
					cx->inpattern = 0;
					cx->mismatch = 100;
				}
				if ( cx->vmetric > cx->vthresh )
				{
					// After field matching and pattern guidance the frame is still combed.
					cx->film = 0;
					if ( !cx->found && ( cx->post == POST_FULL_NOMATCH || cx->post == POST_FULL_NOMATCH_MAP ) )
					{
						cx->chosen = C;
						cx->vmetric = cx->cblock;
						cx->inpattern = 0;
						cx->mismatch = 100;
					}
				}
			}
			cx->vthresh = cx->vthresh_saved;
		
			// Setup strings for debug info.
			if ( cx->inpattern && !cx->override ) strcpy( cx->status, "[in-pattern]" );
			else if ( cx->inpattern && cx->override ) strcpy( cx->status, "[in-pattern*]" );
			else strcpy( cx->status, "[out-of-pattern]" );
	
			// Assemble and output the reconstructed frame according to the final match.
			cx->dstp = *image;
			if ( cx->chosen == N )
			{
				// The best match was with the next frame.
				if ( cx->tff )
				{
					BitBlt( cx->dstp, 2 * cx->dpitch, cx->fnrp, 2 * cx->pitch, cx->w, cx->hover2 );
					BitBlt( cx->dstp + cx->dpitch, 2 * cx->dpitch, cx->fcrp + cx->pitch, 2 * cx->pitch,	cx->w, cx->hover2 );
				}
				else
				{
					BitBlt( cx->dstp, 2 * cx->dpitch, cx->fcrp, 2 * cx->pitch, cx->w, cx->hplus1over2 );
					BitBlt( cx->dstp + cx->dpitch, 2 * cx->dpitch, cx->fnrp + cx->pitch, 2 * cx->pitch,	cx->w, cx->hover2 );
				}
			}
			else if ( cx->chosen == C )
			{
				// The best match was with the current frame.
				BitBlt( cx->dstp, 2 * cx->dpitch, cx->fcrp, 2 * cx->pitch, cx->w, cx->hplus1over2 );
				BitBlt( cx->dstp + cx->dpitch, 2 * cx->dpitch, cx->fcrp + cx->pitch, 2 * cx->pitch,	cx->w, cx->hover2 );
			}
			else if ( ! cx->tff )
			{
				// The best match was with the previous frame.
				BitBlt( cx->dstp, 2 * cx->dpitch, cx->fprp, 2 * cx->pitch, cx->w, cx->hplus1over2 );
				BitBlt( cx->dstp + cx->dpitch, 2 * cx->dpitch, cx->fcrp + cx->pitch, 2 * cx->pitch, cx->w, cx->hover2 );
			}
			else
			{
				// The best match was with the previous frame.
				BitBlt( cx->dstp, 2 * cx->dpitch, cx->fcrp, 2 * cx->pitch, cx->w, cx->hplus1over2 );
				BitBlt( cx->dstp + cx->dpitch, 2 * cx->dpitch, cx->fprp + cx->pitch, 2 * cx->pitch,	cx->w, cx->hover2 );
			}
			if ( cx->guide )
				PutChosen( cx, pos, cx->chosen );

			if ( !cx->post || cx->post == POST_METRICS )
			{
				if ( cx->force == '+') cx->film = 0;
				else if ( cx->force == '-' ) cx->film = 1;
			}
			else if ((cx->force == '+') ||
				((cx->post == POST_FULL || cx->post == POST_FULL_MAP || cx->post == POST_FULL_NOMATCH || cx->post == POST_FULL_NOMATCH_MAP)
				         && (cx->film == 0 && cx->force != '-')))
			{
				unsigned char *dstpp, *dstpn;
				int v1, v2;
		
				if ( cx->blend )
				{
					// Do first and last lines.
					uint8_t *final = mlt_pool_alloc( image_size );
					cx->finalp = final;
					mlt_properties_set_data( frame_properties, "image", final, image_size, (mlt_destructor)mlt_pool_release, NULL );
					dstpn = cx->dstp + cx->dpitch;
					for ( cx->x = 0; cx->x < cx->w; cx->x++ )
					{
						cx->finalp[cx->x] = (((int)cx->dstp[cx->x] + (int)dstpn[cx->x]) >> 1);
					}
					cx->finalp = final + (cx->h-1)*cx->dpitch;
					cx->dstp = *image + (cx->h-1)*cx->dpitch;
					dstpp = cx->dstp - cx->dpitch;
					for ( cx->x = 0; cx->x < cx->w; cx->x++ )
					{
						cx->finalp[cx->x] = (((int)cx->dstp[cx->x] + (int)dstpp[cx->x]) >> 1);
					}
					// Now do the rest.
					cx->dstp = *image + cx->dpitch;
					dstpp = cx->dstp - cx->dpitch;
					dstpn = cx->dstp + cx->dpitch;
					cx->finalp = final + cx->dpitch;
					for ( cx->y = 1; cx->y < cx->h - 1; cx->y++ )
					{
						for ( cx->x = 0; cx->x < cx->w; cx->x++ )
						{
							v1 = (int) cx->dstp[cx->x] - cx->dthresh;
							if ( v1 < 0 )
								v1 = 0; 
							v2 = (int) cx->dstp[cx->x] + cx->dthresh;
							if (v2 > 235) v2 = 235; 
							if ((v1 > dstpp[cx->x] && v1 > dstpn[cx->x]) || (v2 < dstpp[cx->x] && v2 < dstpn[cx->x]))
							{
								if ( cx->post == POST_FULL_MAP || cx->post == POST_FULL_NOMATCH_MAP )
								{
									if (cx->x & 1) cx->finalp[cx->x] = 128;
									else cx->finalp[cx->x] = 235;
								}
								else
									cx->finalp[cx->x] = ((int)dstpp[cx->x] + (int)dstpn[cx->x] + (int)cx->dstp[cx->x] + (int)cx->dstp[cx->x]) >> 2;
							}
							else cx->finalp[cx->x] = cx->dstp[cx->x];
						}
						cx->finalp += cx->dpitch;
						cx->dstp += cx->dpitch;
						dstpp += cx->dpitch;
						dstpn += cx->dpitch;
					}
		
		
					if (cx->show ) Show( cx, pos, frame_properties);
					if (cx->debug) Debug(cx, pos);
					if (cx->hints) WriteHints(cx->film, cx->inpattern, frame_properties);
					goto final;
				}
		
				// Interpolate mode.
				cx->dstp = *image + cx->dpitch;
				dstpp = cx->dstp - cx->dpitch;
				dstpn = cx->dstp + cx->dpitch;
				for ( cx->y = 1; cx->y < cx->h - 1; cx->y+=2 )
				{
					for ( cx->x = 0; cx->x < cx->w; cx->x++ )
					{
						v1 = (int) cx->dstp[cx->x] - cx->dthresh;
						if (v1 < 0) v1 = 0; 
						v2 = (int) cx->dstp[cx->x] + cx->dthresh;
						if (v2 > 235) v2 = 235; 
						if ((v1 > dstpp[cx->x] && v1 > dstpn[cx->x]) || (v2 < dstpp[cx->x] && v2 < dstpn[cx->x]))
						{
							if ( cx->post == POST_FULL_MAP || cx->post == POST_FULL_NOMATCH_MAP )
							{
								if (cx->x & 1) cx->dstp[cx->x] = 128;
								else cx->dstp[cx->x] = 235;
							}
							else
								cx->dstp[cx->x] = (dstpp[cx->x] + dstpn[cx->x]) >> 1;
						}
					}
					cx->dstp += 2 * cx->dpitch;
					dstpp += 2 * cx->dpitch;
					dstpn += 2 * cx->dpitch;
				}
			}
			if (cx->show ) Show( cx, pos, frame_properties);
			if (cx->debug) Debug(cx, pos);
			if (cx->hints) WriteHints(cx->film, cx->inpattern, frame_properties);

final:			
			// Flush frame at tail of period from the cache
			sprintf( key, "%d", pos - 1 );
			mlt_properties_set_data( cx->image_cache, key, NULL, 0, NULL, NULL );
		}
		else
		{
			// Signal the first {cycle} frames as invalid
			mlt_properties_set_int( frame_properties, "garbage", 1 );
		}
	}
	else if ( error == 0 && *format == mlt_image_yuv420p )
	{
		fprintf(stderr,"%s: %d pos %d\n", __FUNCTION__, *width * *height * 3/2, mlt_frame_get_position(frame) );
	}

	return error;
}

/** Process the frame object.
*/

static mlt_frame process( mlt_filter this, mlt_frame frame )
{
	// Push the filter on to the stack
	mlt_frame_push_service( frame, this );

	// Push the frame filter
	mlt_frame_push_get_image( frame, get_image );

	return frame;
}

/** Constructor for the filter.
*/

mlt_filter filter_telecide_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
	mlt_filter this = mlt_filter_new( );
	if ( this != NULL )
	{
		this->process = process;

		// Allocate the context and set up for garbage collection		
		context cx = (context) mlt_pool_alloc( sizeof(struct context_s) );
		memset( cx, 0, sizeof( struct context_s ) );
		mlt_properties properties = MLT_FILTER_PROPERTIES( this );
		mlt_properties_set_data( properties, "context", cx, sizeof(struct context_s), (mlt_destructor)mlt_pool_release, NULL );

		// Allocate the metrics cache and set up for garbage collection
		cx->cache = (struct CACHE_ENTRY *) mlt_pool_alloc(CACHE_SIZE * sizeof(struct CACHE_ENTRY ));
		mlt_properties_set_data( properties, "cache", cx->cache, CACHE_SIZE * sizeof(struct CACHE_ENTRY), (mlt_destructor)mlt_pool_release, NULL );
		int i;
		for (i = 0; i < CACHE_SIZE; i++)
		{
			cx->cache[i].frame = 0xffffffff;
			cx->cache[i].chosen = 0xff;
		}
		
		// Allocate the image cache and set up for garbage collection
		cx->image_cache = mlt_properties_new();
		mlt_properties_set_data( properties, "image_cache", cx->image_cache, 0, (mlt_destructor)mlt_properties_close, NULL );
		
		// Initialize the parameter defaults
		mlt_properties_set_int( properties, "guide", 0 );
		mlt_properties_set_int( properties, "back", 0 );
		mlt_properties_set_int( properties, "chroma", 0 );
		mlt_properties_set_int( properties, "post", POST_FULL );
		mlt_properties_set_double( properties, "gthresh", 10.0 );
		mlt_properties_set_double( properties, "vthresh", 50.0 );
		mlt_properties_set_double( properties, "bthresh", 50.0 );
		mlt_properties_set_double( properties, "dthresh", 7.0 );
		mlt_properties_set_int( properties, "blend", 0 );
		mlt_properties_set_int( properties, "nt", 10 );
		mlt_properties_set_int( properties, "y0", 0 );
		mlt_properties_set_int( properties, "y1", 0 );
		mlt_properties_set_int( properties, "hints", 1 );
	}
	return this;
}