开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
deintl.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：57k
源码类别：

Symbian

开发平台：

C/C++

deintl.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  37. ////////////////////////////////////////////////////////
  38. // defines
  39. ////////////////////////////////////////////////////////
  41. // Defineing TIME_DEINTERLACE will time the deinterlacer
  42. // and write a file with filename TIME_DEINTERLACE_FILENAME
  43. // with the times.
  45. //#define TIME_DEINTERLACE
  46. //#define TIME_DEINTERLACE_FILENAME "d:\dintl.log"
  48. ////////////////////////////////////////////////////////
  49. // include files
  50. ////////////////////////////////////////////////////////
  52. #include "hlxclib/stdlib.h"
  53. #include "hlxclib/string.h"
  55. #define INTL_I420_CODE
  57. #ifdef TIME_DEINTERLACE
  58. #include "hlxclib/stdio.h"
  59. #endif
  61. #include "mmx_util.h"
  62. #include "deintl.h"
  65. ////////////////////////////////////////////////////////
  66. // internal prototypes
  67. ////////////////////////////////////////////////////////
  69. static void
  70. Deinterlace_RGB24(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format);
  72. static void
  73. Deinterlace_I420(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format);
  75. static void
  76. Deinterlace_RGB24_Fast(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format);
  78. static void
  79. Deinterlace_I420_Fast(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format);
  81. static void
  82. Deinterlace_I420_Advanced(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format);
  84. static void
  85. Deinterlace_I420_EdgeInterp(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format);
  87. static void
  88. Deinterlace_RGB24_Field(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format, int field);
  90. static void
  91. Deinterlace_I420_Field(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format, int field);
  93. static void
  94. Deinterlace_I420_FlipFlop(unsigned char *frame, unsigned char *temp_frame, int pels, int lines, int pitch, int format);
  96. #ifdef _M_IX86
  98. static void
  99. Deinterlace_I420_MMX(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format);
  101. #endif
  103. int
  104. C_DetectInterlace_I420(unsigned char *frame, unsigned char *prev_frame, int first_frame, int pels, int lines, int pitch);
  107. ////////////////////////////////////////////////////////
  108. // macros
  109. ////////////////////////////////////////////////////////
  111. #define MEDIAN_3(a,b,c)
  112. ((a > b)?
  113. (
  114. (b > c)?
  115. (b):
  116. (
  117. (a > c)?
  118. (c):
  119. (a)
  120. )
  121. ):
  122. (
  123. (a > c)?
  124. (a):
  125. (
  126. (b > c)?
  127. (c):
  128. (b)
  129. )
  130. ))
  132. #define MABS(v) (tmp=(v),((tmp)^(tmp>>31)))
  133. #define ABS(a)  (((a) < 0) ? (-(a)) : (a))
  134. #define DIFF_FCN(v) ((v)*(v)) // Squared difference
  136. static const int SQUARED_TAB[255+255+1] = {
  137.     65025,  64516,  64009,  63504,  63001,  62500,
  138.     62001,  61504,  61009,  60516,  60025,  59536,  59049,  58564,  58081,  57600,
  139.     57121,  56644,  56169,  55696,  55225,  54756,  54289,  53824,  53361,  52900,
  140.     52441,  51984,  51529,  51076,  50625,  50176,  49729,  49284,  48841,  48400,
  141.     47961,  47524,  47089,  46656,  46225,  45796,  45369,  44944,  44521,  44100,
  142.     43681,  43264,  42849,  42436,  42025,  41616,  41209,  40804,  40401,  40000,
  143.     39601,  39204,  38809,  38416,  38025,  37636,  37249,  36864,  36481,  36100,
  144.     35721,  35344,  34969,  34596,  34225,  33856,  33489,  33124,  32761,  32400,
  145.     32041,  31684,  31329,  30976,  30625,  30276,  29929,  29584,  29241,  28900,
  146.     28561,  28224,  27889,  27556,  27225,  26896,  26569,  26244,  25921,  25600,
  147.     25281,  24964,  24649,  24336,  24025,  23716,  23409,  23104,  22801,  22500,
  148.     22201,  21904,  21609,  21316,  21025,  20736,  20449,  20164,  19881,  19600,
  149.     19321,  19044,  18769,  18496,  18225,  17956,  17689,  17424,  17161,  16900,
  150.     16641,  16384,  16129,  15876,  15625,  15376,  15129,  14884,  14641,  14400,
  151.     14161,  13924,  13689,  13456,  13225,  12996,  12769,  12544,  12321,  12100,
  152.     11881,  11664,  11449,  11236,  11025,  10816,  10609,  10404,  10201,  10000,
  153.     9801,   9604,   9409,   9216,   9025,   8836,   8649,   8464,   8281,   8100,
  154.     7921,   7744,   7569,   7396,   7225,   7056,   6889,   6724,   6561,   6400,
  155.     6241,   6084,   5929,   5776,   5625,   5476,   5329,   5184,   5041,   4900,
  156.     4761,   4624,   4489,   4356,   4225,   4096,   3969,   3844,   3721,   3600,
  157.     3481,   3364,   3249,   3136,   3025,   2916,   2809,   2704,   2601,   2500,
  158.     2401,   2304,   2209,   2116,   2025,   1936,   1849,   1764,   1681,   1600,
  159.     1521,   1444,   1369,   1296,   1225,   1156,   1089,   1024,   961,    900,
  160.     841,    784,    729,    676,    625,    576,    529,    484,    441,    400,
  161.     361,    324,    289,    256,    225,    196,    169,    144,    121,    100,
  162.     81,     64,     49,     36,     25,     16,     9,      4,      1,      0,
  163.     1,      4,      9,      16,     25,     36,     49,     64,     81,     100,
  164.     121,    144,    169,    196,    225,    256,    289,    324,    361,    400,
  165.     441,    484,    529,    576,    625,    676,    729,    784,    841,    900,
  166.     961,    1024,   1089,   1156,   1225,   1296,   1369,   1444,   1521,   1600,
  167.     1681,   1764,   1849,   1936,   2025,   2116,   2209,   2304,   2401,   2500,
  168.     2601,   2704,   2809,   2916,   3025,   3136,   3249,   3364,   3481,   3600,
  169.     3721,   3844,   3969,   4096,   4225,   4356,   4489,   4624,   4761,   4900,
  170.     5041,   5184,   5329,   5476,   5625,   5776,   5929,   6084,   6241,   6400,
  171.     6561,   6724,   6889,   7056,   7225,   7396,   7569,   7744,   7921,   8100,
  172.     8281,   8464,   8649,   8836,   9025,   9216,   9409,   9604,   9801,   10000,
  173.     10201,  10404,  10609,  10816,  11025,  11236,  11449,  11664,  11881,  12100,
  174.     12321,  12544,  12769,  12996,  13225,  13456,  13689,  13924,  14161,  14400,
  175.     14641,  14884,  15129,  15376,  15625,  15876,  16129,  16384,  16641,  16900,
  176.     17161,  17424,  17689,  17956,  18225,  18496,  18769,  19044,  19321,  19600,
  177.     19881,  20164,  20449,  20736,  21025,  21316,  21609,  21904,  22201,  22500,
  178.     22801,  23104,  23409,  23716,  24025,  24336,  24649,  24964,  25281,  25600,
  179.     25921,  26244,  26569,  26896,  27225,  27556,  27889,  28224,  28561,  28900,
  180.     29241,  29584,  29929,  30276,  30625,  30976,  31329,  31684,  32041,  32400,
  181.     32761,  33124,  33489,  33856,  34225,  34596,  34969,  35344,  35721,  36100,
  182.     36481,  36864,  37249,  37636,  38025,  38416,  38809,  39204,  39601,  40000,
  183.     40401,  40804,  41209,  41616,  42025,  42436,  42849,  43264,  43681,  44100,
  184.     44521,  44944,  45369,  45796,  46225,  46656,  47089,  47524,  47961,  48400,
  185.     48841,  49284,  49729,  50176,  50625,  51076,  51529,  51984,  52441,  52900,
  186.     53361,  53824,  54289,  54756,  55225,  55696,  56169,  56644,  57121,  57600,
  187.     58081,  58564,  59049,  59536,  60025,  60516,  61009,  61504,  62001,  62500,
  188.     63001,  63504,  64009,  64516,  65025
  189. };
  191. #define MSQUARED(v) (SQUARED_TAB[(v) + 255])
  193. // Some thresholds
  194. #define INTL_DIFF_THRESH 40000
  195. #define INTL_HORIZ_THRESH 80
  197. #ifdef TIME_DEINTERLACE
  198. static unsigned int num_avg = 0;
  199. static unsigned int num_med = 0;
  200. #endif
  203. int
  204. InitDeinterlace (
  205. int pels, int lines, int pitch, 
  206. int format, 
  207. INTL_MODE mode, 
  208. T_DEINTL_STATE **state)
  209. {
  210. T_DEINTL_STATE *new_state = 0;
  212. if (*state == 0)
  213. {
  214. new_state = (T_DEINTL_STATE *)malloc(sizeof(T_DEINTL_STATE));
  215. }
  217. if (new_state == 0)
  218. return 1;
  220. new_state->pels = pels;
  221. new_state->lines = lines;
  222. new_state->pitch = pitch;
  223. new_state->format = format;
  224. new_state->detection_measure = (lines > 242)?(16):(0);
  225. new_state->commit_deinterlace = FALSE;
  227. *state = new_state;
  229. return 0;
  230. }
  232. void
  233. FreeDeinterlace (T_DEINTL_STATE **state)
  234. {
  235. if (*state != 0)
  236. free(*state);
  237. *state = 0;
  238. }
  240. BOOL
  241. IsContentInterlaced (T_DEINTL_STATE *state)
  242. {
  243. if (state != 0)
  244. return (state->commit_deinterlace == 1)?(TRUE):(FALSE);
  246. return FALSE;
  247. }
  249. void
  250. ResetDeinterlace (T_DEINTL_STATE *state)
  251. {
  252. state->detection_measure = 0;
  253. state->commit_deinterlace = FALSE;
  254. }
  257. ////////////////////////////////////////////////////////
  258. //
  259. // Deinterlace
  260. //
  261. // Top level function to deinterlace a video frame
  262. //
  263. // Parameters:
  264. // frame: Pointer to the frame to deinterlace
  265. // prev_frame: Pointer to the previous frame.
  266. // Better results are achieved by giving
  267. // the previous *interlaced* frame
  268. // pels,
  269. // lines,
  270. // pitch: Frame dimensions
  271. // format: INTL_FORMAT_RGB24 or INTL_FORMAT_I420
  272. // mode: Choose either using both fields or
  273. // to remove one field entirely
  274. // (see 'deintl.h')
  275. //
  276. ////////////////////////////////////////////////////////
  278. int
  279. Deinterlace(
  280. unsigned char *frame, 
  281. unsigned char *prev_frame,
  282. int pels, int lines, int pitch,
  283. int format,
  284. int first_frame, 
  285. INTL_MODE mode,
  286. T_DEINTL_STATE *state)
  287. {
  288. if (pels == 0)
  289. pels = state->pels;
  290. if (lines == 0)
  291. lines = state->lines;
  292. if (pitch == 0)
  293. pitch = state->pitch;
  294. if (format == 0)
  295. format = state->format;
  297. unsigned char *pfp = (first_frame == TRUE)?(NULL):(prev_frame);
  299. // Unless were going to do detection first (i.e. in INTL_MODE_SMART_AUTO mode),
  300. // don't de-interlace when there is less than 242 lines.  This is a little
  301. // check to prevent unintentional de-interlacing of probable progressive frames.
  302. if (lines < 242 && mode != INTL_MODE_SMART_AUTO)
  303. return 0;
  305. // Run detection
  306. if (mode == INTL_MODE_SMART_AUTO)
  307. {
  308. unsigned char *detection_frame;
  309. unsigned char *detection_prev_frame;
  310. int res;
  312. if (format == INTL_FORMAT_I420)
  313. {
  314. // point to the Y-Plane
  315. detection_frame = frame;
  316. detection_prev_frame = prev_frame;
  317. }
  318. if (format == INTL_FORMAT_RGB24)
  319. {
  320. // point to the G-Plane
  321. detection_frame = frame + pels * lines;
  322. detection_prev_frame = prev_frame + pels * lines;
  323. }
  325. // Perform detection
  326. res = C_DetectInterlace_I420(
  327. detection_frame, 
  328. detection_prev_frame, 
  329. first_frame, 
  330. pels, lines, pitch);
  332. // Update the "detection measure" based on result of detection
  333. switch (res)
  334. {
  335. case INTL_STRONG_INTERLACE:
  336. {
  337. state->detection_measure = (31 * state->detection_measure + 256) >> 5;
  338. }
  339. break;
  341. case INTL_WEAK_INTERLACE:
  342. {
  343. state->detection_measure = (31 * state->detection_measure + 256) >> 5;
  344. }
  345. break;
  347. case INTL_WEAK_PROGRESSIVE:
  348. {
  349. state->detection_measure = (31 * state->detection_measure + 0) >> 5;
  350. }
  351. break;
  353. case INTL_STRONG_PROGRESSIVE:
  354. {
  355. state->detection_measure = 0;
  356. }
  357. break;
  358. }
  360. // If the detection measure is above a threshold, set this flag used
  361. // to indicate we are confident the content is interlaced.
  362. if (state->detection_measure > 128)
  363. {
  364. state->commit_deinterlace = TRUE;
  365. }
  367. // If the detection measure is above this threshold, we should
  368. // de-interlace this frame. Otherwise, return without de-interlacing
  369. if (state->detection_measure > 16)
  370. {
  371. mode = INTL_MODE_SMART;
  372. }
  373. else
  374. {
  375. return 0;
  376. }
  377. }
  379. #ifdef TIME_DEINTERLACE
  380. FILE *fp = NULL;
  381. double proc_time;
  383. USE_CODEC_TIMER;
  385. num_avg = 0;
  386. num_med = 0;
  388. START_CODEC_TIMER;
  389. #endif
  391. switch (format)
  392. {
  394. #ifdef INTL_RBG24_CODE
  395. case INTL_FORMAT_RGB24:
  396. Deinterlace_RGB24_Fast(frame, pfp, pels, lines, pitch, format);
  397. break;
  398. #endif
  400. #ifdef INTL_I420_CODE
  402. case INTL_FORMAT_I420:
  404. #ifdef USE_MMX_DEINTERLACING //_M_IX86
  405.         if (checkMmxAvailablity() & CPU_HAS_MMX)
  406. Deinterlace_I420_MMX(frame, pfp, pels, lines, pitch, format);
  407. else
  408. #endif
  409. // Neelesh's new deinterlacer.
  410. Deinterlace_I420_Advanced(frame, pfp, pels, lines, pitch, format);
  412. break;
  414. #endif
  415. }
  417. #ifdef TIME_DEINTERLACE
  418. STOP_CODEC_TIMER(proc_time);
  420. fp = fopen(TIME_DEINTERLACE_FILENAME,"a+");
  421. if (fp != NULL)
  422. {
  423. fprintf(fp,"deinterlace timet%ft%dt%dn",proc_time,num_avg,num_med);
  424. fclose(fp);
  425. }
  426. #endif
  428. return 1;
  429. }
  432. ////////////////////////////////////////////////////////
  433. //
  434. // C_DetectInterlace_I420
  435. //
  436. // Top level function to detect the presense of 
  437. // interlaced video content
  438. //
  439. // Parameters:
  440. // frame: Pointer to the frame to deinterlace
  441. // prev_frame: Pointer to the previous frame.
  442. // pels,
  443. // lines,
  444. // pitch: Frame dimensions
  445. //
  446. ////////////////////////////////////////////////////////
  448. // Threshold: If 8x8 SAD is above MOVEMENT_THRESH then
  449. // we'll decide that the block is in motion
  450. #define MOVEMENT_THRESH (400)
  452. // This is the factor by which 8x8 are skipped (not checked).
  453. // SKIP_FACTOR = 1 means no skipping.
  454. #define SKIP_FACTOR 4
  456. #ifdef DEBUG
  457. // This increments with each call, 
  458. // and is useful for debugging a specific frame.
  459. static unsigned int call_count = 0;
  460. #endif
  462. int
  463. C_DetectInterlace_I420(
  464. unsigned char *frame, 
  465. unsigned char *prev_frame, 
  466. int first_frame, 
  467. int pels, int lines, int pitch)
  468. {
  469. unsigned int image_size = (unsigned int)(pels * lines);
  470. // pre-calculated image size used for determining thresholds
  472. unsigned int interlaced_blocks = 0;
  473. // count of the number of 8x8 blocks that look to be interlaced
  475. unsigned int progressive_blocks = 0;
  476. // count of the number of 8x8 blocks that look to be progressive
  478. unsigned int step1v_tot = 0;
  479. // running total of the 1-step squared vertical difference of pixels
  481. unsigned int step2v_tot = 0;
  482. // running total of the 2-step squared vertical difference of pixels
  484. unsigned int step1h_tot = 0;
  485. // running total of the 1-step squared horizontal difference of pixels
  487. unsigned int step2h_tot = 0;
  488. // running total of the 2-step squared horizontal difference of pixels
  490. unsigned char *fp, *pp;
  491. unsigned char *f0, *f1, *f2, *f3;
  492. // various temporary frame pointers
  494. int i, j, k; // loop counter
  495. int tmp; // intermediate values for correlation and SAD macro
  496. int d0, d1; // SAD counters
  498. #ifdef DEBUG
  499. call_count++;
  500. #endif
  502. // We have no detection scheme for the first frame yet.
  503. if (first_frame)
  504. {
  505. return INTL_NO_DETECTION;
  506. }
  508. // Loop through tiled 8x8 blocks of the image
  509. for (i = 8; i < lines - 8; i += 8)
  510. {
  511. // Start pointer at new line
  512. fp = frame + i * pitch + (i & (8*(SKIP_FACTOR - 1))) + 8;
  513. pp = prev_frame + i * pitch + (i &  (8*(SKIP_FACTOR - 1))) + 8;
  515. for (j = 8; j < pels - 8; j += 8 * SKIP_FACTOR)
  516. {
  517. f0 = fp;
  518. f1 = f0 + pitch;
  519. f2 = pp;
  520. f3 = f2 + pitch;
  522. d0 = d1 = 0;
  524. // Calculate SAD for even and odd lines of 8x8 block.
  525. // We're doing a partial SAD here for speed.
  526. for (k = 0; k < 4; k++)
  527. {
  528. d0 += MABS(f0[0] - f2[0]);
  529. d0 += MABS(f0[2] - f2[2]);
  530. d0 += MABS(f0[4] - f2[4]);
  531. d0 += MABS(f0[6] - f2[6]);
  532. d1 += MABS(f1[1] - f3[1]);
  533. d1 += MABS(f1[3] - f3[3]);
  534. d1 += MABS(f1[5] - f3[5]);
  535. d1 += MABS(f1[7] - f3[7]);
  537. f0 += 2 * pitch;
  538. f1 += 2 * pitch;
  539. f2 += 2 * pitch;
  540. f3 += 2 * pitch;
  541. }
  542. d0 <<= 1;
  543. d1 <<= 1;
  545. // If there is enough difference to determine movement,
  546. // check this region for indications of interlaced artifacts
  547. if (d0 > MOVEMENT_THRESH || d1 > MOVEMENT_THRESH)
  548. {
  549. int step1v_corr = 0;
  550. int step2v_corr = 0;
  551. int step1h_corr = 0;
  552. int step2h_corr = 0;
  554. f0 = fp;
  555. f1 = f0 + pitch;
  556. f2 = f1 + pitch;
  558. // Determine 1 and 2 step pixel differences for 8x8 region
  559. for (k = 0; k < 4; k++)
  560. {
  561. tmp = f0[1] - f1[1];
  562. step1v_corr += MSQUARED(tmp);
  563. tmp = f0[1] - f2[1];
  564. step2v_corr += MSQUARED(tmp);
  565. tmp = f1[0] - f1[1];
  566. step1h_corr += MSQUARED(tmp);
  567. tmp = f1[0] - f1[2];
  568. step2h_corr += MSQUARED(tmp);
  570. tmp = f0[3] - f1[3];
  571. step1v_corr += MSQUARED(tmp);
  572. tmp = f0[3] - f2[3];
  573. step2v_corr += MSQUARED(tmp);
  574. tmp = f1[2] - f1[3];
  575. step1h_corr += MSQUARED(tmp);
  576. tmp = f1[2] - f1[4];
  577. step2h_corr += MSQUARED(tmp);
  579. tmp = f0[5] - f1[5];
  580. step1v_corr += MSQUARED(tmp);
  581. tmp = f0[5] - f2[5];
  582. step2v_corr += MSQUARED(tmp);
  583. tmp = f1[4] - f1[5];
  584. step1h_corr += MSQUARED(tmp);
  585. tmp = f1[4] - f1[6];
  586. step2h_corr += MSQUARED(tmp);
  588. tmp = f0[7] - f1[7];
  589. step1v_corr += MSQUARED(tmp);
  590. tmp = f0[7] - f2[7];
  591. step2v_corr += MSQUARED(tmp);
  592. tmp = f1[6] - f1[7];
  593. step1h_corr += MSQUARED(tmp);
  594. tmp = f1[6] - f1[8];
  595. step2h_corr += MSQUARED(tmp);
  597. f0 += 2 * pitch;
  598. f1 += 2 * pitch;
  599. f2 += 2 * pitch;
  600. }
  602. // These conditions indicate the block 
  603. // is very likely interlaced.
  604. if (step1v_corr > step2v_corr && 
  605. step1h_corr < (40*40*4*4) &&
  606. step2v_corr < (40*40*4*4))
  607. {
  608. interlaced_blocks++;
  609. }
  611. // These conditions indicate the block 
  612. // is very likely progressive.
  613. if (step1v_corr < 2 * step2v_corr && 
  614. step1h_corr < (40*40*4*4) &&
  615. step1v_corr < (40*40*4*4))
  616. {
  617. progressive_blocks++;
  618. }
  620. // Maintain totals
  621. step1v_tot += step1v_corr;
  622. step2v_tot += step2v_corr;
  623. step1h_tot += step1h_corr;
  624. step2h_tot += step2h_corr;
  625. }
  627. // Jump to the next 8x8 block
  628. fp += 8 * SKIP_FACTOR;
  629. pp += 8 * SKIP_FACTOR;
  630. }
  631. }
  633. #if (SKIP_FACTOR != 1)
  634. // If we're skipping some 8x8 block, 
  635. // acount for this by multiplying by skip factor
  637. interlaced_blocks *= SKIP_FACTOR;
  638. progressive_blocks *= SKIP_FACTOR;
  640. step1v_tot *= SKIP_FACTOR;
  641. step2v_tot *= SKIP_FACTOR;
  642. step1h_tot *= SKIP_FACTOR;
  643. step2h_tot *= SKIP_FACTOR;
  645. #endif
  647. // Scale these values. 
  648. // (Done to prevent overflow during later multiplies)
  649. step1v_tot /= image_size;
  650. step2v_tot /= image_size;
  651. step1h_tot /= image_size;
  652. step2h_tot /= image_size;
  654. // Interlaced Tests
  655. if (interlaced_blocks > progressive_blocks &&
  656. interlaced_blocks > (image_size >> 12))
  657. {
  658. return INTL_WEAK_INTERLACE;
  659. }
  661. if (step1v_tot * step2h_tot > step1h_tot * step2v_tot &&
  662. step1v_tot > step2v_tot &&
  663. 2 * interlaced_blocks > progressive_blocks &&
  664. interlaced_blocks > (image_size >> 10))
  665. {
  666. return INTL_WEAK_INTERLACE;
  667. }
  669. // Progressive Tests
  670. if (progressive_blocks > (image_size >> 10) &&
  671. progressive_blocks > (interlaced_blocks << 4))
  672. {
  673. return INTL_WEAK_PROGRESSIVE;
  674. }
  676. return INTL_NO_DETECTION;
  678. }
  680. ////////////////////////////////////////////////////////
  681. //
  682. // Deinterlace_RGB24_Fast
  683. //
  684. // Fast deinterlacing of RGB24 data, using both fields
  685. //
  686. ////////////////////////////////////////////////////////
  688. static void
  689. Deinterlace_RGB24_Fast(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format)
  690. {
  691. int line, pel;
  692. unsigned char *fp1,*pfp1;
  693. unsigned char *fp2,*pfp2;
  694. unsigned char *fp3,*pfp3;
  696. unsigned char *fpr;
  697. unsigned char *fpb;
  699. // Only handle RGB for now...
  700. if (format != INTL_FORMAT_RGB24)
  701. return;
  703. for (line = 1; line < lines - 2; line += 2)
  704. {
  705. unsigned int a,b,c,d,e,f;
  706. int c_nw,c_ne,c_se,c_sw;
  707. int diff,tmp;
  708. int prev_mode = INTL_LINE_REMOVE_AVG;
  709. int mode = INTL_LINE_REMOVE_AVG;
  710. int next_mode = INTL_LINE_REMOVE_AVG;
  712. // current frame
  713. fpr = frame + line * pitch;
  714. fp2 = fpr + pels * lines;
  715. fp1 = fp2 - pitch;
  716. fp3 = fp2 + pitch;
  717. fpb = fp2 + pels * lines;
  719. // previous frame
  720. if (prev_frame != 0)
  721. {
  722. pfp2 = prev_frame + pels * lines + line * pitch;
  723. pfp1 = pfp2 - pitch;
  724. pfp3 = pfp2 + pitch;
  725. }
  726. else
  727. {
  728. pfp2 = fp2;
  729. pfp1 = fp1;
  730. pfp3 = fp3;
  731. }
  733. // initialize
  734. for (pel = 0; pel < pels - 4; pel += 4)
  735. {
  736. // Load *next* 4 pels
  737. a = ((unsigned int *)fp1)[1];
  738. b = ((unsigned int *)fp2)[1];
  739. c = ((unsigned int *)fp3)[1];
  741. // Get corners
  742. c_nw = (a >> 24);
  743. c_ne = (a & 0xff);
  744. c_sw = (c >> 24);
  745. c_se = (c & 0xff);
  747. // Edge detect
  748. tmp = c_nw + c_ne - c_sw - c_se;
  749. if ((tmp < 100) && (tmp > -100))
  750. {
  751. next_mode = INTL_LINE_REMOVE_AVG;
  752. goto proc;
  753. }
  755. tmp = c_ne + c_se - c_nw - c_sw;
  756. if (tmp > 100)
  757. {
  758. next_mode = INTL_LINE_REMOVE_AVG;
  759. goto proc;
  760. }
  761. if (tmp < -100)
  762. {
  763. next_mode = INTL_LINE_REMOVE_AVG;
  764. goto proc;
  765. }
  767. // Load previous pels
  768. d = ((unsigned int *)pfp1)[1];
  769. e = ((unsigned int *)pfp2)[1];
  770. f = ((unsigned int *)pfp3)[1];
  772. // Diff with previous pels
  773. tmp = c_nw;
  774. tmp -= (d >> 24);
  775. diff = tmp ^ (tmp >> 31);
  777. tmp = c_ne;
  778. tmp -= (d & 0xff);
  779. diff += tmp ^ (tmp >> 31);
  781. if (diff > 100)
  782. {
  783. next_mode = INTL_LINE_REMOVE_AVG;
  784. goto proc;
  785. }
  787. tmp = c_sw;
  788. tmp -= (f >> 24);
  789. diff += tmp ^ (tmp >> 31);
  791. tmp = c_se;
  792. tmp -= (f & 0xff);
  793. diff += tmp ^ (tmp >> 31);
  795. if (diff > 200)
  796. {
  797. next_mode = INTL_LINE_REMOVE_AVG;
  798. goto proc;
  799. }
  801. tmp = (b >> 24);
  802. tmp -= (e >> 24);
  803. diff += tmp ^ (tmp >> 31);
  804. tmp = (b & 0xff);
  805. tmp -= (e & 0xff);
  806. diff += tmp ^ (tmp >> 31);
  808. if (diff > 300)
  809. {
  810. next_mode = INTL_LINE_REMOVE_AVG;
  811. goto proc;
  812. }
  814. next_mode = INTL_LINE_REMOVE_MEDIAN;
  816. proc:
  817. if (mode == INTL_LINE_REMOVE_MEDIAN || prev_mode == INTL_LINE_REMOVE_MEDIAN || next_mode == INTL_LINE_REMOVE_MEDIAN)
  818. {
  819. // median
  820. fp2[0] = MEDIAN_3(fp1[0],fp2[0],fp3[0]);
  821. fp2[1] = MEDIAN_3(fp1[1],fp2[1],fp3[1]);
  822. fp2[2] = MEDIAN_3(fp1[2],fp2[2],fp3[2]);
  823. fp2[3] = MEDIAN_3(fp1[3],fp2[3],fp3[3]);
  825. fpr[0] = MEDIAN_3(fpr[-pitch],fpr[0],fpr[pitch]);
  826. fpr[1] = MEDIAN_3(fpr[-pitch+1],fpr[1],fpr[pitch+1]);
  827. fpr[2] = MEDIAN_3(fpr[-pitch+2],fpr[2],fpr[pitch+2]);
  828. fpr[3] = MEDIAN_3(fpr[-pitch+3],fpr[3],fpr[pitch+3]);
  830. fpb[0] = MEDIAN_3(fpb[-pitch],fpb[0],fpb[pitch]);
  831. fpb[1] = MEDIAN_3(fpb[-pitch+1],fpb[1],fpb[pitch+1]);
  832. fpb[2] = MEDIAN_3(fpb[-pitch+2],fpb[2],fpb[pitch+2]);
  833. fpb[3] = MEDIAN_3(fpb[-pitch+3],fpb[3],fpb[pitch+3]);
  835. #ifdef TIME_DEINTERLACE
  836. num_med++;
  837. #endif
  839. }
  840. else
  841. {
  842. // average
  843. a = ((unsigned int *)fp1)[0];
  844. c = ((unsigned int *)fp3)[0];
  845. ((unsigned int*)fp2)[0] = (((a^c)>>1) & 0x7F7F7F7F) + (a&c);
  847. a = ((unsigned int *)(fpr - pitch))[0];
  848. c = ((unsigned int *)(fpr + pitch))[0];
  849. ((unsigned int*)fpr)[0] = (((a^c)>>1) & 0x7F7F7F7F) + (a&c);
  851. a = ((unsigned int *)(fpb - pitch))[0];
  852. c = ((unsigned int *)(fpb + pitch))[0];
  853. ((unsigned int*)fpb)[0] = (((a^c)>>1) & 0x7F7F7F7F) + (a&c);
  855. #ifdef TIME_DEINTERLACE
  856. num_avg++;
  857. #endif
  858. }
  860. prev_mode = mode;
  861. mode = next_mode;
  863. fp1 += 4;
  864. fp2 += 4;
  865. fp3 += 4;
  867. pfp1 += 4;
  868. pfp2 += 4;
  869. pfp3 += 4;
  871. fpr += 4;
  872. fpb += 4;
  873. }
  875. // last 4 pels
  876. if (mode == INTL_LINE_REMOVE_MEDIAN || prev_mode == INTL_LINE_REMOVE_MEDIAN)
  877. {
  878. // median
  879. fp2[0] = MEDIAN_3(fp1[0],fp2[0],fp3[0]);
  880. fp2[1] = MEDIAN_3(fp1[1],fp2[1],fp3[1]);
  881. fp2[2] = MEDIAN_3(fp1[2],fp2[2],fp3[2]);
  882. fp2[3] = MEDIAN_3(fp1[3],fp2[3],fp3[3]);
  884. fpr[0] = MEDIAN_3(fpr[-pitch],fpr[0],fpr[pitch]);
  885. fpr[1] = MEDIAN_3(fpr[-pitch+1],fpr[1],fpr[pitch+1]);
  886. fpr[2] = MEDIAN_3(fpr[-pitch+2],fpr[2],fpr[pitch+2]);
  887. fpr[3] = MEDIAN_3(fpr[-pitch+3],fpr[3],fpr[pitch+3]);
  889. fpb[0] = MEDIAN_3(fpb[-pitch],fpb[0],fpb[pitch]);
  890. fpb[1] = MEDIAN_3(fpb[-pitch+1],fpb[1],fpb[pitch+1]);
  891. fpb[2] = MEDIAN_3(fpb[-pitch+2],fpb[2],fpb[pitch+2]);
  892. fpb[3] = MEDIAN_3(fpb[-pitch+3],fpb[3],fpb[pitch+3]);
  894. #ifdef TIME_DEINTERLACE
  895. num_med++;
  896. #endif
  898. }
  899. else
  900. {
  901. // average
  902. a = ((unsigned int *)fp1)[0];
  903. c = ((unsigned int *)fp3)[0];
  904. ((unsigned int*)fp2)[0] = (((a^c)>>1) & 0x7F7F7F7F) + (a&c);
  906. a = ((unsigned int *)(fpr - pitch))[0];
  907. c = ((unsigned int *)(fpr + pitch))[0];
  908. ((unsigned int*)fpr)[0] = (((a^c)>>1) & 0x7F7F7F7F) + (a&c);
  910. a = ((unsigned int *)(fpb - pitch))[0];
  911. c = ((unsigned int *)(fpb + pitch))[0];
  912. ((unsigned int*)fpb)[0] = (((a^c)>>1) & 0x7F7F7F7F) + (a&c);
  914. #ifdef TIME_DEINTERLACE
  915. num_avg++;
  916. #endif
  917. }
  918. }
  920. }
  923. ////////////////////////////////////////////////////////
  924. //
  925. // Deinterlace_RGB24
  926. //
  927. // Slow deinterlacing of RGB24 data, using both fields
  928. //
  929. ////////////////////////////////////////////////////////
  931. static void
  932. Deinterlace_RGB24(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format)
  933. {
  934. int line, pel;
  935. unsigned char *fp1,*pfp1;
  936. unsigned char *fp2,*pfp2;
  937. unsigned char *fp3,*pfp3;
  938. int tmp;
  940. // Only handle RGB for now...
  941. if (format != INTL_FORMAT_RGB24)
  942. return;
  944. for (line = 1; line < lines - 2; line += 2)
  945. {
  946. int a,b,c,d,e;
  947. int mode = INTL_LINE_REMOVE_AVG;
  949. fp1 = frame + line * pitch;
  950. fp2 = frame + pels*lines + line * pitch;
  951. fp3 = frame + 2 * pels*lines + line * pitch;
  953. if (prev_frame != 0)
  954. {
  955. pfp1 = prev_frame + line * pitch;
  956. pfp2 = prev_frame + pels*lines + line * pitch;
  957. pfp3 = prev_frame + 2 * pels*lines + line * pitch;
  958. }
  959. else
  960. {
  961. pfp1 = fp1;
  962. pfp2 = fp2;
  963. pfp3 = fp3;
  964. }
  966. // initialize
  967. tmp = (int)(fp1[-pitch]) + (int)(fp2[-pitch]) + (int)(fp3[-pitch]) - (int)(pfp1[-pitch]) - (int)(pfp2[-pitch]) - (int)(pfp3[-pitch]);
  968. a = DIFF_FCN(tmp);
  969. tmp = (int)(fp1[0]) + (int)(fp2[0]) + (int)(fp3[0]) - (int)(pfp1[0]) - (int)(pfp2[0]) - (int)(pfp3[0]);
  970. a += DIFF_FCN(tmp);
  971. tmp = (int)(fp1[pitch]) + (int)(fp2[pitch]) + (int)(fp3[pitch]) - (int)(pfp1[pitch]) - (int)(pfp2[pitch]) - (int)(pfp3[pitch]);
  972. a += DIFF_FCN(tmp);
  974. fp1++;pfp1++;
  975. fp2++;pfp2++;
  976. fp3++;pfp3++;
  978. tmp = (int)(fp1[-pitch]) + (int)(fp2[-pitch]) + (int)(fp3[-pitch]) - (int)(pfp1[-pitch]) - (int)(pfp2[-pitch]) - (int)(pfp3[-pitch]);
  979. b = DIFF_FCN(tmp);
  980. tmp = (int)(fp1[0]) + (int)(fp2[0]) + (int)(fp3[0]) - (int)(pfp1[0]) - (int)(pfp2[0]) - (int)(pfp3[0]);
  981. b += DIFF_FCN(tmp);
  982. tmp = (int)(fp1[pitch]) + (int)(fp2[pitch]) + (int)(fp3[pitch]) - (int)(pfp1[pitch]) - (int)(pfp2[pitch]) - (int)(pfp3[pitch]);
  983. b += DIFF_FCN(tmp);
  985. fp1++;pfp1++;
  986. fp2++;pfp2++;
  987. fp3++;pfp3++;
  989. tmp = (int)(fp1[-pitch]) + (int)(fp2[-pitch]) + (int)(fp3[-pitch]) - (int)(pfp1[-pitch]) - (int)(pfp2[-pitch]) - (int)(pfp3[-pitch]);
  990. c = DIFF_FCN(tmp);
  991. tmp = (int)(fp1[0]) + (int)(fp2[0]) + (int)(fp3[0]) - (int)(pfp1[0]) - (int)(pfp2[0]) - (int)(pfp3[0]);
  992. c += DIFF_FCN(tmp);
  993. tmp = (int)(fp1[pitch]) + (int)(fp2[pitch]) + (int)(fp3[pitch]) - (int)(pfp1[pitch]) - (int)(pfp2[pitch]) - (int)(pfp3[pitch]);
  994. c += DIFF_FCN(tmp);
  996. tmp = (int)(fp1[-pitch+1]) + (int)(fp2[-pitch+1]) + (int)(fp3[-pitch+1]) - (int)(pfp1[-pitch+1]) - (int)(pfp2[-pitch+1]) - (int)(pfp3[-pitch+1]);
  997. d = DIFF_FCN(tmp);
  998. tmp = (int)(fp1[1]) + (int)(fp2[1]) + (int)(fp3[1]) - (int)(pfp1[1]) - (int)(pfp2[1]) - (int)(pfp3[1]);
  999. d += DIFF_FCN(tmp);
  1000. tmp = (int)(fp1[pitch+1]) + (int)(fp2[pitch+1]) + (int)(fp3[pitch+1]) - (int)(pfp1[pitch+1]) - (int)(pfp2[pitch+1]) - (int)(pfp3[pitch+1]);
  1001. d += DIFF_FCN(tmp);
  1003. for (pel = 2; pel < pels - 2; pel++)
  1004. {
  1005. tmp = (int)(fp1[-pitch+2]) + (int)(fp2[-pitch+2]) + (int)(fp3[-pitch+2]) - (int)(pfp1[-pitch+2]) - (int)(pfp2[-pitch+2]) - (int)(pfp3[-pitch+2]);
  1006. e = DIFF_FCN(tmp);
  1007. tmp = (int)(fp1[2]) + (int)(fp2[2]) + (int)(fp3[2]) - (int)(pfp1[2]) - (int)(pfp2[2]) - (int)(pfp3[2]);
  1008. e += DIFF_FCN(tmp);
  1009. tmp = (int)(fp1[pitch+2]) + (int)(fp2[pitch+2]) + (int)(fp3[pitch+2]) - (int)(pfp1[pitch+2]) - (int)(pfp2[pitch+2]) - (int)(pfp3[pitch+2]);
  1010. e += DIFF_FCN(tmp);
  1012. if (mode == INTL_LINE_REMOVE_MEDIAN)
  1013. {
  1014. if (a + b + c + d + e > INTL_DIFF_THRESH)
  1015. {
  1016. a =  MABS(fp2[-pitch-2] - fp2[-pitch+1]);
  1017. a += MABS(fp2[pitch-2] - fp2[pitch+1]);
  1018. a += MABS(fp2[-pitch-1] - fp2[-pitch+2]);
  1019. a += MABS(fp2[pitch-1] - fp2[pitch+2]);
  1020. a <<= 1;
  1021. a -= MABS(fp2[-pitch-2] - fp2[pitch-2]);
  1022. a -= MABS(fp2[-pitch-1] - fp2[pitch-1]);
  1023. a -= MABS(fp2[-pitch+1] - fp2[pitch+1]);
  1024. a -= MABS(fp2[-pitch+2] - fp2[pitch+2]);
  1026. if (a > 0)
  1027. {
  1028. mode = INTL_LINE_REMOVE_AVG;
  1029. }
  1030. }
  1031. }
  1032. else
  1033. {
  1034. if (a + b + c + d + e < INTL_DIFF_THRESH)
  1035. {
  1036. a =  MABS(fp2[-pitch-2] - fp2[-pitch+1]);
  1037. a += MABS(fp2[pitch-2] - fp2[pitch+1]);
  1038. a += MABS(fp2[-pitch-1] - fp2[-pitch+2]);
  1039. a += MABS(fp2[pitch-1] - fp2[pitch+2]);
  1040. a <<= 1;
  1041. a -= MABS(fp2[-pitch-2] - fp2[pitch-2]);
  1042. a -= MABS(fp2[-pitch-1] - fp2[pitch-1]);
  1043. a -= MABS(fp2[-pitch+1] - fp2[pitch+1]);
  1044. a -= MABS(fp2[-pitch+2] - fp2[pitch+2]);
  1046. if (a < 0)
  1047. {
  1048. mode = INTL_LINE_REMOVE_MEDIAN;
  1049. }
  1050. }
  1051. }
  1053. if (mode == INTL_LINE_REMOVE_MEDIAN)
  1054. {
  1055. // median
  1056. fp1[0] = MEDIAN_3(fp1[-pitch],fp1[0],fp1[pitch]);
  1057. fp2[0] = MEDIAN_3(fp2[-pitch],fp2[0],fp2[pitch]);
  1058. fp3[0] = MEDIAN_3(fp3[-pitch],fp3[0],fp3[pitch]);
  1059. }
  1060. else
  1061. {
  1062. // average
  1063. tmp = fp1[-pitch];
  1064. tmp += fp1[pitch];
  1065. fp1[0] = (tmp >> 1);
  1066. tmp = fp2[-pitch];
  1067. tmp += fp2[pitch];
  1068. fp2[0] = (tmp >> 1);
  1069. tmp = fp3[-pitch];
  1070. tmp += fp3[pitch];
  1071. fp3[0] = (tmp >> 1);
  1072. }
  1074. a = b;
  1075. b = c;
  1076. c = d;
  1077. d = e;
  1079. fp1++;pfp1++;
  1080. fp2++;pfp2++;
  1081. fp3++;pfp3++;
  1083. }
  1084. }
  1085. }
  1088. ////////////////////////////////////////////////////////
  1089. //
  1090. // Deinterlace_I420_Fast
  1091. //
  1092. // Fast deinterlacing of I420 data, using both fields
  1093. //
  1094. ////////////////////////////////////////////////////////
  1096. static void
  1097. Deinterlace_I420_Fast(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format)
  1098. {
  1099. int line, pel;
  1100. unsigned char *fp1,*pfp1;
  1101. unsigned char *fp2,*pfp2;
  1102. unsigned char *fp3,*pfp3;
  1104. // Only handle RGB for now...
  1105. if (format != INTL_FORMAT_I420)
  1106. return;
  1108. for (line = 1; line < lines - 2; line += 2)
  1109. {
  1110. unsigned int a,b,c,d,e,f;
  1111. int c_nw,c_ne,c_se,c_sw;
  1112. int diff,tmp;
  1113. int prev_mode = INTL_LINE_REMOVE_AVG;
  1114. int mode = INTL_LINE_REMOVE_AVG;
  1115. int next_mode = INTL_LINE_REMOVE_AVG;
  1117. // current frame
  1118. fp2 = frame + line * pitch;
  1119. fp1 = fp2 - pitch;
  1120. fp3 = fp2 + pitch;
  1122. // previous frame
  1123. if (prev_frame != 0)
  1124. {
  1125. pfp2 = prev_frame + line * pitch;
  1126. pfp1 = pfp2 - pitch;
  1127. pfp3 = pfp2 + pitch;
  1128. }
  1129. else
  1130. {
  1131. pfp2 = fp2;
  1132. pfp1 = fp1;
  1133. pfp3 = fp3;
  1134. }
  1136. // initialize
  1137. for (pel = 0; pel < pels - 4; pel += 4)
  1138. {
  1139. // Load *next* 4 pels
  1140. a = ((unsigned int *)fp1)[1];
  1141. b = ((unsigned int *)fp2)[1];
  1142. c = ((unsigned int *)fp3)[1];
  1144. // Get corners
  1145. c_nw = (a >> 24);
  1146. c_ne = (a & 0xff);
  1147. c_sw = (c >> 24);
  1148. c_se = (c & 0xff);
  1150. // Edge detect
  1151. tmp = c_nw + c_ne - c_sw - c_se;
  1152. if ((tmp < 100) && (tmp > -100))
  1153. {
  1154. next_mode = INTL_LINE_REMOVE_AVG;
  1155. goto proc;
  1156. }
  1158. tmp = c_ne + c_se - c_nw - c_sw;
  1159. if (tmp > 100)
  1160. {
  1161. next_mode = INTL_LINE_REMOVE_AVG;
  1162. goto proc;
  1163. }
  1164. if (tmp < -100)
  1165. {
  1166. next_mode = INTL_LINE_REMOVE_AVG;
  1167. goto proc;
  1168. }
  1170. // Load previous pels
  1171. d = ((unsigned int *)pfp1)[1];
  1172. e = ((unsigned int *)pfp2)[1];
  1173. f = ((unsigned int *)pfp3)[1];
  1175. // Diff with previous pels
  1176. tmp = c_nw;
  1177. tmp -= (d >> 24);
  1178. diff = tmp ^ (tmp >> 31);
  1180. tmp = c_ne;
  1181. tmp -= (d & 0xff);
  1182. diff += tmp ^ (tmp >> 31);
  1184. if (diff > 100)
  1185. {
  1186. next_mode = INTL_LINE_REMOVE_AVG;
  1187. goto proc;
  1188. }
  1190. tmp = c_sw;
  1191. tmp -= (f >> 24);
  1192. diff += tmp ^ (tmp >> 31);
  1194. tmp = c_se;
  1195. tmp -= (f & 0xff);
  1196. diff += tmp ^ (tmp >> 31);
  1198. if (diff > 200)
  1199. {
  1200. next_mode = INTL_LINE_REMOVE_AVG;
  1201. goto proc;
  1202. }
  1204. tmp = (b >> 24);
  1205. tmp -= (e >> 24);
  1206. diff += tmp ^ (tmp >> 31);
  1207. tmp = (b & 0xff);
  1208. tmp -= (e & 0xff);
  1209. diff += tmp ^ (tmp >> 31);
  1211. if (diff > 300)
  1212. {
  1213. next_mode = INTL_LINE_REMOVE_AVG;
  1214. goto proc;
  1215. }
  1217. next_mode = INTL_LINE_REMOVE_MEDIAN;
  1219. proc:
  1220. if (mode == INTL_LINE_REMOVE_MEDIAN || prev_mode == INTL_LINE_REMOVE_MEDIAN || next_mode == INTL_LINE_REMOVE_MEDIAN)
  1221. {
  1222. // median
  1223. fp2[0] = MEDIAN_3(fp1[0],fp2[0],fp3[0]);
  1224. fp2[1] = MEDIAN_3(fp1[1],fp2[1],fp3[1]);
  1225. fp2[2] = MEDIAN_3(fp1[2],fp2[2],fp3[2]);
  1226. fp2[3] = MEDIAN_3(fp1[3],fp2[3],fp3[3]);
  1228. #ifdef TIME_DEINTERLACE
  1229. num_med++;
  1230. #endif
  1232. }
  1233. else
  1234. {
  1235. // average
  1236. a = ((unsigned int *)fp1)[0];
  1237. c = ((unsigned int *)fp3)[0];
  1238. ((unsigned int*)fp2)[0] = (((a^c)>>1) & 0x7F7F7F7F) + (a&c);
  1240. #ifdef TIME_DEINTERLACE
  1241. num_avg++;
  1242. #endif
  1243. }
  1245. prev_mode = mode;
  1246. mode = next_mode;
  1248. fp1 += 4;
  1249. fp2 += 4;
  1250. fp3 += 4;
  1252. pfp1 += 4;
  1253. pfp2 += 4;
  1254. pfp3 += 4;
  1255. }
  1257. // last 4 pels
  1258. if (mode == INTL_LINE_REMOVE_MEDIAN || prev_mode == INTL_LINE_REMOVE_MEDIAN)
  1259. {
  1260. // median
  1261. fp2[0] = MEDIAN_3(fp1[0],fp2[0],fp3[0]);
  1262. fp2[1] = MEDIAN_3(fp1[1],fp2[1],fp3[1]);
  1263. fp2[2] = MEDIAN_3(fp1[2],fp2[2],fp3[2]);
  1264. fp2[3] = MEDIAN_3(fp1[3],fp2[3],fp3[3]);
  1266. #ifdef TIME_DEINTERLACE
  1267. num_med++;
  1268. #endif
  1270. }
  1271. else
  1272. {
  1273. // average
  1274. a = ((unsigned int *)fp1)[0];
  1275. c = ((unsigned int *)fp3)[0];
  1276. ((unsigned int*)fp2)[0] = (((a^c)>>1) & 0x7F7F7F7F) + (a&c);
  1278. #ifdef TIME_DEINTERLACE
  1279. num_avg++;
  1280. #endif
  1281. }
  1282. }
  1283. }
  1285. ////////////////////////////////////////////////////////
  1286. //
  1287. // Deinterlace_I420_Advanced
  1288. //
  1289. // Slow deinterlacing of I420 data, using Edge Interpolation
  1290. //
  1291. ////////////////////////////////////////////////////////
  1293. void
  1294. Deinterlace_I420_Advanced(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format)
  1295. {
  1296. int line, pel;
  1297. unsigned char *fpy, *pfpy;
  1298. unsigned char *fp1, *pfp1;
  1299. unsigned char *fp2, *pfp2;
  1300. unsigned char *fp3, *pfp3;
  1302. int edge1, edge2, pedge1, pedge2, diff1, diff2;
  1303. unsigned int a, c;
  1305. int tmp, pitch2;
  1306. pitch2= pitch<<1;
  1308. for (line = 1; line < lines - 2; line += 2)
  1309. {
  1311. fpy = frame + line*pitch;
  1313. // current frame
  1314. // current line
  1315. fp2 = fpy;
  1316. // prev line
  1317. fp1 = fp2 - pitch;
  1318. // next line
  1319. fp3 = fp2 + pitch;
  1320. // current frame
  1322. // previous frame
  1323. if (prev_frame != 0)
  1324. {
  1325. pfpy = prev_frame + line * pitch;
  1326. pfp2 = pfpy;
  1327. pfp1 = pfp2 - pitch;
  1328. pfp3 = pfp2 + pitch;
  1329. }
  1330. else
  1331. {
  1332. pfp2 = fp2;
  1333. pfp1 = fp1;
  1334. pfp3 = fp3;
  1335. }
  1337. // handle first pel
  1338. tmp = (*fp1 + *fp3) >> 1;
  1339. *fp2 = (unsigned char) tmp;
  1340. fp1++;
  1341. fp2++;
  1342. fp3++;
  1343. pfp1++;
  1345. edge1 = (*fp1) + *(fp1+1) +*(fp1+2);
  1346. edge2=  (*fp3) + *(fp3+1) +*(fp3+2);
  1348. for (pel = 1; pel < pels-4; pel += 1)
  1349. {
  1350. edge1+=*(fp1+3);
  1351. edge2+=*(fp3+3);
  1352. tmp = (edge1 - edge2);
  1354. if( tmp > 160 || tmp < -160) {
  1355. // horiz
  1356. pfp3 = pfp1 + pitch2;
  1357. pedge1= *pfp1 + *(pfp1+1) + *(pfp1+2) + *(pfp1+3);
  1358. pedge2= *pfp3 + *(pfp3+1) + *(pfp3+2) + *(pfp3+3);
  1360. diff1 = (edge1 - pedge1);
  1361. if (diff1 < 0) diff1=-(diff1);
  1362. //diff1 = ABS(diff1);
  1363. diff2 = (edge2  - pedge2);
  1364. if (diff2 < 0) diff2=-(diff2);
  1365. //diff2 = ABS(diff2);
  1367. if ((diff1 + diff2) < 200) {
  1368. // not moving
  1369. *fp2 = MEDIAN_3(*fp1,*fp2,*fp3);
  1370. *(fp2+1) = MEDIAN_3(*(fp1+1),*(fp2+1),*(fp3+1));
  1372. #ifdef TIME_DEINTERLACE
  1373. num_med++;
  1374. #endif
  1375. edge1 -= *fp1;
  1376. edge2 -= *fp3;
  1377. fp1++;
  1378. fp2++;
  1379. fp3++;
  1380. pfp1++;
  1381. pel++;
  1382. edge1+=*(fp1+3);
  1383. edge2+=*(fp3+3);
  1384. } else {
  1385. tmp = *(fp2-1) + *fp1 + *fp3;
  1386. tmp *= 21845;
  1387. *fp2 =  (unsigned char) (tmp >> 16);
  1388. //tmp = (*(fp2-1)<<1) + *fp1 + *fp3;
  1389. //*fp2 =  (unsigned char) (tmp >> 2);
  1390. #ifdef TIME_DEINTERLACE
  1391. num_avg++;
  1392. #endif
  1393. }
  1394. } else {
  1395. // not horiz
  1396. // average
  1397. tmp = (*fp1 + *fp3) >> 1;
  1398. *fp2 = (unsigned char) tmp;
  1400. #ifdef TIME_DEINTERLACE
  1401. num_avg++;
  1402. #endif
  1403. }
  1404. edge1 -= (*fp1);
  1405. edge2 -= (*fp3);
  1406. fp1++;
  1407. fp2++;
  1408. fp3++;
  1409. pfp1++;
  1410. }
  1411. // handle last four pels
  1412. // last 4 pels
  1413. pfp3 = pfp1 + pitch2;
  1414. pedge1= *pfp1 + *(pfp1+1) + *(pfp1+2) + *(pfp1+3);
  1415. pedge2= *pfp3 + *(pfp3+1) + *(pfp3+2) + *(pfp3+3);
  1417. diff1 = (edge1 - pedge1);
  1418. diff1 = ABS(diff1);
  1419. diff2 = (edge2  - pedge2);
  1420. diff2 = ABS(diff2);
  1421. if ((diff1 + diff2) < 200) {
  1422. // not moving
  1423. // median
  1424. fp2[0] = MEDIAN_3(fp1[0],fp2[0],fp3[0]);
  1425. fp2[1] = MEDIAN_3(fp1[1],fp2[1],fp3[1]);
  1426. fp2[2] = MEDIAN_3(fp1[2],fp2[2],fp3[2]);
  1427. fp2[3] = MEDIAN_3(fp1[3],fp2[3],fp3[3]);
  1429. #ifdef TIME_DEINTERLACE
  1430. num_med++;
  1431. #endif
  1432. }
  1433. else
  1434. {
  1435. // average
  1436. a = ((unsigned int *)fp1)[0];
  1437. c = ((unsigned int *)fp3)[0];
  1438. ((unsigned int*)fp2)[0] = (((a^c)>>1) & 0x7F7F7F7F) + (a&c);
  1440. #ifdef TIME_DEINTERLACE
  1441. num_avg++;
  1442. #endif
  1443. }
  1444. }
  1446. }
  1449. ////////////////////////////////////////////////////////
  1450. //
  1451. // Deinterlace_I420
  1452. //
  1453. // Slow deinterlacing of I420 data, using both fields
  1454. //
  1455. ////////////////////////////////////////////////////////
  1457. static void
  1458. Deinterlace_I420(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format)
  1459. {
  1460. int line, pel;
  1461. unsigned char *fp1,*pfp1; // line above
  1462. unsigned char *fp2,*pfp2; // current line
  1463. unsigned char *fp3,*pfp3; // line below
  1464. int tmp;
  1466. // Only handle RGB for now...
  1467. if (format != INTL_FORMAT_I420)
  1468. return;
  1470. for (line = 1; line < lines - 2; line += 2)
  1471. {
  1472. int a,b,c,d,e;
  1473. int mode = INTL_LINE_REMOVE_AVG;
  1475. // set pointers
  1476. fp1 = frame + (line - 1) * pitch;
  1477. fp2 = fp1 + pitch;
  1478. fp3 = fp2 + pitch;
  1480. if (prev_frame != 0)
  1481. {
  1482. pfp2 = prev_frame + line * pitch;
  1483. pfp1 = pfp1 - pitch;
  1484. pfp3 = pfp2 + pitch;
  1485. }
  1486. else
  1487. {
  1488. pfp2 = fp2;
  1489. pfp1 = fp1;
  1490. pfp3 = fp3;
  1491. }
  1493. // initialize
  1494. // a
  1495. tmp = (int)(*fp1++);
  1496. tmp -= (int)(*pfp1++);
  1497. a = DIFF_FCN(tmp);
  1498. tmp = (int)(*fp2++);
  1499. tmp -= (int)(*pfp2++);
  1500. a += DIFF_FCN(tmp);
  1501. tmp = (int)(*fp3++);
  1502. tmp -= (int)(*pfp3++);
  1503. a += DIFF_FCN(tmp);
  1505. // b
  1506. tmp = (int)(*fp1++);
  1507. tmp -= (int)(*pfp1++);
  1508. b = DIFF_FCN(tmp);
  1509. tmp = (int)(*fp2++);
  1510. tmp -= (int)(*pfp2++);
  1511. b += DIFF_FCN(tmp);
  1512. tmp = (int)(*fp3++);
  1513. tmp -= (int)(*pfp3++);
  1514. b += DIFF_FCN(tmp);
  1516. // c
  1517. tmp = (int)(*fp1);
  1518. tmp -= (int)(*pfp1);
  1519. c = DIFF_FCN(tmp);
  1520. tmp = (int)(*fp2);
  1521. tmp -= (int)(*pfp2);
  1522. c += DIFF_FCN(tmp);
  1523. tmp = (int)(*fp3);
  1524. tmp -= (int)(*pfp3);
  1525. c += DIFF_FCN(tmp);
  1527. // d
  1528. tmp = (int)(fp1[1]);
  1529. tmp -= (int)(pfp1[1]);
  1530. d = DIFF_FCN(tmp);
  1531. tmp = (int)(fp2[1]);
  1532. tmp -= (int)(pfp2[1]);
  1533. d += DIFF_FCN(tmp);
  1534. tmp = (int)(fp3[1]);
  1535. tmp -= (int)(pfp3[1]);
  1536. d += DIFF_FCN(tmp);
  1538. for (pel = 2; pel < pels - 2; pel++)
  1539. {
  1540. // e
  1541. tmp = (int)(fp1[2]);
  1542. tmp -= (int)(pfp1[2]);
  1543. e = DIFF_FCN(tmp);
  1544. tmp = (int)(fp2[2]);
  1545. tmp -= (int)(pfp2[2]);
  1546. e += DIFF_FCN(tmp);
  1547. tmp = (int)(fp3[2]);
  1548. tmp -= (int)(pfp3[2]);
  1549. e += DIFF_FCN(tmp);
  1551. // should we switch line removal mode?
  1552. if (mode == INTL_LINE_REMOVE_MEDIAN)
  1553. {
  1554. if (a + b + c + d + e > INTL_DIFF_THRESH)
  1555. {
  1556. a =  MABS(fp1[-2] - fp1[+1]);
  1557. a += MABS(fp3[-2] - fp3[+1]);
  1558. a += MABS(fp1[-1] - fp1[+2]);
  1559. a += MABS(fp3[-1] - fp3[+2]);
  1560. a <<= 1;
  1561. a += MABS(fp1[-2] - fp3[-2]);
  1562. a += MABS(fp1[-1] - fp3[-1]);
  1563. a += MABS(fp1[+1] - fp3[+1]);
  1564. a += MABS(fp1[+2] - fp3[+2]);
  1565. if (a > 0)
  1566. {
  1567. mode = INTL_LINE_REMOVE_AVG;
  1568. }
  1569. }
  1570. }
  1571. else
  1572. {
  1573. if (a + b + c + d + e < INTL_DIFF_THRESH)
  1574. {
  1575. a =  MABS(fp1[-2] - fp1[+1]);
  1576. a += MABS(fp3[-2] - fp3[+1]);
  1577. a += MABS(fp1[-1] - fp1[+2]);
  1578. a += MABS(fp3[-1] - fp3[+2]);
  1579. a <<= 1;
  1580. a += MABS(fp1[-2] - fp3[-2]);
  1581. a += MABS(fp1[-1] - fp3[-1]);
  1582. a += MABS(fp1[+1] - fp3[+1]);
  1583. a += MABS(fp1[+2] - fp3[+2]);
  1584. if (a < 0)
  1585. {
  1586. mode = INTL_LINE_REMOVE_MEDIAN;
  1587. }
  1588. }
  1589. }
  1591. if (mode == INTL_LINE_REMOVE_MEDIAN)
  1592. {
  1593. // median
  1594. fp2[0] = MEDIAN_3(fp1[0],fp2[0],fp3[0]);
  1595. }
  1596. else
  1597. {
  1598. // average
  1599. tmp = fp1[0];
  1600. tmp += fp3[0];
  1601. fp2[0] = (tmp >> 1);
  1602. }
  1604. // shift difference measures
  1605. a = b;
  1606. b = c;
  1607. c = d;
  1608. d = e;
  1610. // move pointers
  1611. fp1++;pfp1++;
  1612. fp2++;pfp2++;
  1613. fp3++;pfp3++;
  1615. }
  1616. }
  1617. }
  1621. ////////////////////////////////////////////////////////
  1622. //
  1623. // Deinterlace_RGB24_Field
  1624. //
  1625. // Replaces 'frame' with only one field.
  1626. //  The result is an image with dimesions pels x lines/2
  1627. //
  1628. ////////////////////////////////////////////////////////
  1630. static void
  1631. Deinterlace_RGB24_Field(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format, int field)
  1632. {
  1633. int line;
  1634. unsigned char *in,*out;
  1636. lines >>= 1;
  1638. // R
  1639. in  = frame + field * pitch;
  1640. out = frame;
  1641. for (line = field; line < lines; line++)
  1642. {
  1643. memcpy(out, in, pels); /* Flawfinder: ignore */
  1644. out += pitch;
  1645. in  += (pitch << 1);
  1646. }
  1648. // G
  1649. in  = frame + pels * (lines << 1);
  1650. out = frame + pels * lines;
  1651. for (line = 0; line < lines; line++)
  1652. {
  1653. memcpy(out, in, pels); /* Flawfinder: ignore */
  1654. out += pitch;
  1655. in  += (pitch << 1);
  1656. }
  1658. // B
  1659. in  = frame + pels * (lines << 1) * 2;
  1660. out = frame + pels * lines * 2;
  1661. for (line = 0; line < lines; line++)
  1662. {
  1663. memcpy(out, in, pels); /* Flawfinder: ignore */
  1664. out += pitch;
  1665. in  += (pitch << 1);
  1666. }
  1667. }
  1671. ////////////////////////////////////////////////////////
  1672. //
  1673. // Deinterlace_I420_Field
  1674. //
  1675. // Replaces 'frame' with only one field.
  1676. //  The result is an image with dimesions pels x lines/2
  1677. //
  1678. ////////////////////////////////////////////////////////
  1680. static void
  1681. Deinterlace_I420_Field(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format, int field)
  1682. {
  1683. register int line;
  1684. register unsigned char *in,*out;
  1685. int in_pitch;
  1686. int out_pitch;
  1687. int out_lines;
  1689. // Y
  1690. in_pitch = (pitch << 1);
  1691. out_pitch = pitch;
  1692. out_lines = (lines >> 1) & ~3;
  1694. in  = frame + field * pitch;
  1695. out = frame;
  1696. for (line = 0; line < out_lines; line++)
  1697. {
  1698. memcpy(out, in, pels); /* Flawfinder: ignore */
  1699. out += out_pitch;
  1700. in  += in_pitch;
  1701. }
  1703. pels >>= 1;
  1704. lines >>= 1;
  1705. in_pitch >>= 1;
  1706. out_pitch >>= 1;
  1707. out_lines >>= 1;
  1709. // U
  1710. in  = frame + ((pels * lines) << 2);
  1711. out = frame + ((pels * out_lines) << 2);
  1712. for (line = 0; line < out_lines; line++)
  1713. {
  1714. memcpy(out, in, pels); /* Flawfinder: ignore */
  1715. out += out_pitch;
  1716. in  += in_pitch;
  1717. }
  1719. // V
  1720. in  = frame + pels * lines * 5;
  1721. out = frame + pels * out_lines * 5;
  1722. for (line = 0; line < out_lines; line++)
  1723. {
  1724. memcpy(out, in, pels); /* Flawfinder: ignore */
  1725. out += out_pitch;
  1726. in  += in_pitch;
  1727. }
  1728. }
  1732. ////////////////////////////////////////////////////////
  1733. //
  1734. // Deinterlace_I420_FlipFlop
  1735. //
  1736. // The Odd field is put at the top of the frame,
  1737. //  the Even field is put up-side-down at the bottom.
  1738. //
  1739. ////////////////////////////////////////////////////////
  1741. static void
  1742. Deinterlace_I420_FlipFlop(unsigned char *frame, unsigned char *tempFrame, int pels, int lines, int pitch, int format)
  1743. {
  1744. int lineCounter;
  1746. //  reorder the frame, even field on top, Y, Cr then Cb
  1747. for(lineCounter=0;lineCounter<lines;lineCounter+=2)
  1748. {
  1749. memcpy(tempFrame+((lineCounter>>1)*(pels)), /* Flawfinder: ignore */
  1750. frame+lineCounter*pels,pels);
  1751. }
  1752. for(lineCounter=0;lineCounter<(lines>>1);lineCounter+=2)
  1753. {
  1754. memcpy(tempFrame+((lineCounter>>1)*(pels>>1)) + (pels*lines) /* Flawfinder: ignore */
  1755. ,frame+(pels*lines)+lineCounter*(pels>>1),(pels>>1));
  1756. }
  1757. for(lineCounter=0;lineCounter<(lines>>1);lineCounter+=2)
  1758. {
  1759. memcpy(tempFrame+((lineCounter>>1)*(pels>>1)) +(pels*lines*5/4) /* Flawfinder: ignore */
  1760. ,frame+(pels*lines*5/4)+lineCounter*(pels>>1),(pels>>1));
  1761. }
  1762. for(lineCounter=1;lineCounter<lines+1;lineCounter+=2)
  1763. {
  1764. memcpy(tempFrame+((lines-1)-(lineCounter>>1))*pels, /* Flawfinder: ignore */
  1765. frame+lineCounter*pels,pels);
  1766. }
  1767. for(lineCounter=1;lineCounter<(lines>>1)+1;lineCounter+=2)
  1768. {
  1769. memcpy(tempFrame + (pels*lines) + /* Flawfinder: ignore */
  1770. (((lines>>1)-1)-(lineCounter>>1))*(pels>>1),frame+(pels*lines)+lineCounter*(pels>>1),(pels>>1));
  1771. }
  1772. for(lineCounter=1;lineCounter<(lines>>1)+1;lineCounter+=2)
  1773. {
  1774. memcpy(tempFrame + (pels*lines*5/4) + /* Flawfinder: ignore */
  1775. (((lines>>1)-1)-(lineCounter>>1))*(pels>>1),frame+(pels*lines*5/4)+lineCounter*(pels>>1),(pels>>1));
  1776. }
  1777. memcpy(frame,tempFrame,(pels*lines*3)/2); /* Flawfinder: ignore */
  1779. return;
  1780. }
  1783. #ifdef _M_IX86
  1785. ////////////////////////////////////////////////////////
  1786. //
  1787. // Deinterlace_I420_MMX
  1788. //
  1789. // MMX optimized deinterlacing of I420 data, using both fields
  1790. //
  1791. ////////////////////////////////////////////////////////
  1793. static void
  1794. Deinterlace_I420_MMX(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format)
  1795. {
  1796. int line_shift;
  1797. int pels_div8;
  1799. pels_div8 = (pels >> 3); // round down
  1800. line_shift = ((pitch << 1) - (pels & ~7));
  1802. __asm {
  1804. mov ecx, lines // ecx -> lines
  1805. shr ecx, 1 // ecx -> lines/2
  1807. mov edx, pitch // pitch
  1808. mov eax, edx
  1809. neg eax // -pitch
  1811. mov esi, frame // esi -> current frame
  1812. add esi, pitch; // move esi to the next line
  1814. pxor mm7, mm7
  1816. ALIGN 16
  1817. line_loop:
  1818. mov ebx, pels_div8 // ebx -> pels/8 (rounded down)
  1819. ALIGN 16
  1820. pel_loop:
  1821. // median = (upper & A) | (mid & B) | (lower & C)
  1822. // e.g....
  1823. movq mm0,[esi+eax] // 1 2 1 3 2 3 1 3 = mm0 = (upper)
  1824. movq mm1,[esi] // 2 1 3 1 3 2 1 3 = mm1 = (mid)
  1825. movq mm2,[esi+edx] // 3 3 2 2 1 1 2 3 = mm2 = (lower)
  1827. movq mm3,mm1 // 2 1 3 1 3 2 1 3 = mm3
  1828. psubusb mm3,mm0 // 1 0 2 0 1 0 0 0 = mm3
  1829. pcmpeqb mm3,mm7 // 0 1 0 1 0 1 1 1 = mm3 = (upper > mid)
  1831. movq mm4,mm2 // 3 3 2 2 1 1 2 3 = mm4
  1832. psubusb mm4,mm1 // 1 2 0 1 0 0 1 0 = mm4
  1833. pcmpeqb mm4,mm7 // 0 0 1 0 1 1 0 1 = mm4 = (mid > lower)
  1835. movq mm6,mm3 // 0 1 0 1 0 1 1 1 = mm6
  1836. pxor mm6,mm4 // 0 1 1 1 1 0 1 0 = mm6 = ~(B)
  1837. pandn mm6,mm1 // 2 0 0 0 0 2 1 0 = mm6 = (mid & B)
  1839. movq mm5,mm2 // 3 3 2 2 1 1 2 3 = mm5
  1840. psubusb mm5,mm0 // 2 1 1 0 0 0 1 0 = mm5
  1841. pcmpeqb mm5,mm7 // 0 0 0 1 1 1 0 1 = mm5 = (upper > lower)
  1843. movq mm1,mm5 // 0 0 0 1 1 1 0 1 = mm1
  1844. pxor mm1,mm3 // 0 1 0 0 1 0 1 0 = mm1 = (A)
  1845. pand mm1,mm0 // 0 2 0 0 2 0 1 0 = mm1 = (upper & A)
  1847. por   mm6,mm1 // 2 2 0 0 2 2 1 0 = mm6 = (upper & A) | (mid & B)
  1849. pxor mm4,mm5 // 0 0 1 1 0 0 0 1 = mm4 = (C)
  1850. pand mm4,mm2 // 0 0 2 2 0 0 0 3 = mm4 = (lower & C)
  1852. por   mm6,mm4 // 2 2 2 2 2 2 1 3 = mm6 = (upper & A) | (mid & B) | (lower & C)
  1854. movq [esi],mm6
  1856. lea esi,[esi+8]
  1858. dec ebx
  1859. jnz pel_loop
  1861. // any pels left???
  1862. mov ebx, pels
  1863. and ebx, 0x07
  1864. jnz last_pels
  1866. add esi, line_shift; // move esi to the next line
  1868. dec ecx
  1869. jnz line_loop
  1870. jmp done
  1872. last_pels:
  1873. // take care of last four pels
  1874. movd mm0,[esi+eax]
  1875. movd mm1,[esi]
  1876. movd mm2,[esi+edx]
  1878. movq mm3,mm1 // 2 1 3 1 3 2 1 3 = mm3
  1879. psubusb mm3,mm0 // 1 0 2 0 1 0 0 0 = mm3
  1880. pcmpeqb mm3,mm7 // 0 1 0 1 0 1 1 1 = mm3 = (upper > mid)
  1882. movq mm4,mm2 // 3 3 2 2 1 1 2 3 = mm4
  1883. psubusb mm4,mm1 // 1 2 0 1 0 0 1 0 = mm4
  1884. pcmpeqb mm4,mm7 // 0 0 1 0 1 1 0 1 = mm4 = (mid > lower)
  1886. movq mm6,mm3 // 0 1 0 1 0 1 1 1 = mm6
  1887. pxor mm6,mm4 // 0 1 1 1 1 0 1 0 = mm6 = ~(B)
  1888. pandn mm6,mm1 // 2 0 0 0 0 2 1 0 = mm6 = (mid & B)
  1890. movq mm5,mm2 // 3 3 2 2 1 1 2 3 = mm5
  1891. psubusb mm5,mm0 // 2 1 1 0 0 0 1 0 = mm5
  1892. pcmpeqb mm5,mm7 // 0 0 0 1 1 1 0 1 = mm5 = (upper > lower)
  1894. movq mm1,mm5 // 0 0 0 1 1 1 0 1 = mm1
  1895. pxor mm1,mm3 // 0 1 0 0 1 0 1 0 = mm1 = (A)
  1896. pand mm1,mm0 // 0 2 0 0 2 0 1 0 = mm1 = (upper & A)
  1898. por   mm6,mm1 // 2 2 0 0 2 2 1 0 = mm6 = (upper & A) | (mid & B)
  1900. pxor mm4,mm5 // 0 0 1 1 0 0 0 1 = mm4 = (C)
  1901. pand mm4,mm2 // 0 0 2 2 0 0 0 3 = mm4 = (lower & C)
  1903. por   mm6,mm4 // 2 2 2 2 2 2 1 3 = mm6 = (upper & A) | (mid & B) | (lower & C)
  1905. movd [esi],mm6
  1907. add esi, line_shift; // move esi to the next line
  1909. dec ecx
  1910. jnz line_loop
  1912. done:
  1913. emms
  1914. }
  1915. }
  1918. ////////////////////////////////////////////////////////
  1919. //
  1920. // Deinterlace_I420_Slow
  1921. //
  1922. // Slow deinterlacing of I420 data, 
  1923. //  with Rigorous Edge Interpolation using 
  1924. //  Optical Flow
  1925. //
  1926. ////////////////////////////////////////////////////////
  1927. static void
  1928. Deinterlace_I420_EdgeInterp(unsigned char *frame, unsigned char *prev_frame, int pels, int lines, int pitch, int format)
  1929. {
  1930. int line, pel, mcountfr=1, mcountfi=1, D1=0;
  1931. unsigned char *fpr, *fpg, *pfpg, *pfpr;
  1932. unsigned char *fp1, *pfp1;
  1933. unsigned char *fp2, *pfp2;
  1934. unsigned char *fp3, *pfp3;
  1935. # define IFrMThresh 10
  1936. # define IFsMThresh 20
  1937. # define FlowThresh 1200
  1938. # define StrictFlowThresh 5
  1939. # define adj 10
  1940. int frm =1;
  1941. int diff1;
  1943. int tmp;
  1944. int *tempLine, *ptempLine;
  1945. tempLine = (int*)malloc(pels*sizeof(int));
  1947. for (line = 1; line < lines - 2; line += 2)
  1948. {
  1950. int a,b,c,d,e,f;
  1951. int D1 =0;
  1952. unsigned char *tfp3;
  1953. memset(tempLine, -1, pels*sizeof(int));
  1955. fpr = frame + line*pitch;
  1957. fpg = fpr;
  1960. fp2 = fpg + adj;
  1962. ptempLine = &tempLine[0] + adj;
  1965. // prev line
  1966. fp1 = fp2 - pitch;
  1968. // next line
  1969. fp3 = fp2 + pitch;
  1971. // previous frame
  1972. if (prev_frame != 0)
  1973. {
  1974. pfpr = prev_frame + line * pitch;
  1975. pfpg = pfpr;
  1976. pfp2 = pfpg + adj;
  1977. pfp1 = pfp2 - pitch;
  1978. pfp3 = pfp2 + pitch;
  1979. }
  1980. else
  1981. {
  1982. Deinterlace_RGB24_Fast(frame, prev_frame, pels, lines, pitch, format);
  1983. free(tempLine);
  1984. return;
  1985. }
  1988. // initialize
  1989. for (pel = adj; pel < (pels - adj); pel += 1)
  1990. {
  1992. int moving = 0;
  1993. int fi, fD;
  1994. int minf;
  1995. int pix;
  1996. int error2, error21, error22, error3, d2=0, j;
  1998. // Load *next* pels
  1999. a = (int)(*fp1);
  2000. b = (int)(*fp2);
  2001. c = (int)(*fp3);
  2003. // intra frame
  2004. D1 = *(fp1+1) - *(fp1-1);
  2005. D1 = ABS(D1);
  2006. if( D1 > 20) { 
  2007. d = *(fp1+1);
  2008. e = *(fp1-1);
  2009. tfp3 = fp3;
  2010. tmp = (a - *(tfp3));
  2011. minf = DIFF_FCN(tmp);
  2012. tmp = (d - *(tfp3+1));
  2013. minf += DIFF_FCN(tmp);
  2014. tmp = (e - *(tfp3-1));
  2015. minf += DIFF_FCN(tmp);
  2017. fi = 0;
  2018. tfp3--;
  2019. for (j=-1; j>=-adj; j--) {
  2020. tmp = (a - *(tfp3));
  2021. fD = DIFF_FCN(tmp);
  2022. if (fD > minf)
  2023. goto gskip;
  2024. tmp = (d - *(tfp3+1));
  2025. fD= fD + DIFF_FCN(tmp);
  2026. if (fD > minf)
  2027. goto gskip;
  2028. tmp = (e - *(tfp3-1));
  2029. fD= fD + DIFF_FCN(tmp);
  2030. if(fD<minf) {
  2031. minf = fD;
  2032. fi = j;
  2033. }
  2034. gskip:
  2035. tfp3--;
  2036. }
  2038. tfp3 = fp3 + 1;
  2039. for (j=1; j<=adj; j++) {
  2040. tmp = (a - *(tfp3));
  2041. fD = DIFF_FCN(tmp);
  2042. if (fD > minf)
  2043. goto gskip2;
  2044. tmp = (d - *(tfp3+1));
  2045. fD += DIFF_FCN(tmp);
  2046. if (fD > minf)
  2047. goto gskip2;
  2048. tmp = (e - *(tfp3-1));
  2049. fD += DIFF_FCN(tmp);
  2050. if(fD<minf) {
  2051. minf = fD;
  2052. fi = j;
  2053. }
  2054. gskip2:
  2055. tfp3++;
  2056. }
  2058. #ifdef TIME_DEINTERLACE
  2059. //num_flow++;
  2060. #endif
  2062. if (minf < FlowThresh)  {
  2064. if ((fi == 1) || (fi == -1) || (fi == 0)) {
  2065. tempLine[pel] = (*fp1 + *fp3)/2;
  2066. } else {
  2068. f = *(fp3+ fi);
  2069. pix = (a + f) / 2;
  2070. d2 = (int)(fi)/2;
  2072. f = *(fp1 + d2);
  2073. tmp = (pix - f);
  2074. error2 = ABS(tmp);
  2076. f = *(fp1 + d2 + 1);
  2077. pix = (d + *(fp3 + fi + 1))/2;
  2078. tmp = (pix - f);
  2079. error21 = ABS(tmp);
  2081. f = *(fp1 + d2 -1);
  2082. pix = (e + *(fp3 + fi - 1))/2;
  2083. tmp = (pix - f);
  2084. error22 = ABS(tmp);
  2087. if(error2 < 15 && ( ((error21 < 15) && (error22 > 25)) || ((error21 > 25) && (error22 < 15)) ) ) {
  2089. pix = (a + *(fp3+fi)) / 2;
  2090. tempLine[pel + d2] = pix;
  2092. pix = (d + *(fp3 + fi + 1))/2;
  2093. tempLine[pel + d2 + 1] = pix;
  2095. pix = (e + *(fp3 + fi - 1))/2;
  2096. tempLine[pel + d2 - 1] = pix;
  2098. goto gadvance;
  2099. }
  2101. pix = (a + *(fp3 + fi))/2;
  2102. f = *(fp3 + d2);
  2103. tmp = (pix - f);
  2104. error3 = ABS(tmp);
  2106. f = *(fp3 + d2 + 1);
  2107. pix = (d + *(fp3 + fi + 1))/2;
  2108. tmp = (pix - f);
  2109. error21 = ABS(tmp);
  2111. f = *(fp3 + d2 -1);
  2112. pix = (e + *(fp3 + fi - 1))/2;
  2113. tmp = (pix - f);
  2114. error22 = ABS(tmp);
  2116. pix = (a + *(fp3 + fi))/2;
  2118. if( error3 < 15 && ( ((error21 < 15) && (error22 > 25)) || ((error21 > 25) && (error22 < 15))) ) {
  2120. tempLine[pel + d2] = pix;
  2122. pix = (d + *(fp3 + fi + 1))/2;
  2123. tempLine[pel + d2 + 1] = pix;
  2125. pix = (e + *(fp3 + fi - 1))/2;
  2126. tempLine[pel + d2 - 1] = pix;
  2129. goto gadvance;
  2130. } else {
  2131. /*
  2132. *fp2 = 0;
  2133. *fpr2 = 0;
  2134. *fpb2 = 255;
  2135. tempLine[pel] = 0;
  2136. */
  2138. }
  2140. }
  2141. } else {
  2142. /*
  2143. *fp2 = 0;
  2144. *fpr2 = 255;
  2145. *fpb2 = 0;
  2146. tempLine[pel] = 0;
  2147. */
  2149. }
  2151. }
  2152. gadvance:
  2153. fp1++;
  2154. fp2++;
  2155. fp3++;
  2156. pfp1++;
  2157. pfp2++;
  2158. pfp3++;
  2159. ptempLine++;
  2160. }
  2162. // current frame
  2163. // current line
  2164. fp2 = fpg;
  2165. // prev line
  2166. fp1 = fp2 - pitch;
  2167. // next line
  2168. fp3 = fp2 + pitch;
  2169. // current frame
  2171. //prev frame
  2172. // current line
  2173. pfp2 = pfpg;
  2174. // prev line
  2175. pfp1 = pfp2 - pitch;
  2176. // next line
  2177. pfp3 = pfp2 + pitch;
  2179. ptempLine = &tempLine[0];
  2181. for (pel = 0; pel < pels-1; pel += 1)
  2182. {
  2183. // change
  2185. tmp = (*fp1 - *(fp3));
  2186. diff1 = DIFF_FCN(tmp);
  2187. tmp = (*(fp1-1) - *(fp3-1));
  2188. diff1 += DIFF_FCN(tmp);
  2189. tmp = (*(fp3+1) - *(pfp3+1));
  2190. diff1 += DIFF_FCN(tmp);
  2192. if( ABS(diff1) > 4800 ) {
  2193. // horiz
  2194. tmp = (*fp1 - *(pfp1));
  2195. diff1 = DIFF_FCN(tmp);
  2196. tmp = (*(fp1-1) - *(pfp1-1));
  2197. diff1 += DIFF_FCN(tmp);
  2198. tmp = (*(fp1+1) - *(pfp1+1));
  2199. diff1 += DIFF_FCN(tmp);
  2200. tmp = (*fp3 - *(pfp3));
  2201. diff1 += DIFF_FCN(tmp);
  2202. tmp = (*(fp3-1) - *(pfp3-1));
  2203. diff1 += DIFF_FCN(tmp);
  2204. tmp = (*(fp3+1) - *(pfp3+1));
  2205. diff1 += DIFF_FCN(tmp);
  2208. if (diff1 < 2400) {
  2209. // not moving
  2211. *fp2 = MEDIAN_3(*fp1,*fp2,*fp3);
  2213. } else {
  2215. if (*ptempLine != -1) {
  2216. *fp2 = (unsigned char) *ptempLine;
  2217. } else {
  2218. tmp = (*fp1 + *fp3)/2;
  2219. *fp2 =  (unsigned char) tmp;
  2220. }
  2222. #ifdef TIME_DEINTERLACE
  2223. num_avg++;
  2224. #endif
  2226. }
  2227. } else {
  2228. // not horiz
  2229. // avg
  2230. if (*ptempLine != -1) {
  2231. D1 = *(fp1+1) - *(fp1-1);
  2232. D1 = ABS(D1);
  2233. if( D1 > 20) { 
  2234. *fp2 = (unsigned char) *ptempLine;
  2235. } else {
  2236. tmp = (*fp1 + *fp3)/2;
  2237. *fp2 =  (unsigned char) tmp;
  2238. // not vertical
  2239. }
  2240. } else {
  2241. tmp = (*fp1 + *fp3)/2;
  2242. *fp2 =  (unsigned char) tmp;
  2243. }
  2245. #ifdef TIME_DEINTERLACE
  2246. num_avg++;
  2247. #endif
  2249. }
  2252. fp1++;
  2253. fp2++;
  2254. fp3++;
  2255. pfp1++;
  2256. pfp2++;
  2257. pfp3++;
  2258. ptempLine++;
  2259. }
  2260. }
  2262. free(tempLine);
  2264. return;
  2266. }
  2269. #endif