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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
deintl.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：57k
源码类别：

Symbian

开发平台：

Visual C++

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