git.sesse.net Git - mlt/blob - src/modules/dgraft/filter_telecide.c

   1 /*
   2  * filter_telecide.c -- Donald Graft's Inverse Telecine Filter
   3  * Copyright (C) 2003 Donald A. Graft
   4  * Copyright (C) 2008 Dan Dennedy <dan@dennedy.org>
   5  * Author: Dan Dennedy <dan@dennedy.org>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software Foundation,
  19  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <framework/mlt.h>
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <math.h>
  27 #include <string.h>
  28
  29 //#define DEBUG_PATTERN_GUIDANCE
  30
  31 #define MAX_CYCLE 6
  32 #define BLKSIZE 24
  33 #define BLKSIZE_TIMES2 (2 * BLKSIZE)
  34 #define GUIDE_32 1
  35 #define GUIDE_22 2
  36 #define GUIDE_32322 3
  37 #define AHEAD 0
  38 #define BEHIND 1
  39 #define POST_METRICS 1
  40 #define POST_FULL 2
  41 #define POST_FULL_MAP 3
  42 #define POST_FULL_NOMATCH 4
  43 #define POST_FULL_NOMATCH_MAP 5
  44 #define CACHE_SIZE 100000
  45 #define P 0
  46 #define C 1
  47 #define N 2
  48 #define PBLOCK 3
  49 #define CBLOCK 4
  50
  51 #define NO_BACK 0
  52 #define BACK_ON_COMBED 1
  53 #define ALWAYS_BACK 2
  54
  55 struct CACHE_ENTRY
  56 {
  57         unsigned int frame;
  58         unsigned int metrics[5];
  59         unsigned int chosen;
  60 };
  61
  62 struct PREDICTION
  63 {
  64         unsigned int metric;
  65         unsigned int phase;
  66         unsigned int predicted;
  67         unsigned int predicted_metric;
  68 };
  69
  70 struct context_s {
  71         int is_configured;
  72         mlt_properties image_cache;
  73         int out;
  74
  75         int tff, chroma, blend, hints, show, debug;
  76         float dthresh, gthresh, vthresh, vthresh_saved, bthresh;
  77         int y0, y1, nt, guide, post, back, back_saved;
  78         int pitch, dpitch, pitchover2, pitchtimes4;
  79         int w, h, wover2, hover2, hplus1over2, hminus2;
  80         int xblocks, yblocks;
  81 #ifdef WINDOWED_MATCH
  82         unsigned int *matchc, *matchp, highest_matchc, highest_matchp;
  83 #endif
  84         unsigned int *sumc, *sump, highest_sumc, highest_sump;
  85         int vmetric;
  86         unsigned int *overrides, *overrides_p;
  87         int film, override, inpattern, found;
  88         int force;
  89
  90         // Used by field matching.
  91         unsigned char *fprp, *fcrp, *fcrp_saved, *fnrp;
  92 //      unsigned char *fprpU, *fcrpU, *fcrp_savedU, *fnrpU;
  93 //      unsigned char *fprpV, *fcrpV, *fcrp_savedV, *fnrpV;
  94         unsigned char *dstp, *finalp;
  95 //      unsigned char *dstpU, *dstpV;
  96         int chosen;
  97         unsigned int p, c, pblock, cblock, lowest, predicted, predicted_metric;
  98         unsigned int np, nc, npblock, ncblock, nframe;
  99         float mismatch;
 100         int pframe, x, y;
 101         unsigned char *crp, *prp;
 102         unsigned char *crpU, *prpU;
 103         unsigned char *crpV, *prpV;
 104         int hard;
 105         char status[80];
 106
 107         // Metrics cache.
 108         struct CACHE_ENTRY *cache;
 109
 110         // Pattern guidance data.
 111         int cycle;
 112         struct PREDICTION pred[MAX_CYCLE+1];
 113 };
 114 typedef struct context_s *context;
 115
 116
 117 static inline
 118 void BitBlt(uint8_t* dstp, int dst_pitch, const uint8_t* srcp,
 119             int src_pitch, int row_size, int height)
 120 {
 121         uint32_t y;
 122         for(y=0;y<height;y++)
 123         {
 124                 memcpy(dstp,srcp,row_size);
 125                 dstp+=dst_pitch;
 126                 srcp+=src_pitch;
 127         }
 128 }
 129
 130 static void Show(context cx, int frame, mlt_properties properties)
 131 {
 132         char use;
 133         char buf[512];
 134
 135         if (cx->chosen == P) use = 'p';
 136         else if (cx->chosen == C) use = 'c';
 137         else use = 'n';
 138         snprintf(buf, sizeof(buf), "Telecide: frame %d: matches: %d %d %d\n", frame, cx->p, cx->c, cx->np);
 139         if ( cx->post )
 140                 snprintf(buf, sizeof(buf), "%sTelecide: frame %d: vmetrics: %d %d %d [chosen=%d]\n", buf, frame, cx->pblock, cx->cblock, cx->npblock, cx->vmetric);
 141         if ( cx->guide )
 142                 snprintf(buf, sizeof(buf), "%spattern mismatch=%0.2f%%\n", buf, cx->mismatch);
 143         snprintf(buf, sizeof(buf), "%sTelecide: frame %d: [%s %c]%s %s\n", buf, frame, cx->found ? "forcing" : "using", use,
 144                 cx->post ? (cx->film ? " [progressive]" : " [interlaced]") : "",
 145                 cx->guide ? cx->status : "");
 146         mlt_properties_set( properties, "meta.attr.telecide.markup", buf );
 147 }
 148
 149 static void Debug(context cx, int frame)
 150 {
 151         char use;
 152
 153         if (cx->chosen == P) use = 'p';
 154         else if (cx->chosen == C) use = 'c';
 155         else use = 'n';
 156         fprintf(stderr, "Telecide: frame %d: matches: %d %d %d\n", frame, cx->p, cx->c, cx->np);
 157         if ( cx->post )
 158                 fprintf(stderr, "Telecide: frame %d: vmetrics: %d %d %d [chosen=%d]\n", frame, cx->pblock, cx->cblock, cx->npblock, cx->vmetric);
 159         if ( cx->guide )
 160                 fprintf(stderr, "pattern mismatch=%0.2f%%\n", cx->mismatch);
 161         fprintf(stderr, "Telecide: frame %d: [%s %c]%s %s\n", frame, cx->found ? "forcing" : "using", use,
 162                 cx->post ? (cx->film ? " [progressive]" : " [interlaced]") : "",
 163                 cx->guide ? cx->status : "");
 164 }
 165
 166 static void WriteHints(int film, int inpattern, mlt_properties frame_properties)
 167 {
 168         mlt_properties_set_int( frame_properties, "telecide.progressive", film);
 169         mlt_properties_set_int( frame_properties, "telecide.in_pattern", inpattern);
 170 }
 171
 172 static void PutChosen(context cx, int frame, unsigned int chosen)
 173 {
 174         int f = frame % CACHE_SIZE;
 175         if (frame < 0 || frame > cx->out || cx->cache[f].frame != frame)
 176                 return;
 177         cx->cache[f].chosen = chosen;
 178 }
 179
 180 static void CacheInsert(context cx, int frame, unsigned int p, unsigned int pblock,
 181                                          unsigned int c, unsigned int cblock)
 182 {
 183         int f = frame % CACHE_SIZE;
 184         if (frame < 0 || frame > cx->out)
 185                 fprintf( stderr, "%s: internal error: invalid frame %d for CacheInsert", __FUNCTION__, frame);
 186         cx->cache[f].frame = frame;
 187         cx->cache[f].metrics[P] = p;
 188         if (f) cx->cache[f-1].metrics[N] = p;
 189         cx->cache[f].metrics[C] = c;
 190         cx->cache[f].metrics[PBLOCK] = pblock;
 191         cx->cache[f].metrics[CBLOCK] = cblock;
 192         cx->cache[f].chosen = 0xff;
 193 }
 194
 195 static int CacheQuery(context cx, int frame, unsigned int *p, unsigned int *pblock,
 196                                         unsigned int *c, unsigned int *cblock)
 197 {
 198         int f;
 199
 200         f = frame % CACHE_SIZE;
 201         if (frame < 0 || frame > cx->out)
 202                 fprintf( stderr, "%s: internal error: invalid frame %d for CacheQuery", __FUNCTION__, frame);
 203         if (cx->cache[f].frame != frame)
 204         {
 205                 return 0;
 206         }
 207         *p = cx->cache[f].metrics[P];
 208         *c = cx->cache[f].metrics[C];
 209         *pblock = cx->cache[f].metrics[PBLOCK];
 210         *cblock = cx->cache[f].metrics[CBLOCK];
 211         return 1;
 212 }
 213
 214 static int PredictHardYUY2(context cx, int frame, unsigned int *predicted, unsigned int *predicted_metric)
 215 {
 216         // Look for pattern in the actual delivered matches of the previous cycle of frames.
 217         // If a pattern is found, use that to predict the current match.
 218         if ( cx->guide == GUIDE_22 )
 219         {
 220                 if (cx->cache[(frame- cx->cycle)%CACHE_SIZE  ].chosen == 0xff ||
 221                         cx->cache[(frame- cx->cycle+1)%CACHE_SIZE].chosen == 0xff)
 222                         return 0;
 223                 switch ((cx->cache[(frame- cx->cycle)%CACHE_SIZE  ].chosen << 4) +
 224                                 (cx->cache[(frame- cx->cycle+1)%CACHE_SIZE].chosen))
 225                 {
 226                 case 0x11:
 227                         *predicted = C;
 228                         *predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C];
 229                         break;
 230                 case 0x22:
 231                         *predicted = N;
 232                         *predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N];
 233                         break;
 234                 default: return 0;
 235                 }
 236         }
 237         else if ( cx->guide == GUIDE_32 )
 238         {
 239                 if (cx->cache[(frame-cx->cycle)%CACHE_SIZE  ].chosen == 0xff ||
 240                         cx->cache[(frame-cx->cycle+1)%CACHE_SIZE].chosen == 0xff ||
 241                         cx->cache[(frame-cx->cycle+2)%CACHE_SIZE].chosen == 0xff ||
 242                         cx->cache[(frame-cx->cycle+3)%CACHE_SIZE].chosen == 0xff ||
 243                         cx->cache[(frame-cx->cycle+4)%CACHE_SIZE].chosen == 0xff)
 244                         return 0;
 245
 246                 switch ((cx->cache[(frame-cx->cycle)%CACHE_SIZE  ].chosen << 16) +
 247                                 (cx->cache[(frame-cx->cycle+1)%CACHE_SIZE].chosen << 12) +
 248                                 (cx->cache[(frame-cx->cycle+2)%CACHE_SIZE].chosen <<  8) +
 249                                 (cx->cache[(frame-cx->cycle+3)%CACHE_SIZE].chosen <<  4) +
 250                                 (cx->cache[(frame-cx->cycle+4)%CACHE_SIZE].chosen))
 251                 {
 252                 case 0x11122:
 253                 case 0x11221:
 254                 case 0x12211:
 255                 case 0x12221:
 256                 case 0x21122:
 257                 case 0x11222:
 258                         *predicted = C;
 259                         *predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C];
 260                         break;
 261                 case 0x22111:
 262                 case 0x21112:
 263                 case 0x22112:
 264                 case 0x22211:
 265                         *predicted = N;
 266                         *predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N];
 267                         break;
 268                 default: return 0;
 269                 }
 270         }
 271         else if ( cx->guide == GUIDE_32322 )
 272         {
 273                 if (cx->cache[(frame- cx->cycle)%CACHE_SIZE  ].chosen == 0xff ||
 274                         cx->cache[(frame- cx->cycle +1)%CACHE_SIZE].chosen == 0xff ||
 275                         cx->cache[(frame- cx->cycle +2)%CACHE_SIZE].chosen == 0xff ||
 276                         cx->cache[(frame- cx->cycle +3)%CACHE_SIZE].chosen == 0xff ||
 277                         cx->cache[(frame- cx->cycle +4)%CACHE_SIZE].chosen == 0xff ||
 278                         cx->cache[(frame- cx->cycle +5)%CACHE_SIZE].chosen == 0xff)
 279                         return 0;
 280
 281                 switch ((cx->cache[(frame- cx->cycle)%CACHE_SIZE  ].chosen << 20) +
 282                                 (cx->cache[(frame- cx->cycle +1)%CACHE_SIZE].chosen << 16) +
 283                                 (cx->cache[(frame- cx->cycle +2)%CACHE_SIZE].chosen << 12) +
 284                                 (cx->cache[(frame- cx->cycle +3)%CACHE_SIZE].chosen <<  8) +
 285                                 (cx->cache[(frame- cx->cycle +4)%CACHE_SIZE].chosen <<  4) +
 286                                 (cx->cache[(frame- cx->cycle +5)%CACHE_SIZE].chosen))
 287                 {
 288                 case 0x111122:
 289                 case 0x111221:
 290                 case 0x112211:
 291                 case 0x122111:
 292                 case 0x111222:
 293                 case 0x112221:
 294                 case 0x122211:
 295                 case 0x222111:
 296                         *predicted = C;
 297                         *predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C];
 298                         break;
 299                 case 0x221111:
 300                 case 0x211112:
 301
 302                 case 0x221112:
 303                 case 0x211122:
 304                         *predicted = N;
 305                         *predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N];
 306                         break;
 307                 default: return 0;
 308                 }
 309         }
 310 #ifdef DEBUG_PATTERN_GUIDANCE
 311         fprintf( stderr, "%s: pos=%d HARD: predicted=%d\n", __FUNCTION__, frame, *predicted);
 312 #endif
 313         return 1;
 314 }
 315
 316 static struct PREDICTION *PredictSoftYUY2(context cx, int frame )
 317 {
 318         // Use heuristics to look forward for a match.
 319         int i, j, y, c, n, phase;
 320         unsigned int metric;
 321
 322         cx->pred[0].metric = 0xffffffff;
 323         if (frame < 0 || frame > cx->out - cx->cycle) return cx->pred;
 324
 325         // Look at the next cycle of frames.
 326         for (y = frame + 1; y <= frame + cx->cycle; y++)
 327         {
 328                 // Look for a frame where the current and next match values are
 329                 // very close. Those are candidates to predict the phase, because
 330                 // that condition should occur only once per cycle. Store the candidate
 331                 // phases and predictions in a list sorted by goodness. The list will
 332                 // be used by the caller to try the phases in order.
 333                 c = cx->cache[y%CACHE_SIZE].metrics[C];
 334                 n = cx->cache[y%CACHE_SIZE].metrics[N];
 335                 if (c == 0) c = 1;
 336                 metric = (100 * abs (c - n)) / c;
 337                 phase = y % cx->cycle;
 338                 if (metric < 5)
 339                 {
 340                         // Place the new candidate phase in sorted order in the list.
 341                         // Find the insertion point.
 342                         i = 0;
 343                         while (metric > cx->pred[i].metric) i++;
 344                         // Find the end-of-list marker.
 345                         j = 0;
 346                         while (cx->pred[j].metric != 0xffffffff) j++;
 347                         // Shift all items below the insertion point down by one to make
 348                         // room for the insertion.
 349                         j++;
 350                         for (; j > i; j--)
 351                         {
 352                                 cx->pred[j].metric = cx->pred[j-1].metric;
 353                                 cx->pred[j].phase = cx->pred[j-1].phase;
 354                                 cx->pred[j].predicted = cx->pred[j-1].predicted;
 355                                 cx->pred[j].predicted_metric = cx->pred[j-1].predicted_metric;
 356                         }
 357                         // Insert the new candidate data.
 358                         cx->pred[j].metric = metric;
 359                         cx->pred[j].phase = phase;
 360                         if ( cx->guide == GUIDE_32 )
 361                         {
 362                                 switch ((frame % cx->cycle) - phase)
 363                                 {
 364                                 case -4: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break;
 365                                 case -3: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break;
 366                                 case -2: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 367                                 case -1: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 368                                 case  0: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 369                                 case +1: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break;
 370                                 case +2: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break;
 371                                 case +3: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 372                                 case +4: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 373                                 }
 374                         }
 375                         else if ( cx->guide == GUIDE_32322 )
 376                         {
 377                                 switch ((frame % cx->cycle) - phase)
 378                                 {
 379                                 case -5: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break;
 380                                 case -4: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break;
 381                                 case -3: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 382                                 case -2: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 383                                 case -1: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 384                                 case  0: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 385                                 case +1: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break;
 386                                 case +2: cx->pred[j].predicted = N; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[N]; break;
 387                                 case +3: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 388                                 case +4: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 389                                 case +5: cx->pred[j].predicted = C; cx->pred[j].predicted_metric = cx->cache[frame%CACHE_SIZE].metrics[C]; break;
 390                                 }
 391                         }
 392                 }
 393 #ifdef DEBUG_PATTERN_GUIDANCE
 394                 fprintf( stderr, "%s: pos=%d metric=%d phase=%d\n", __FUNCTION__, frame, metric, phase);
 395 #endif
 396         }
 397         return cx->pred;
 398 }
 399
 400 static
 401 void CalculateMetrics(context cx, int frame, unsigned char *fcrp, unsigned char *fcrpU, unsigned char *fcrpV,
 402                                         unsigned char *fprp, unsigned char *fprpU, unsigned char *fprpV)
 403 {
 404         int x, y, p, c, tmp1, tmp2, skip;
 405         int vc;
 406     unsigned char *currbot0, *currbot2, *prevbot0, *prevbot2;
 407         unsigned char *prevtop0, *prevtop2, *prevtop4, *currtop0, *currtop2, *currtop4;
 408         unsigned char *a0, *a2, *b0, *b2, *b4;
 409         unsigned int diff, index;
 410 #       define T 4
 411
 412         /* Clear the block sums. */
 413         for (y = 0; y < cx->yblocks; y++)
 414         {
 415                 for (x = 0; x < cx->xblocks; x++)
 416                 {
 417 #ifdef WINDOWED_MATCH
 418                         matchp[y*xblocks+x] = 0;
 419                         matchc[y*xblocks+x] = 0;
 420 #endif
 421                         cx->sump[y * cx->xblocks + x] = 0;
 422                         cx->sumc[y * cx->xblocks + x] = 0;
 423                 }
 424         }
 425
 426         /* Find the best field match. Subsample the frames for speed. */
 427         currbot0  = fcrp + cx->pitch;
 428         currbot2  = fcrp + 3 * cx->pitch;
 429         currtop0 = fcrp;
 430         currtop2 = fcrp + 2 * cx->pitch;
 431         currtop4 = fcrp + 4 * cx->pitch;
 432         prevbot0  = fprp + cx->pitch;
 433         prevbot2  = fprp + 3 * cx->pitch;
 434         prevtop0 = fprp;
 435         prevtop2 = fprp + 2 * cx->pitch;
 436         prevtop4 = fprp + 4 * cx->pitch;
 437         if ( cx->tff )
 438         {
 439                 a0 = prevbot0;
 440                 a2 = prevbot2;
 441                 b0 = currtop0;
 442                 b2 = currtop2;
 443                 b4 = currtop4;
 444         }
 445         else
 446         {
 447                 a0 = currbot0;
 448                 a2 = currbot2;
 449                 b0 = prevtop0;
 450                 b2 = prevtop2;
 451                 b4 = prevtop4;
 452         }
 453         p = c = 0;
 454
 455         // Calculate the field match and film/video metrics.
 456 //      if (vi.IsYV12()) skip = 1;
 457 //      else
 458         skip = 1 + ( !cx->chroma );
 459         for (y = 0, index = 0; y < cx->h - 4; y+=4)
 460         {
 461                 /* Exclusion band. Good for ignoring subtitles. */
 462                 if (cx->y0 == cx->y1 || y < cx->y0 || y > cx->y1)
 463                 {
 464                         for (x = 0; x < cx->w;)
 465                         {
 466 //                              if (vi.IsYV12())
 467 //                                      index = (y/BLKSIZE)*xblocks + x/BLKSIZE;
 468 //                              else
 469                                         index = (y/BLKSIZE) * cx->xblocks + x/BLKSIZE_TIMES2;
 470
 471                                 // Test combination with current frame.
 472                                 tmp1 = ((long)currbot0[x] + (long)currbot2[x]);
 473 //                              diff = abs((long)currtop0[x] - (tmp1 >> 1));
 474                                 diff = abs((((long)currtop0[x] + (long)currtop2[x] + (long)currtop4[x])) - (tmp1 >> 1) - tmp1);
 475                                 if (diff > cx->nt)
 476                                 {
 477                                         c += diff;
 478 #ifdef WINDOWED_MATCH
 479                                         matchc[index] += diff;
 480 #endif
 481                                 }
 482
 483                                 tmp1 = currbot0[x] + T;
 484                                 tmp2 = currbot0[x] - T;
 485                                 vc = (tmp1 < currtop0[x] && tmp1 < currtop2[x]) ||
 486                                          (tmp2 > currtop0[x] && tmp2 > currtop2[x]);
 487                                 if (vc)
 488                                 {
 489                                         cx->sumc[index]++;
 490                                 }
 491
 492                                 // Test combination with previous frame.
 493                                 tmp1 = ((long)a0[x] + (long)a2[x]);
 494                                 diff = abs((((long)b0[x] + (long)b2[x] + (long)b4[x])) - (tmp1 >> 1) - tmp1);
 495                                 if (diff > cx->nt)
 496                                 {
 497                                         p += diff;
 498 #ifdef WINDOWED_MATCH
 499                                         matchp[index] += diff;
 500 #endif
 501                                 }
 502
 503                                 tmp1 = a0[x] + T;
 504                                 tmp2 = a0[x] - T;
 505                                 vc = (tmp1 < b0[x] && tmp1 < b2[x]) ||
 506                                          (tmp2 > b0[x] && tmp2 > b2[x]);
 507                                 if (vc)
 508                                 {
 509                                         cx->sump[index]++;
 510                                 }
 511
 512                                 x += skip;
 513                                 if (!(x&3)) x += 4;
 514                         }
 515                 }
 516                 currbot0 += cx->pitchtimes4;
 517                 currbot2 += cx->pitchtimes4;
 518                 currtop0 += cx->pitchtimes4;
 519                 currtop2 += cx->pitchtimes4;
 520                 currtop4 += cx->pitchtimes4;
 521                 a0               += cx->pitchtimes4;
 522                 a2               += cx->pitchtimes4;
 523                 b0               += cx->pitchtimes4;
 524                 b2               += cx->pitchtimes4;
 525                 b4               += cx->pitchtimes4;
 526         }
 527
 528 //      if (vi.IsYV12() && chroma == true)
 529 //      {
 530 //              int z;
 531 //
 532 //              for (z = 0; z < 2; z++)
 533 //              {
 534 //                      // Do the same for the U plane.
 535 //                      if (z == 0)
 536 //                      {
 537 //                              currbot0  = fcrpU + pitchover2;
 538 //                              currbot2  = fcrpU + 3 * pitchover2;
 539 //                              currtop0 = fcrpU;
 540 //                              currtop2 = fcrpU + 2 * pitchover2;
 541 //                              currtop4 = fcrpU + 4 * pitchover2;
 542 //                              prevbot0  = fprpU + pitchover2;
 543 //                              prevbot2  = fprpU + 3 * pitchover2;
 544 //                              prevtop0 = fprpU;
 545 //                              prevtop2 = fprpU + 2 * pitchover2;
 546 //                              prevtop4 = fprpU + 4 * pitchover2;
 547 //                      }
 548 //                      else
 549 //                      {
 550 //                              currbot0  = fcrpV + pitchover2;
 551 //                              currbot2  = fcrpV + 3 * pitchover2;
 552 //                              currtop0 = fcrpV;
 553 //                              currtop2 = fcrpV + 2 * pitchover2;
 554 //                              currtop4 = fcrpV + 4 * pitchover2;
 555 //                              prevbot0  = fprpV + pitchover2;
 556 //                              prevbot2  = fprpV + 3 * pitchover2;
 557 //                              prevtop0 = fprpV;
 558 //                              prevtop2 = fprpV + 2 * pitchover2;
 559 //                              prevtop4 = fprpV + 4 * pitchover2;
 560 //                      }
 561 //                      if (tff == true)
 562 //                      {
 563 //                              a0 = prevbot0;
 564 //                              a2 = prevbot2;
 565 //                              b0 = currtop0;
 566 //                              b2 = currtop2;
 567 //                              b4 = currtop4;
 568 //                      }
 569 //                      else
 570 //                      {
 571 //                              a0 = currbot0;
 572 //                              a2 = currbot2;
 573 //                              b0 = prevtop0;
 574 //                              b2 = prevtop2;
 575 //                              b4 = prevtop4;
 576 //                      }
 577 //
 578 //                      for (y = 0, index = 0; y < hover2 - 4; y+=4)
 579 //                      {
 580 //                              /* Exclusion band. Good for ignoring subtitles. */
 581 //                              if (y0 == y1 || y < y0/2 || y > y1/2)
 582 //                              {
 583 //                                      for (x = 0; x < wover2;)
 584 //                                      {
 585 //                                              if (vi.IsYV12())
 586 //                                                      index = (y/BLKSIZE)*xblocks + x/BLKSIZE;
 587 //                                              else
 588 //                                                      index = (y/BLKSIZE)*xblocks + x/BLKSIZE_TIMES2;
 589 //
 590 //                                              // Test combination with current frame.
 591 //                                              tmp1 = ((long)currbot0[x] + (long)currbot2[x]);
 592 //                                              diff = abs((((long)currtop0[x] + (long)currtop2[x] + (long)currtop4[x])) - (tmp1 >> 1) - tmp1);
 593 //                                              if (diff > nt)
 594 //                                              {
 595 //                                                      c += diff;
 596 //#ifdef WINDOWED_MATCH
 597 //                                                      matchc[index] += diff;
 598 //#endif
 599 //                                              }
 600 //
 601 //                                              tmp1 = currbot0[x] + T;
 602 //                                              tmp2 = currbot0[x] - T;
 603 //                                              vc = (tmp1 < currtop0[x] && tmp1 < currtop2[x]) ||
 604 //                                                       (tmp2 > currtop0[x] && tmp2 > currtop2[x]);
 605 //                                              if (vc)
 606 //                                              {
 607 //                                                      sumc[index]++;
 608 //                                              }
 609 //
 610 //                                              // Test combination with previous frame.
 611 //                                              tmp1 = ((long)a0[x] + (long)a2[x]);
 612 //                                              diff = abs((((long)b0[x] + (long)b2[x] + (long)b4[x])) - (tmp1 >> 1) - tmp1);
 613 //                                              if (diff > nt)
 614 //                                              {
 615 //                                                      p += diff;
 616 //#ifdef WINDOWED_MATCH
 617 //                                                      matchp[index] += diff;
 618 //#endif
 619 //                                              }
 620 //
 621 //                                              tmp1 = a0[x] + T;
 622 //                                              tmp2 = a0[x] - T;
 623 //                                              vc = (tmp1 < b0[x] && tmp1 < b2[x]) ||
 624 //                                                       (tmp2 > b0[x] && tmp2 > b2[x]);
 625 //                                              if (vc)
 626 //                                              {
 627 //                                                      sump[index]++;
 628 //                                              }
 629 //
 630 //                                              x ++;
 631 //                                              if (!(x&3)) x += 4;
 632 //                                      }
 633 //                              }
 634 //                              currbot0 += 4*pitchover2;
 635 //                              currbot2 += 4*pitchover2;
 636 //                              currtop0 += 4*pitchover2;
 637 //                              currtop2 += 4*pitchover2;
 638 //                              currtop4 += 4*pitchover2;
 639 //                              a0               += 4*pitchover2;
 640 //                              a2               += 4*pitchover2;
 641 //                              b0               += 4*pitchover2;
 642 //                              b2               += 4*pitchover2;
 643 //                              b4               += 4*pitchover2;
 644 //                      }
 645 //              }
 646 //      }
 647 //
 648 //      // Now find the blocks that have the greatest differences.
 649 //#ifdef WINDOWED_MATCH
 650 //      highest_matchp = 0;
 651 //      for (y = 0; y < yblocks; y++)
 652 //      {
 653 //              for (x = 0; x < xblocks; x++)
 654 //              {
 655 //if (frame == 45 && matchp[y * xblocks + x] > 2500)
 656 //{
 657 //      sprintf(buf, "%d/%d = %d\n", x, y, matchp[y * xblocks + x]);
 658 //      OutputDebugString(buf);
 659 //}
 660 //                      if (matchp[y * xblocks + x] > highest_matchp)
 661 //                      {
 662 //                              highest_matchp = matchp[y * xblocks + x];
 663 //                      }
 664 //              }
 665 //      }
 666 //      highest_matchc = 0;
 667 //      for (y = 0; y < yblocks; y++)
 668 //      {
 669 //              for (x = 0; x < xblocks; x++)
 670 //              {
 671 //if (frame == 44 && matchc[y * xblocks + x] > 2500)
 672 //{
 673 //      sprintf(buf, "%d/%d = %d\n", x, y, matchc[y * xblocks + x]);
 674 //      OutputDebugString(buf);
 675 //}
 676 //                      if (matchc[y * xblocks + x] > highest_matchc)
 677 //                      {
 678 //                              highest_matchc = matchc[y * xblocks + x];
 679 //                      }
 680 //              }
 681 //      }
 682 //#endif
 683         if ( cx->post )
 684         {
 685                 cx->highest_sump = 0;
 686                 for (y = 0; y < cx->yblocks; y++)
 687                 {
 688                         for (x = 0; x < cx->xblocks; x++)
 689                         {
 690                                 if (cx->sump[y * cx->xblocks + x] > cx->highest_sump)
 691                                 {
 692                                         cx->highest_sump = cx->sump[y * cx->xblocks + x];
 693                                 }
 694                         }
 695                 }
 696                 cx->highest_sumc = 0;
 697                 for (y = 0; y < cx->yblocks; y++)
 698                 {
 699                         for (x = 0; x < cx->xblocks; x++)
 700                         {
 701                                 if (cx->sumc[y * cx->xblocks + x] > cx->highest_sumc)
 702                                 {
 703                                         cx->highest_sumc = cx->sumc[y * cx->xblocks + x];
 704                                 }
 705                         }
 706                 }
 707         }
 708 #ifdef WINDOWED_MATCH
 709         CacheInsert(frame, highest_matchp, highest_sump, highest_matchc, highest_sumc);
 710 #else
 711         CacheInsert( cx, frame, p, cx->highest_sump, c, cx->highest_sumc);
 712 #endif
 713 }
 714
 715
 716 /** Process the image.
 717 */
 718
 719 static int get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
 720 {
 721         // Get the filter service
 722         mlt_filter filter = mlt_frame_pop_service( frame );
 723         mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
 724         mlt_properties frame_properties = mlt_frame_properties( frame );
 725         context cx = mlt_properties_get_data( properties, "context", NULL );
 726         mlt_service producer = mlt_service_producer( mlt_filter_service( filter ) );
 727         cx->out = producer? mlt_producer_get_playtime( MLT_PRODUCER( producer ) ) : 999999;
 728
 729         if ( ! cx->is_configured )
 730         {
 731                 cx->back = mlt_properties_get_int( properties, "back" );
 732                 cx->chroma = mlt_properties_get_int( properties, "chroma" );
 733                 cx->guide = mlt_properties_get_int( properties, "guide" );
 734                 cx->gthresh = mlt_properties_get_double( properties, "gthresh" );
 735                 cx->post = mlt_properties_get_int( properties, "post" );
 736                 cx->vthresh = mlt_properties_get_double( properties, "vthresh" );
 737                 cx->bthresh = mlt_properties_get_double( properties, "bthresh" );
 738                 cx->dthresh = mlt_properties_get_double( properties, "dthresh" );
 739                 cx->blend = mlt_properties_get_int( properties, "blend" );
 740                 cx->nt = mlt_properties_get_int( properties, "nt" );
 741                 cx->y0 = mlt_properties_get_int( properties, "y0" );
 742                 cx->y1 = mlt_properties_get_int( properties, "y1" );
 743                 cx->hints = mlt_properties_get_int( properties, "hints" );
 744                 cx->debug = mlt_properties_get_int( properties, "debug" );
 745                 cx->show = mlt_properties_get_int( properties, "show" );
 746         }
 747
 748         // Get the image
 749         int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
 750
 751         if ( ! cx->sump )
 752         {
 753                 int guide = mlt_properties_get_int( properties, "guide" );
 754                 cx->cycle = 0;
 755                 if ( guide == GUIDE_32 )
 756                 {
 757                         // 24fps to 30 fps telecine.
 758                         cx->cycle = 5;
 759                 }
 760                 else if ( guide == GUIDE_22 )
 761                 {
 762                         // PAL guidance (expect the current match to be continued).
 763                         cx->cycle = 2;
 764                 }
 765                 else if ( guide == GUIDE_32322 )
 766                 {
 767                         // 25fps to 30 fps telecine.
 768                         cx->cycle = 6;
 769                 }
 770
 771                 cx->xblocks = (*width+BLKSIZE-1) / BLKSIZE;
 772                 cx->yblocks = (*height+BLKSIZE-1) / BLKSIZE;
 773                 cx->sump = (unsigned int *) mlt_pool_alloc( cx->xblocks * cx->yblocks * sizeof(unsigned int) );
 774                 cx->sumc = (unsigned int *) mlt_pool_alloc( cx->xblocks * cx->yblocks * sizeof(unsigned int) );
 775                 mlt_properties_set_data( properties, "sump", cx->sump, cx->xblocks * cx->yblocks * sizeof(unsigned int), (mlt_destructor)mlt_pool_release, NULL );
 776                 mlt_properties_set_data( properties, "sumc", cx->sumc, cx->xblocks * cx->yblocks * sizeof(unsigned int), (mlt_destructor)mlt_pool_release, NULL );
 777                 cx->tff = mlt_properties_get_int( frame_properties, "top_field_first" );
 778         //      fprintf(stderr, "%s: TOP FIELD FIRST %d\n", __FUNCTION__, cx->tff );
 779         }
 780
 781         // Only process if we have no error and a valid colour space
 782         if ( error == 0 && *format == mlt_image_yuv422 )
 783         {
 784                 // Put the current image into the image cache, keyed on position
 785                 size_t image_size = (*width * *height) << 1;
 786                 mlt_position pos = mlt_frame_get_position( frame );
 787                 uint8_t *image_copy = mlt_pool_alloc( image_size );
 788                 memcpy( image_copy, *image, image_size );
 789                 char key[20];
 790                 sprintf( key, "%d", pos );
 791                 mlt_properties_set_data( cx->image_cache, key, image_copy, image_size, (mlt_destructor)mlt_pool_release, NULL );
 792
 793                 // Only if we have enough frame images cached
 794                 if ( pos > 1 && pos > cx->cycle + 1 )
 795                 {
 796                         pos -= cx->cycle + 1;
 797                         // Get the current frame image
 798                         sprintf( key, "%d", pos );
 799                         cx->fcrp = mlt_properties_get_data( cx->image_cache, key, NULL );
 800                         if (!cx->fcrp) return error;
 801
 802                         // Get the previous frame image
 803                         cx->pframe = pos == 0 ? 0 : pos - 1;
 804                         sprintf( key, "%d", cx->pframe );
 805                         cx->fprp = mlt_properties_get_data( cx->image_cache, key, NULL );
 806                         if (!cx->fprp) return error;
 807
 808                         // Get the next frame image
 809                         cx->nframe = pos > cx->out ? cx->out : pos + 1;
 810                         sprintf( key, "%d", cx->nframe );
 811                         cx->fnrp = mlt_properties_get_data( cx->image_cache, key, NULL );
 812                         if (!cx->fnrp) return error;
 813
 814                         cx->pitch = *width << 1;
 815                         cx->pitchover2 = cx->pitch >> 1;
 816                         cx->pitchtimes4 = cx->pitch << 2;
 817                         cx->w = *width << 1;
 818                         cx->h = *height;
 819                         if ((cx->w/2) & 1)
 820                                 fprintf( stderr, "%s: width must be a multiple of 2\n", __FUNCTION__ );
 821                         if (cx->h & 1)
 822                                 fprintf( stderr, "%s: height must be a multiple of 2\n", __FUNCTION__ );
 823                         cx->wover2 = cx->w/2;
 824                         cx->hover2 = cx->h/2;
 825                         cx->hplus1over2 = (cx->h+1)/2;
 826                         cx->hminus2 = cx->h - 2;
 827                         cx->dpitch = cx->pitch;
 828
 829                         // Ensure that the metrics for the frames
 830                         // after the current frame are in the cache. They will be used for
 831                         // pattern guidance.
 832                         if ( cx->guide )
 833                         {
 834                                 for ( cx->y = pos + 1; (cx->y <= pos + cx->cycle + 1) && (cx->y <= cx->out); cx->y++ )
 835                                 {
 836                                         if ( ! CacheQuery( cx, cx->y, &cx->p, &cx->pblock, &cx->c, &cx->cblock ) )
 837                                         {
 838                                                 sprintf( key, "%d", cx->y );
 839                                                 cx->crp = (unsigned char *) mlt_properties_get_data( cx->image_cache, key, NULL );
 840                                                 sprintf( key, "%d", cx->y ? cx->y - 1 : 1 );
 841                                                 cx->prp = (unsigned char *) mlt_properties_get_data( cx->image_cache, key, NULL );
 842                                                 CalculateMetrics( cx, cx->y, cx->crp, NULL, NULL, cx->prp, NULL, NULL );                                        }
 843                                 }
 844                         }
 845
 846                         // Check for manual overrides of the field matching.
 847                         cx->found = 0;
 848                         cx->film = 1;
 849                         cx->override = 0;
 850                         cx->inpattern = 0;
 851                         cx->vthresh = cx->vthresh;
 852                         cx->back = cx->back_saved;
 853
 854                         // Get the metrics for the current-previous (p), current-current (c), and current-next (n) match candidates.
 855                         if ( ! CacheQuery( cx, pos, &cx->p, &cx->pblock, &cx->c, &cx->cblock ) )
 856                         {
 857                                 CalculateMetrics( cx, pos, cx->fcrp, NULL, NULL, cx->fprp, NULL, NULL );
 858                                 CacheQuery( cx, pos, &cx->p, &cx->pblock, &cx->c, &cx->cblock );
 859                         }
 860                         if ( ! CacheQuery( cx, cx->nframe, &cx->np, &cx->npblock, &cx->nc, &cx->ncblock ) )
 861                         {
 862                                 CalculateMetrics( cx, cx->nframe, cx->fnrp, NULL, NULL, cx->fcrp, NULL, NULL );
 863                                 CacheQuery( cx, cx->nframe, &cx->np, &cx->npblock, &cx->nc, &cx->ncblock );
 864                         }
 865
 866                         // Determine the best candidate match.
 867                         if ( !cx->found )
 868                         {
 869                                 cx->lowest = cx->c;
 870                                 cx->chosen = C;
 871                                 if ( cx->back == ALWAYS_BACK && cx->p < cx->lowest )
 872                                 {
 873                                         cx->lowest = cx->p;
 874                                         cx->chosen = P;
 875                                 }
 876                                 if ( cx->np < cx->lowest )
 877                                 {
 878                                         cx->lowest = cx->np;
 879                                         cx->chosen = N;
 880                                 }
 881                         }
 882                         if ((pos == 0 && cx->chosen == P) || (pos == cx->out && cx->chosen == N))
 883                         {
 884                                 cx->chosen = C;
 885                                 cx->lowest = cx->c;
 886                         }
 887
 888                         // See if we can apply pattern guidance.
 889                         cx->mismatch = 100.0;
 890                         if ( cx->guide )
 891                         {
 892                                 cx->hard = 0;
 893                                 if ( pos >= cx->cycle && PredictHardYUY2( cx, pos, &cx->predicted, &cx->predicted_metric) )
 894                                 {
 895                                         cx->inpattern = 1;
 896                                         cx->mismatch = 0.0;
 897                                         cx->hard = 1;
 898                                         if ( cx->chosen != cx->predicted )
 899                                         {
 900                                                 // The chosen frame doesn't match the prediction.
 901                                                 if ( cx->predicted_metric == 0 )
 902                                                         cx->mismatch = 0.0;
 903                                                 else
 904                                                         cx->mismatch = (100.0 * abs( cx->predicted_metric - cx->lowest ) ) / cx->predicted_metric;
 905                                                 if ( cx->mismatch < cx->gthresh )
 906                                                 {
 907                                                         // It's close enough, so use the predicted one.
 908                                                         if ( !cx->found )
 909                                                         {
 910                                                                 cx->chosen = cx->predicted;
 911                                                                 cx->override = 1;
 912                                                         }
 913                                                 }
 914                                                 else
 915                                                 {
 916                                                         cx->hard = 0;
 917                                                         cx->inpattern = 0;
 918                                                 }
 919                                         }
 920                                 }
 921
 922                                 if ( !cx->hard && cx->guide != GUIDE_22 )
 923                                 {
 924                                         int i;
 925                                         struct PREDICTION *pred = PredictSoftYUY2( cx, pos );
 926
 927                                         if ( ( pos <= cx->out - cx->cycle) && ( pred[0].metric != 0xffffffff ) )
 928                                         {
 929                                                 // Apply pattern guidance.
 930                                                 // If the predicted match metric is within defined percentage of the
 931                                                 // best calculated one, then override the calculated match with the
 932                                                 // predicted match.
 933                                                 i = 0;
 934                                                 while ( pred[i].metric != 0xffffffff )
 935                                                 {
 936                                                         cx->predicted = pred[i].predicted;
 937                                                         cx->predicted_metric = pred[i].predicted_metric;
 938 #ifdef DEBUG_PATTERN_GUIDANCE
 939                                                         fprintf(stderr, "%s: pos=%d predicted=%d\n", __FUNCTION__, pos, cx->predicted);
 940 #endif
 941                                                         if ( cx->chosen != cx->predicted )
 942                                                         {
 943                                                                 // The chosen frame doesn't match the prediction.
 944                                                                 if ( cx->predicted_metric == 0 )
 945                                                                         cx->mismatch = 0.0;
 946                                                                 else
 947                                                                         cx->mismatch = (100.0 * abs( cx->predicted_metric - cx->lowest )) / cx->predicted_metric;
 948                                                                 if ( (int) cx->mismatch <= cx->gthresh )
 949                                                                 {
 950                                                                         // It's close enough, so use the predicted one.
 951                                                                         if ( !cx->found )
 952                                                                         {
 953                                                                                 cx->chosen = cx->predicted;
 954                                                                                 cx->override = 1;
 955                                                                         }
 956                                                                         cx->inpattern = 1;
 957                                                                         break;
 958                                                                 }
 959                                                                 else
 960                                                                 {
 961                                                                         // Looks like we're not in a predictable pattern.
 962                                                                         cx->inpattern = 0;
 963                                                                 }
 964                                                         }
 965                                                         else
 966                                                         {
 967                                                                 cx->inpattern = 1;
 968                                                                 cx->mismatch = 0.0;
 969                                                                 break;
 970                                                         }
 971                                                         i++;
 972                                                 }
 973                                         }
 974                                 }
 975                         }
 976
 977                         // Check the match for progressive versus interlaced.
 978                         if ( cx->post )
 979                         {
 980                                 if (cx->chosen == P) cx->vmetric = cx->pblock;
 981                                 else if (cx->chosen == C) cx->vmetric = cx->cblock;
 982                                 else if (cx->chosen == N) cx->vmetric = cx->npblock;
 983
 984                                 if ( !cx->found && cx->back == BACK_ON_COMBED && cx->vmetric > cx->bthresh && cx->p < cx->lowest )
 985                                 {
 986                                         // Backward match.
 987                                         cx->vmetric = cx->pblock;
 988                                         cx->chosen = P;
 989                                         cx->inpattern = 0;
 990                                         cx->mismatch = 100;
 991                                 }
 992                                 if ( cx->vmetric > cx->vthresh )
 993                                 {
 994                                         // After field matching and pattern guidance the frame is still combed.
 995                                         cx->film = 0;
 996                                         if ( !cx->found && ( cx->post == POST_FULL_NOMATCH || cx->post == POST_FULL_NOMATCH_MAP ) )
 997                                         {
 998                                                 cx->chosen = C;
 999                                                 cx->vmetric = cx->cblock;
1000                                                 cx->inpattern = 0;
1001                                                 cx->mismatch = 100;
1002                                         }
1003                                 }
1004                         }
1005                         cx->vthresh = cx->vthresh_saved;
1006
1007                         // Setup strings for debug info.
1008                         if ( cx->inpattern && !cx->override ) strcpy( cx->status, "[in-pattern]" );
1009                         else if ( cx->inpattern && cx->override ) strcpy( cx->status, "[in-pattern*]" );
1010                         else strcpy( cx->status, "[out-of-pattern]" );
1011
1012                         // Assemble and output the reconstructed frame according to the final match.
1013                         cx->dstp = *image;
1014                         if ( cx->chosen == N )
1015                         {
1016                                 // The best match was with the next frame.
1017                                 if ( cx->tff )
1018                                 {
1019                                         BitBlt( cx->dstp, 2 * cx->dpitch, cx->fnrp, 2 * cx->pitch, cx->w, cx->hover2 );
1020                                         BitBlt( cx->dstp + cx->dpitch, 2 * cx->dpitch, cx->fcrp + cx->pitch, 2 * cx->pitch,     cx->w, cx->hover2 );
1021                                 }
1022                                 else
1023                                 {
1024                                         BitBlt( cx->dstp, 2 * cx->dpitch, cx->fcrp, 2 * cx->pitch, cx->w, cx->hplus1over2 );
1025                                         BitBlt( cx->dstp + cx->dpitch, 2 * cx->dpitch, cx->fnrp + cx->pitch, 2 * cx->pitch,     cx->w, cx->hover2 );
1026                                 }
1027                         }
1028                         else if ( cx->chosen == C )
1029                         {
1030                                 // The best match was with the current frame.
1031                                 BitBlt( cx->dstp, 2 * cx->dpitch, cx->fcrp, 2 * cx->pitch, cx->w, cx->hplus1over2 );
1032                                 BitBlt( cx->dstp + cx->dpitch, 2 * cx->dpitch, cx->fcrp + cx->pitch, 2 * cx->pitch,     cx->w, cx->hover2 );
1033                         }
1034                         else if ( ! cx->tff )
1035                         {
1036                                 // The best match was with the previous frame.
1037                                 BitBlt( cx->dstp, 2 * cx->dpitch, cx->fprp, 2 * cx->pitch, cx->w, cx->hplus1over2 );
1038                                 BitBlt( cx->dstp + cx->dpitch, 2 * cx->dpitch, cx->fcrp + cx->pitch, 2 * cx->pitch, cx->w, cx->hover2 );
1039                         }
1040                         else
1041                         {
1042                                 // The best match was with the previous frame.
1043                                 BitBlt( cx->dstp, 2 * cx->dpitch, cx->fcrp, 2 * cx->pitch, cx->w, cx->hplus1over2 );
1044                                 BitBlt( cx->dstp + cx->dpitch, 2 * cx->dpitch, cx->fprp + cx->pitch, 2 * cx->pitch,     cx->w, cx->hover2 );
1045                         }
1046                         if ( cx->guide )
1047                                 PutChosen( cx, pos, cx->chosen );
1048
1049                         if ( !cx->post || cx->post == POST_METRICS )
1050                         {
1051                                 if ( cx->force == '+') cx->film = 0;
1052                                 else if ( cx->force == '-' ) cx->film = 1;
1053                         }
1054                         else if ((cx->force == '+') ||
1055                                 ((cx->post == POST_FULL || cx->post == POST_FULL_MAP || cx->post == POST_FULL_NOMATCH || cx->post == POST_FULL_NOMATCH_MAP)
1056                                          && (cx->film == 0 && cx->force != '-')))
1057                         {
1058                                 unsigned char *dstpp, *dstpn;
1059                                 int v1, v2;
1060
1061                                 if ( cx->blend )
1062                                 {
1063                                         // Do first and last lines.
1064                                         uint8_t *final = mlt_pool_alloc( image_size );
1065                                         cx->finalp = final;
1066                                         mlt_properties_set_data( frame_properties, "image", final, image_size, (mlt_destructor)mlt_pool_release, NULL );
1067                                         dstpn = cx->dstp + cx->dpitch;
1068                                         for ( cx->x = 0; cx->x < cx->w; cx->x++ )
1069                                         {
1070                                                 cx->finalp[cx->x] = (((int)cx->dstp[cx->x] + (int)dstpn[cx->x]) >> 1);
1071                                         }
1072                                         cx->finalp = final + (cx->h-1)*cx->dpitch;
1073                                         cx->dstp = *image + (cx->h-1)*cx->dpitch;
1074                                         dstpp = cx->dstp - cx->dpitch;
1075                                         for ( cx->x = 0; cx->x < cx->w; cx->x++ )
1076                                         {
1077                                                 cx->finalp[cx->x] = (((int)cx->dstp[cx->x] + (int)dstpp[cx->x]) >> 1);
1078                                         }
1079                                         // Now do the rest.
1080                                         cx->dstp = *image + cx->dpitch;
1081                                         dstpp = cx->dstp - cx->dpitch;
1082                                         dstpn = cx->dstp + cx->dpitch;
1083                                         cx->finalp = final + cx->dpitch;
1084                                         for ( cx->y = 1; cx->y < cx->h - 1; cx->y++ )
1085                                         {
1086                                                 for ( cx->x = 0; cx->x < cx->w; cx->x++ )
1087                                                 {
1088                                                         v1 = (int) cx->dstp[cx->x] - cx->dthresh;
1089                                                         if ( v1 < 0 )
1090                                                                 v1 = 0;
1091                                                         v2 = (int) cx->dstp[cx->x] + cx->dthresh;
1092                                                         if (v2 > 235) v2 = 235;
1093                                                         if ((v1 > dstpp[cx->x] && v1 > dstpn[cx->x]) || (v2 < dstpp[cx->x] && v2 < dstpn[cx->x]))
1094                                                         {
1095                                                                 if ( cx->post == POST_FULL_MAP || cx->post == POST_FULL_NOMATCH_MAP )
1096                                                                 {
1097                                                                         if (cx->x & 1) cx->finalp[cx->x] = 128;
1098                                                                         else cx->finalp[cx->x] = 235;
1099                                                                 }
1100                                                                 else
1101                                                                         cx->finalp[cx->x] = ((int)dstpp[cx->x] + (int)dstpn[cx->x] + (int)cx->dstp[cx->x] + (int)cx->dstp[cx->x]) >> 2;
1102                                                         }
1103                                                         else cx->finalp[cx->x] = cx->dstp[cx->x];
1104                                                 }
1105                                                 cx->finalp += cx->dpitch;
1106                                                 cx->dstp += cx->dpitch;
1107                                                 dstpp += cx->dpitch;
1108                                                 dstpn += cx->dpitch;
1109                                         }
1110
1111
1112                                         if (cx->show ) Show( cx, pos, frame_properties);
1113                                         if (cx->debug) Debug(cx, pos);
1114                                         if (cx->hints) WriteHints(cx->film, cx->inpattern, frame_properties);
1115                                         goto final;
1116                                 }
1117
1118                                 // Interpolate mode.
1119                                 cx->dstp = *image + cx->dpitch;
1120                                 dstpp = cx->dstp - cx->dpitch;
1121                                 dstpn = cx->dstp + cx->dpitch;
1122                                 for ( cx->y = 1; cx->y < cx->h - 1; cx->y+=2 )
1123                                 {
1124                                         for ( cx->x = 0; cx->x < cx->w; cx->x++ )
1125                                         {
1126                                                 v1 = (int) cx->dstp[cx->x] - cx->dthresh;
1127                                                 if (v1 < 0) v1 = 0;
1128                                                 v2 = (int) cx->dstp[cx->x] + cx->dthresh;
1129                                                 if (v2 > 235) v2 = 235;
1130                                                 if ((v1 > dstpp[cx->x] && v1 > dstpn[cx->x]) || (v2 < dstpp[cx->x] && v2 < dstpn[cx->x]))
1131                                                 {
1132                                                         if ( cx->post == POST_FULL_MAP || cx->post == POST_FULL_NOMATCH_MAP )
1133                                                         {
1134                                                                 if (cx->x & 1) cx->dstp[cx->x] = 128;
1135                                                                 else cx->dstp[cx->x] = 235;
1136                                                         }
1137                                                         else
1138                                                                 cx->dstp[cx->x] = (dstpp[cx->x] + dstpn[cx->x]) >> 1;
1139                                                 }
1140                                         }
1141                                         cx->dstp += 2 * cx->dpitch;
1142                                         dstpp += 2 * cx->dpitch;
1143                                         dstpn += 2 * cx->dpitch;
1144                                 }
1145                         }
1146                         if (cx->show ) Show( cx, pos, frame_properties);
1147                         if (cx->debug) Debug(cx, pos);
1148                         if (cx->hints) WriteHints(cx->film, cx->inpattern, frame_properties);
1149
1150 final:
1151                         // Flush frame at tail of period from the cache
1152                         sprintf( key, "%d", pos - 1 );
1153                         mlt_properties_set_data( cx->image_cache, key, NULL, 0, NULL, NULL );
1154                 }
1155                 else
1156                 {
1157                         // Signal the first {cycle} frames as invalid
1158                         mlt_properties_set_int( frame_properties, "garbage", 1 );
1159                 }
1160         }
1161         else if ( error == 0 && *format == mlt_image_yuv420p )
1162         {
1163                 fprintf(stderr,"%s: %d pos %d\n", __FUNCTION__, *width * *height * 3/2, mlt_frame_get_position(frame) );
1164         }
1165
1166         return error;
1167 }
1168
1169 /** Process the frame object.
1170 */
1171
1172 static mlt_frame process( mlt_filter this, mlt_frame frame )
1173 {
1174         // Push the filter on to the stack
1175         mlt_frame_push_service( frame, this );
1176
1177         // Push the frame filter
1178         mlt_frame_push_get_image( frame, get_image );
1179
1180         return frame;
1181 }
1182
1183 /** Constructor for the filter.
1184 */
1185
1186 mlt_filter filter_telecide_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
1187 {
1188         mlt_filter this = mlt_filter_new( );
1189         if ( this != NULL )
1190         {
1191                 this->process = process;
1192
1193                 // Allocate the context and set up for garbage collection
1194                 context cx = (context) mlt_pool_alloc( sizeof(struct context_s) );
1195                 memset( cx, 0, sizeof( struct context_s ) );
1196                 mlt_properties properties = MLT_FILTER_PROPERTIES( this );
1197                 mlt_properties_set_data( properties, "context", cx, sizeof(struct context_s), (mlt_destructor)mlt_pool_release, NULL );
1198
1199                 // Allocate the metrics cache and set up for garbage collection
1200                 cx->cache = (struct CACHE_ENTRY *) mlt_pool_alloc(CACHE_SIZE * sizeof(struct CACHE_ENTRY ));
1201                 mlt_properties_set_data( properties, "cache", cx->cache, CACHE_SIZE * sizeof(struct CACHE_ENTRY), (mlt_destructor)mlt_pool_release, NULL );
1202                 int i;
1203                 for (i = 0; i < CACHE_SIZE; i++)
1204                 {
1205                         cx->cache[i].frame = 0xffffffff;
1206                         cx->cache[i].chosen = 0xff;
1207                 }
1208
1209                 // Allocate the image cache and set up for garbage collection
1210                 cx->image_cache = mlt_properties_new();
1211                 mlt_properties_set_data( properties, "image_cache", cx->image_cache, 0, (mlt_destructor)mlt_properties_close, NULL );
1212
1213                 // Initialize the parameter defaults
1214                 mlt_properties_set_int( properties, "guide", 0 );
1215                 mlt_properties_set_int( properties, "back", 0 );
1216                 mlt_properties_set_int( properties, "chroma", 0 );
1217                 mlt_properties_set_int( properties, "post", POST_FULL );
1218                 mlt_properties_set_double( properties, "gthresh", 10.0 );
1219                 mlt_properties_set_double( properties, "vthresh", 50.0 );
1220                 mlt_properties_set_double( properties, "bthresh", 50.0 );
1221                 mlt_properties_set_double( properties, "dthresh", 7.0 );
1222                 mlt_properties_set_int( properties, "blend", 0 );
1223                 mlt_properties_set_int( properties, "nt", 10 );
1224                 mlt_properties_set_int( properties, "y0", 0 );
1225                 mlt_properties_set_int( properties, "y1", 0 );
1226                 mlt_properties_set_int( properties, "hints", 1 );
1227         }
1228         return this;
1229 }
1230