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

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

Symbian

开发平台：

Visual C++

invtelec.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: invtelec.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 ***** */
  53. ////////////////////////////////////////////////////////
  54. // include files
  55. ////////////////////////////////////////////////////////
  57. #include "invtelec.h"
  58. #include "hxtick.h"
  59. #include "mmx_util.h"
  60. #include "hlxclib/stdlib.h"
  61. #include "hlxclib/string.h"
  62. #include "hlxclib/math.h"
  64. ////////////////////////////////////////////////////////
  65. // internal prototypes
  66. ////////////////////////////////////////////////////////
  68. static T_INVTELE_RESULT 
  69. InvTelecineDetect(
  70. UCHAR *data, UCHAR *prevData, 
  71. double frameRate, 
  72. ULONG32 timestamp, 
  73. ULONG32 pels, ULONG32 lines,
  74. BOOL bDeInterlaced,
  75. T_INVTELE_STATE *state);
  77. //#define CODEC_DEBUG_32PULLDOWN
  78. #ifdef CODEC_DEBUG_32PULLDOWN
  79. #include <stdio.h>
  80. static FILE *fp_log = NULL;
  81. #endif
  84. const T_INVTELE_FLOAT inThresh[PULLDOWN_HIST_LEN+1] = {3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4};
  85. const T_INVTELE_FLOAT outThresh[PULLDOWN_HIST_LEN+1] = {1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2};
  87. #ifdef ALLOW_MMX_INVTELE
  89. void
  90. SumSqaredFrameDiff_MMX(
  91. unsigned char *frame, 
  92. unsigned char *prev_frame,
  93. int pels,
  94. int lines,
  95. int pitch,
  96. float *ssd_odd,
  97. float *ssd_even);
  99. void
  100. RestitchCheck_MMX(
  101. unsigned char *frame, 
  102. unsigned char *prev_frame,
  103. int pels,
  104. int lines,
  105. int pitch,
  106. float *ssd_new,
  107. float *ssd_old);
  109. #endif
  111. ////////////////////////////////////////////////////////
  112. //
  113. // InitInvTelecine
  114. //
  115. // Allocates and initializes memory for state information
  116. //
  117. // Parameters:
  118. // state: Pointer to the allocated state pointer
  119. //
  120. ////////////////////////////////////////////////////////
  122. INT32
  123. InitInvTelecine(T_INVTELE_STATE **state)
  124. {
  125. T_INVTELE_STATE *new_state = 0;
  127. if (*state != 0)
  128. return 1;
  130. new_state = (T_INVTELE_STATE *)malloc(sizeof(T_INVTELE_STATE));
  132. if (new_state == 0)
  133. {
  134. return 1;
  135. }
  137. new_state->impl_id = INVTELE_IMPL_ID_C;
  138. new_state->firstFrame = TRUE;
  139. new_state->ulPulldownActiveTimerIntl = 0;
  140. new_state->ulPulldownActiveTimerProg = 0;
  141. new_state->lastRemovedTimestamp = 0;
  142. new_state->frameCountMod = 4;
  143. new_state->frameRemovalPattern = 4;
  144. new_state->NTSCTrackingFrameCounter = 500;
  145. new_state->interleaveEvenFlag = FALSE;
  146. new_state->interleaveOddFlag = FALSE;
  147. new_state->checkNextFrameForInterlace = FALSE;
  148. new_state->checkNextFrameForProgressive = FALSE;
  149. new_state->bProgressiveTelecineSeen = FALSE;
  150. new_state->bInterlacedTelecineSeen = FALSE;
  151. new_state->pulldownTimeBuffer = 0;
  153. for (int i = 0; i < PULLDOWN_HIST_LEN; i++)
  154. {
  155. new_state->pulldownSadHistEven[i] = UN_INIT_SAD;
  156. new_state->pulldownSadHistOdd[i] = UN_INIT_SAD;
  157. new_state->pulldownSadHistAll[i] = UN_INIT_SAD;
  158. new_state->pulldownTimeHist[i] = 0;
  159. }
  161. #ifdef ALLOW_MMX_INVTELE
  162. // Check for MMx availability
  163.     if (checkMmxAvailablity() & CPU_HAS_MMX)
  164. new_state->impl_id = INVTELE_IMPL_ID_MMX;
  165. #endif
  167. *state = new_state;
  169. return 0;
  170. }
  173. ////////////////////////////////////////////////////////
  174. //
  175. // FreeInvTelecine
  176. //
  177. // Frees memory for state information
  178. //
  179. // Parameters:
  180. // state: Pointer to the allocated state pointer
  181. //
  182. ////////////////////////////////////////////////////////
  184. void
  185. FreeInvTelecine(T_INVTELE_STATE **state)
  186. {
  187. if (*state != 0)
  188. free(*state);
  190. *state = 0;
  191. }
  194. ////////////////////////////////////////////////////////
  195. //
  196. // IsContentProgressiveTelecine
  197. //
  198. // Returns TRUE if the telecine detector has seen 
  199. //   interlaced telecine content
  200. //
  201. // Parameters:
  202. // state: State pointer
  203. //
  204. ////////////////////////////////////////////////////////
  206. BOOL
  207. IsContentProgressiveTelecine(T_INVTELE_STATE *state)
  208. {
  209. if (state != 0)
  210. return (state->bProgressiveTelecineSeen)?(TRUE):(FALSE);
  212. return FALSE;
  213. }
  216. ////////////////////////////////////////////////////////
  217. //
  218. // IsContentInterlacedTelecine
  219. //
  220. // Returns TRUE if the telecine detector has seen 
  221. //   progressive telecine content
  222. //
  223. // Parameters:
  224. // state: State pointer
  225. //
  226. ////////////////////////////////////////////////////////
  228. BOOL
  229. IsContentInterlacedTelecine(T_INVTELE_STATE *state)
  230. {
  231. if (state != 0)
  232. return (state->bInterlacedTelecineSeen)?(TRUE):(FALSE);
  234. return FALSE;
  235. }
  238. ////////////////////////////////////////////////////////
  239. //
  240. // GetTelecinePattern
  241. //
  242. // Returns the frame modulo for the removal pattern
  243. //
  244. // Parameters:
  245. // state: State pointer
  246. //
  247. ////////////////////////////////////////////////////////
  249. UCHAR
  250. GetTelecinePattern(T_INVTELE_STATE *state)
  251. {
  252. INT32 pattern;
  254. if (state != 0)
  255. pattern = (state->frameRemovalPattern - state->frameCountMod) % 5;
  256. else
  257. pattern = 0;
  259. if (pattern < 0)
  260. pattern +=5;
  262. return (UCHAR)pattern;
  263. }
  266. ////////////////////////////////////////////////////////
  267. //
  268. // SetTelecinePattern
  269. //
  270. // Sets the frame modulo for the removal pattern
  271. //
  272. // Parameters:
  273. // state: State pointer
  274. //
  275. ////////////////////////////////////////////////////////
  277. void
  278. SetTelecinePattern(T_INVTELE_STATE *state, UCHAR telecine_pattern)
  279. {
  280. if (state != 0)
  281. state->frameRemovalPattern = ((telecine_pattern + state->frameCountMod) % 5);
  282. }
  286. ////////////////////////////////////////////////////////
  287. //
  288. // DoInvTelecine
  289. //
  290. // Performs inverse Telecine
  291. //
  292. // Parameters:
  293. // data: Pointer to the current planar frame.
  294. // prevData: Pointer to the previous source frame.
  295. // frameRate: The input frame rate.
  296. // timestamp: The timestamp of the current frame.
  297. // This value will be adjusted to account
  298. // for the change to 24 fps
  299. // pels, lines: Frame dimensions.
  300. // bDeInterlaced: Should be set to TRUE if frame is known
  301. // to be progressive.
  302. // state: State pointer
  303. //
  304. ////////////////////////////////////////////////////////
  306. T_INVTELE_RESULT
  307. DoInvTelecine(
  308. UCHAR *data, 
  309. UCHAR *prevData, 
  310. double frameRate, 
  311. ULONG32 &timestamp, 
  312. ULONG32 pels, ULONG32 lines, 
  313. BOOL bDeInterlaced, 
  314. T_INVTELE_STATE *state)
  315. {
  316. T_INVTELE_RESULT ret;
  318. if (frameRate < 25.5)
  319. return (INVTELE_RESULT_LOW_FRAMERATE);
  321. #ifdef CODEC_DEBUG_32PULLDOWN
  322.   if(fp_log == NULL)
  323.   fp_log = fopen("c:\pulldown.log","w");
  324. #endif
  326. ret = InvTelecineDetect(data, prevData, frameRate, timestamp, pels, lines, bDeInterlaced, state);
  328. // hack -- don't drop more than 1 out of every 5 progressive frames
  329. if ((state->pulldownTimeBuffer > 1) && 
  330. (bDeInterlaced || lines < 242) &&
  331. (ret == INVTELE_RESULT_DROP_FRAME))
  332. {
  333. ret = INVTELE_RESULT_FRAME_OK;
  334. }
  336. if (ret == INVTELE_RESULT_DROP_FRAME)
  337. {
  338. state->pulldownTimeBuffer = 33;
  339. }
  340. else
  341. {
  342. // adjust timestamp 
  343. // -- allowed offsets will be -33, -25, -17, -9, -1, 0
  344. timestamp -= state->pulldownTimeBuffer;
  346. if (state->pulldownTimeBuffer > 8)
  347. {
  348. state->pulldownTimeBuffer -= 8;
  349. }
  350. else
  351. {
  352. state->pulldownTimeBuffer = 0;
  353. }
  354. }
  356. return (ret);
  357. }
  361. ////////////////////////////////////////////////////////
  362. //
  363. // InvTelecineDetect
  364. //
  365. // Performs detection of the inverse telecine pattern
  366. //
  367. // Parameters:
  368. // data: Pointer to the current planar frame.
  369. // prevData: Pointer to the previous source frame.
  370. // frameRate: The input frame rate.
  371. // timestamp: The timestamp of the current frame.
  372. // pels, lines: Frame dimensions.
  373. // bDeInterlaced: Should be set to TRUE if frame is known
  374. // to be progressive.
  375. // state: State pointer
  376. //
  377. ////////////////////////////////////////////////////////
  379. T_INVTELE_RESULT
  380. InvTelecineDetect
  381. (
  382.  UCHAR *data, 
  383.  UCHAR *prevData, 
  384.  double frameRate, 
  385.  ULONG32 timestamp, 
  386.  ULONG32 pels, ULONG32 lines,
  387.  BOOL bDeInterlaced,
  388.  T_INVTELE_STATE *state
  389. )
  390. {
  391. unsigned int i, j, k, ll;
  392. ULONG32 patternStart, histLength;
  393. LONG32 *pNew, *pOld;
  394. float temp;
  395. float sumEven = 0.0f, sumOdd = 0.0f;
  396. float sumOld = 0.0f, sumNew = 0.0f;
  397. float sumAll = 0.0f;
  399. float inGroupMeanEven[5],outGroupMeanEven[5];
  400. float inGroupStdEven[5],outGroupStdEven[5];
  401. ULONG32 inGroupCountEven,outGroupCountEven;
  402. float outMinEven[5],outMaxEven[5];
  403. float inMaxEven[5],inMinEven[5];
  404. BOOL groupValidFlagEven[5];
  406. float inGroupMeanOdd[5],outGroupMeanOdd[5];
  407. float inGroupStdOdd[5],outGroupStdOdd[5];
  408. ULONG32 inGroupCountOdd,outGroupCountOdd;
  409. float outMinOdd[5],outMaxOdd[5];
  410. float inMaxOdd[5],inMinOdd[5];
  411. BOOL groupValidFlagOdd[5];
  413. float inGroupMean[5], outGroupMean[5];
  414. float inGroupStd[5], outGroupStd[5];
  415. ULONG32 inGroupCount,outGroupCount;
  416. float outMin[5],outMax[5],inMax[5];
  417. BOOL groupValidFlag[5];
  419. ULONG32 timeSinceLastFrame;
  420. BOOL obviousPatternFlag = FALSE;
  421. BOOL sceneChangeFlag = FALSE;
  423. if (state->firstFrame == TRUE)
  424. {
  425. // Initialize history timestamps with this first timestamp
  426. for (i = 0; i < PULLDOWN_HIST_LEN; i++)
  427. {
  428. state->pulldownTimeHist[i] = timestamp;
  429. }
  430. state->lastRemovedTimestamp = timestamp;
  431. state->firstFrame = FALSE;
  432. goto TOO_EARLY;
  433. }
  435. // Calculate Sum of Differences for even and odd lines...
  436. // If we know that the frame is de-interlaced, then the stats
  437. // for the "odd" lines are invalid.  So just measure "even"
  438. // lines then copy into "odd" SAD (so the rest of the algorithm
  439. // will work).
  440. ll = (pels >> 2);
  442. if (bDeInterlaced)
  443. {
  444. pNew = (LONG32 *)data;
  445. pOld = (LONG32 *)prevData;
  446. ll = (pels >> 2);
  448. for (i = 0; i < lines; i += 2)  //  only do the luma.
  449. {
  450. for (j = 0; j < ll; j++)
  451. {
  452. temp = (float)((pNew[j]&0xff00) - (pOld[j]&0xFF00));
  453. sumEven += ((float)(1./(256.*256.)))*(temp*temp);
  454. }
  456. pOld += 2*ll;
  457. pNew += 2*ll;
  458. }
  459. sumOdd = sumEven;
  460. }
  461. else
  462. {
  463. switch (state->impl_id)
  464. {
  465. #ifdef ALLOW_MMX_INVTELE
  466. case INVTELE_IMPL_ID_MMX:
  467. {
  468. SumSqaredFrameDiff_MMX(
  469. data, prevData,
  470. pels, lines, pels,
  471. &sumEven, &sumOdd);
  472. sumAll = 0.5f * (sumEven + sumOdd);
  473. }
  474. break;
  475. #endif
  476. case INVTELE_IMPL_ID_C:
  477. default:
  478. {
  479. pNew = (LONG32 *)data;
  480. pOld = (LONG32 *)prevData;
  482. for (i = 0; i < lines; i += 2)  //  only do the luma.
  483. {
  484. for (j = 0; j < ll; j++)
  485. {
  486. temp = (float)((pNew[j]&0xff00) - (pOld[j]&0xFF00));
  487. sumEven += ((float)(1./(256.*256.)))*(temp*temp);
  488. temp = (float)((pNew[j+ll]&0xFF00) - (pOld[j+ll]&0xFF00));
  489. sumOdd += ((float)(1./(256.*256.)))*(temp*temp);
  490. }
  492. pOld += 2*ll;
  493. pNew += 2*ll;
  494. }
  495. sumAll = sumEven + sumOdd;
  496. sumEven /= (ll * (lines>>1));
  497. sumOdd /= (ll * (lines>>1));
  498. sumAll /= (ll * lines);
  499. }
  500. break;
  501. }
  502. }
  504. sceneChangeFlag = (sumAll > 7500)?(TRUE):(FALSE);
  505. if (sumEven > 100) sumEven=100;
  506. if (sumOdd > 100) sumOdd=100;
  507. if (sumAll > 100) sumAll=100;
  509. #ifdef CODEC_DEBUG_32PULLDOWN
  510. fprintf(fp_log,"ssd are %f %f at time %dn",sumEven,sumOdd,timestamp);
  511. #endif
  513. // Compensate for 30 vs 29.97fps captures.
  514. if ((sumEven == 0) && (sumOdd == 0) && 
  515. (state->NTSCTrackingFrameCounter > 500) && (frameRate > 29.98))
  516. {
  517. state->pulldownTimeHist[PULLDOWN_HIST_LEN-1] = timestamp;
  518. state->NTSCTrackingFrameCounter = 0;
  519.   goto REMOVE_FRAME;
  520. }
  521. state->NTSCTrackingFrameCounter++;
  523. // In case we dropped a frame
  524. timeSinceLastFrame = CALCULATE_ELAPSED_TICKS(state->pulldownTimeHist[PULLDOWN_HIST_LEN-1], timestamp);
  526. while(timeSinceLastFrame > 50)
  527. {
  528. for(i=0;i<PULLDOWN_HIST_LEN-1;i++)
  529. {
  530. state->pulldownSadHistEven[i] = state->pulldownSadHistEven[i+1];
  531. state->pulldownSadHistOdd[i] = state->pulldownSadHistOdd[i+1];
  532. state->pulldownSadHistAll[i] = state->pulldownSadHistAll[i+1];
  533. state->pulldownTimeHist[i] = state->pulldownTimeHist[i+1];
  534. }
  536. state->pulldownSadHistEven[i] = MISSING_SAD;
  537. state->pulldownSadHistOdd[i] = MISSING_SAD;
  538. state->pulldownSadHistAll[i] = MISSING_SAD;
  539. state->pulldownTimeHist[i] = timestamp;
  540. timeSinceLastFrame -= 33;
  541. state->frameRemovalPattern--;
  542. if (state->frameRemovalPattern < 0)
  543. state->frameRemovalPattern = 4;
  544. state->frameCountMod--;
  545. if (state->frameCountMod < 0)
  546. state->frameCountMod = 4;
  547. }
  549. //  Update the history 
  550. for(i = 0; i < PULLDOWN_HIST_LEN - 1; i++)
  551. {
  552. state->pulldownSadHistEven[i] = state->pulldownSadHistEven[i+1];
  553. state->pulldownSadHistOdd[i] = state->pulldownSadHistOdd[i+1];
  554. state->pulldownSadHistAll[i] = state->pulldownSadHistAll[i+1];
  555. state->pulldownTimeHist[i] = state->pulldownTimeHist[i+1];
  556. }
  557. state->frameRemovalPattern--;
  558. if (state->frameRemovalPattern < 0)
  559. state->frameRemovalPattern = 4;
  560. state->frameCountMod--;
  561. if (state->frameCountMod < 0)
  562. state->frameCountMod = 4;
  564. state->pulldownSadHistEven[i] = sumEven;
  565. state->pulldownSadHistOdd[i] = sumOdd;
  566. state->pulldownSadHistAll[i] = sumAll;
  567. state->pulldownTimeHist[i] = timestamp;
  569. // If removal on, and we have no pattern established, wait a while.
  570. if ((state->pulldownSadHistEven[PULLDOWN_HIST_LEN - 5] == UN_INIT_SAD) || 
  571. (state->pulldownSadHistOdd[PULLDOWN_HIST_LEN - 5] == UN_INIT_SAD) || 
  572. (state->pulldownSadHistAll[PULLDOWN_HIST_LEN - 5] == UN_INIT_SAD))
  573. {
  574. #ifdef CODEC_DEBUG_32PULLDOWN
  575. fprintf(fp_log,"gotoing - too earlyn");
  576. #endif
  577. goto TOO_EARLY;
  578. }
  580. histLength = 0;
  582. while (state->pulldownSadHistAll[histLength] == UN_INIT_SAD)
  583. {
  584. histLength += 5;
  585. if (histLength > PULLDOWN_HIST_LEN - 10)
  586. goto TOO_EARLY;
  587. }
  589. if ((bDeInterlaced) || (state->ulPulldownActiveTimerProg > 90 && state->ulPulldownActiveTimerIntl < 10))
  590. {
  591. // Skip interlaced telecine tests
  592. goto PROGRESSIVE_TESTS;
  593. }
  595. // Gather statistics from SAD history
  596. // Run through tests looking at the last 20, then 15, then 10, then 5 frames
  597. for (patternStart = histLength; patternStart < PULLDOWN_HIST_LEN; patternStart += 5)
  598. {
  599. for (i = 0; i < 5;i++)
  600. {
  601. // Stats for "even" lines
  602. inGroupMeanEven[i]  = 0;
  603. outGroupMeanEven[i] = 0;
  604. inGroupStdEven[i]   = 0;
  605. outGroupStdEven[i]  = 0;
  606. inGroupCountEven    = 0;
  607. outGroupCountEven   = 0;
  608. outMinEven[i] = 255*255;
  609. inMinEven[i]  = 255*255;
  610. outMaxEven[i] = 0;
  611. inMaxEven[i]  = 0;
  612. for (j = patternStart + i; j < PULLDOWN_HIST_LEN; j++)
  613. {
  614. if (state->pulldownSadHistEven[j] == MISSING_SAD ||
  615. state->pulldownSadHistEven[j] == UN_INIT_SAD)
  616. continue;
  618. if (((j - i) % 5) == 0)
  619. {
  620. inGroupMeanEven[i] += state->pulldownSadHistEven[j];
  621. inGroupStdEven[i] += state->pulldownSadHistEven[j]*state->pulldownSadHistEven[j];
  622. if (inMaxEven[i] < state->pulldownSadHistEven[j])
  623. inMaxEven[i] = state->pulldownSadHistEven[j];
  624. if (inMinEven[i] > state->pulldownSadHistOdd[j])
  625. inMinEven[i] = state->pulldownSadHistOdd[j];
  626. inGroupCountEven++;
  627. }
  628. else
  629. {
  630. outGroupMeanEven[i]+= state->pulldownSadHistEven[j];
  631. outGroupStdEven[i]+= state->pulldownSadHistEven[j]*state->pulldownSadHistEven[j];
  632. if (outMinEven[i] > state->pulldownSadHistEven[j])
  633. outMinEven[i] = state->pulldownSadHistEven[j];
  634. if (outMaxEven[i] < state->pulldownSadHistEven[j])
  635. outMaxEven[i] = state->pulldownSadHistEven[j];
  636. outGroupCountEven++;
  637. }
  638. }
  639. // Is there enough valid data to analyze?
  640. if ((inGroupCountEven > 1) && (outGroupCountEven > 3))
  641. {
  642. inGroupMeanEven[i] = inGroupMeanEven[i]/inGroupCountEven;
  643. if ((inGroupStdEven[i]/inGroupCountEven)-(inGroupMeanEven[i]*inGroupMeanEven[i]) > 0.0f)
  644. inGroupStdEven[i] = (float)sqrt((inGroupStdEven[i]/inGroupCountEven)-(inGroupMeanEven[i]*inGroupMeanEven[i]));
  645. else
  646. inGroupStdEven[i] = 0.0f;
  648. outGroupMeanEven[i] = outGroupMeanEven[i]/outGroupCountEven;
  649. if ((outGroupStdEven[i]/outGroupCountEven)-(outGroupMeanEven[i]*outGroupMeanEven[i]) > 0.0f)
  650. outGroupStdEven[i] = (float)sqrt((outGroupStdEven[i]/outGroupCountEven)-(outGroupMeanEven[i]*outGroupMeanEven[i]));
  651. else
  652. outGroupStdEven[i] = 0.0f;
  654. groupValidFlagEven[i] = TRUE;
  655. }
  656. else
  657. {
  658. inGroupMeanEven[i] = 0;
  659. outGroupMeanEven[i] = 0;
  660. inGroupStdEven[i] = 1;
  661. outGroupStdEven[i] = 1;
  662. groupValidFlagEven[i] = FALSE;
  663. }
  665. // Stats for "odd" lines
  666. inGroupMeanOdd[i]  = 0;
  667. outGroupMeanOdd[i] = 0;
  668. inGroupStdOdd[i]   = 0;
  669. outGroupStdOdd[i]  = 0;
  670. inGroupCountOdd    = 0;
  671. outGroupCountOdd   = 0;
  672. outMinOdd[i] = 255*255;
  673. inMinOdd[i]  = 255*255;
  674. outMaxOdd[i] = 0;
  675. inMaxOdd[i]  = 0;
  676. for (j = patternStart + i; j < PULLDOWN_HIST_LEN; j++)
  677. {
  678. if (state->pulldownSadHistOdd[j] == MISSING_SAD ||
  679. state->pulldownSadHistOdd[j] == UN_INIT_SAD)
  680. continue;
  682. if (((j - i) % 5) == 0)
  683. {
  684. inGroupMeanOdd[i] += state->pulldownSadHistOdd[j];
  685. inGroupStdOdd[i] += state->pulldownSadHistOdd[j]*state->pulldownSadHistOdd[j];
  686. if (inMaxOdd[i] < state->pulldownSadHistOdd[j])
  687. inMaxOdd[i] = state->pulldownSadHistOdd[j];
  688. if (inMinOdd[i] > state->pulldownSadHistOdd[j])
  689. inMinOdd[i] = state->pulldownSadHistOdd[j];
  690. inGroupCountOdd++;
  691. }
  692. else
  693. {
  694. outGroupMeanOdd[i] += state->pulldownSadHistOdd[j];
  695. outGroupStdOdd[i] += state->pulldownSadHistOdd[j]*state->pulldownSadHistOdd[j];
  696. if (outMinOdd[i] > state->pulldownSadHistOdd[j])
  697. outMinOdd[i] = state->pulldownSadHistOdd[j];
  698. if (outMaxOdd[i] < state->pulldownSadHistOdd[j])
  699. outMaxOdd[i] = state->pulldownSadHistOdd[j];
  700. outGroupCountOdd++;
  701. }
  702. }
  703. // Is there enough valid data to analyze?
  704. if ((inGroupCountOdd > 1) && (outGroupCountOdd > 3))
  705. {
  706. inGroupMeanOdd[i] = inGroupMeanOdd[i]/inGroupCountOdd;
  707. if ((inGroupStdOdd[i]/inGroupCountOdd)-(inGroupMeanOdd[i]*inGroupMeanOdd[i]) > 0.0f)
  708. inGroupStdOdd[i] = (float)sqrt((inGroupStdOdd[i]/inGroupCountOdd)-(inGroupMeanOdd[i]*inGroupMeanOdd[i]));
  709. else
  710. inGroupStdOdd[i] = 0.0f;
  712. outGroupMeanOdd[i] = outGroupMeanOdd[i]/outGroupCountOdd;
  713. if ((outGroupStdOdd[i]/outGroupCountOdd)-(outGroupMeanOdd[i]*outGroupMeanOdd[i]) > 0.0f)
  714. outGroupStdOdd[i] = (float)sqrt((outGroupStdOdd[i]/outGroupCountOdd)-(outGroupMeanOdd[i]*outGroupMeanOdd[i]));
  715. else
  716. outGroupStdOdd[i] = 0.0f;
  718. groupValidFlagOdd[i] = TRUE;
  719. }
  720. else
  721. {
  722. inGroupMeanOdd[i] = 0;
  723. outGroupMeanOdd[i] = 0;
  724. inGroupStdOdd[i] = 1;
  725. outGroupStdOdd[i] = 1;
  726. groupValidFlagOdd[i] = FALSE;
  727. }
  728. }
  730. // Do we have a clear pattern? Always trust this test.
  731. for (i = 0; i < 5; i++)
  732. {
  733. if (groupValidFlagEven[i] == FALSE)
  734. continue;
  735. if (groupValidFlagOdd[i] == FALSE)
  736. continue;
  737. if (groupValidFlagEven[(i+2)%5] == FALSE)
  738. continue;
  739. if (groupValidFlagOdd[(i+2)%5] == FALSE)
  740. continue;
  742. if ((inGroupMeanEven[i]+inThresh[patternStart]*inGroupStdEven[i] < outGroupMeanEven[i] - outThresh[patternStart]*outGroupStdEven[i]) &&
  743. (inGroupMeanOdd[(i+2)%5]+inThresh[patternStart]*inGroupStdOdd[(i+2)%5] < outGroupMeanOdd[(i+2)%5] - outThresh[patternStart]*outGroupStdOdd[(i+2)%5]) &&
  744. (inGroupMeanEven[i]+inGroupStdEven[i] < inGroupMeanOdd[i]) &&
  745. (inGroupMeanOdd[(i+2)%5]+inGroupStdOdd[(i+2)%5] < inGroupMeanEven[(i+2)%5]))
  746. {
  747. #ifdef CODEC_DEBUG_32PULLDOWN
  748. fprintf(fp_log,"clear pattern, i is %d, pulldown timer is %d, patternStart is %dn",i,state->ulPulldownActiveTimerIntl,patternStart);
  749. #endif
  750. // Set the removal pattern phase
  751. state->frameRemovalPattern = i;
  753. // If this is the right frame remove it!
  754. if (i == (PULLDOWN_HIST_LEN - 1) % 5)
  755. {
  756. // Set a counter that goes up if we have a consistent pattern 80+% of the time, down otherwise
  757. if ((timestamp - state->lastRemovedTimestamp > 145) &&
  758. (timestamp - state->lastRemovedTimestamp < 175))
  759. {
  760. if (state->ulPulldownActiveTimerIntl < 95)
  761. state->ulPulldownActiveTimerIntl += 5;
  762. else
  763. {
  764. state->ulPulldownActiveTimerIntl = 100;
  765. state->bInterlacedTelecineSeen = TRUE;
  766. }
  768. if (state->ulPulldownActiveTimerProg > 5)
  769. state->ulPulldownActiveTimerProg -= 5;
  770. else
  771. state->ulPulldownActiveTimerProg = 0;
  772. }
  773. else if (timestamp - state->lastRemovedTimestamp < 300)
  774. {
  775. if (state->ulPulldownActiveTimerIntl > 5)
  776. state->ulPulldownActiveTimerIntl -= 5;
  777. else
  778. state->ulPulldownActiveTimerIntl = 0;
  779. }
  780. state->lastRemovedTimestamp = timestamp;
  782. goto REMOVE_FRAME;
  783. }
  784. else if (i == ((PULLDOWN_HIST_LEN - 2) % 5))
  785. {
  786. obviousPatternFlag = TRUE;
  787. goto INTERLEAVE_ODD;
  788. }
  789. else 
  790. goto DO_NOTHING;
  791. }
  793. if ((inGroupMeanOdd[i]+inThresh[patternStart]*inGroupStdOdd[i] < outGroupMeanOdd[i] - outThresh[patternStart]*outGroupStdOdd[i]) &&
  794. (inGroupMeanEven[(i+2)%5]+inThresh[patternStart]*inGroupStdEven[(i+2)%5] < outGroupMeanEven[(i+2)%5] - outThresh[patternStart]*outGroupStdEven[(i+2)%5]) &&
  795. (inGroupMeanOdd[i]+inGroupStdOdd[i] < inGroupMeanEven[i]) &&
  796. (inGroupMeanEven[(i+2)%5]+inGroupStdEven[(i+2)%5] < inGroupMeanOdd[(i+2)%5]))
  797. {
  798. #ifdef CODEC_DEBUG_32PULLDOWN
  799. fprintf(fp_log,"clear pattern, i is %d, pulldown timer is %d, patternStart is %dn",i,state->ulPulldownActiveTimerIntl,patternStart);
  800. #endif
  801. // Set the removal pattern phase
  802. state->frameRemovalPattern=i;
  804. // If this is the right frame remove it!
  805. if (i == (PULLDOWN_HIST_LEN - 1) % 5)
  806. {
  807. // Set a counter that goes up if we have a consistent pattern 80+% of the time, down otherwise
  808. if ((timestamp - state->lastRemovedTimestamp > 145) &&
  809. (timestamp - state->lastRemovedTimestamp < 175))
  810. {
  811. if (state->ulPulldownActiveTimerIntl < 95)
  812. state->ulPulldownActiveTimerIntl += 5;
  813. else
  814. {
  815. state->ulPulldownActiveTimerIntl = 100;
  816. state->bInterlacedTelecineSeen = TRUE;
  817. }
  819. if (state->ulPulldownActiveTimerProg > 5)
  820. state->ulPulldownActiveTimerProg -= 5;
  821. else
  822. state->ulPulldownActiveTimerProg = 0;
  823. }
  824. else if (timestamp - state->lastRemovedTimestamp < 300)
  825. {
  826. if (state->ulPulldownActiveTimerIntl > 5)
  827. state->ulPulldownActiveTimerIntl -= 5;
  828. else
  829. state->ulPulldownActiveTimerIntl = 0;
  830. }
  831. state->lastRemovedTimestamp = timestamp;
  833. goto REMOVE_FRAME;
  834. }
  835. else if (i == ((PULLDOWN_HIST_LEN - 2) % 5))
  836. {
  837. obviousPatternFlag = TRUE;
  838. goto INTERLEAVE_EVEN;
  839. }
  840. else 
  841. goto DO_NOTHING;
  842. }
  843. }
  845. // Do we have a pretty clear pattern? Only trust this test 
  846. // if we have succeeded with the strongest test a couple of times
  847. for (i = 0; i < 5; i++)
  848. {
  849. if (groupValidFlagEven[i] == FALSE)
  850. continue;
  851. if (groupValidFlagOdd[i] == FALSE)
  852. continue;
  853. if (groupValidFlagEven[(i+2)%5] == FALSE)
  854. continue;
  855. if (groupValidFlagOdd[(i+2)%5] == FALSE)
  856. continue;
  858. if ((state->ulPulldownActiveTimerIntl > 10) &&
  859. (inGroupMeanEven[i]      + inThresh[patternStart]*inGroupStdEven[i]      < outMinEven[i]     ) &&
  860. (inGroupMeanOdd[(i+2)%5] + inThresh[patternStart]*inGroupStdOdd[(i+2)%5] < outMinOdd[(i+2)%5]) &&
  861. (inGroupMeanEven[i]      + inGroupStdEven[i]      < inGroupMeanOdd[i]       ) &&
  862. (inGroupMeanOdd[(i+2)%5] + inGroupStdOdd[(i+2)%5] < inGroupMeanEven[(i+2)%5]))
  863. {
  864. #ifdef CODEC_DEBUG_32PULLDOWN
  865. fprintf(fp_log,"pretty clear pattern, i is %d, pulldown timer is %d, patternStart is %dn",i,state->ulPulldownActiveTimerIntl,patternStart);
  866. #endif
  867. // Set the removal pattern phase
  868. state->frameRemovalPattern=i;
  870. // If this is the right frame remove it!
  871. if(i == (PULLDOWN_HIST_LEN - 1) % 5)
  872. {
  873. // Set a counter that goes up if we have a consistent pattern 80+% of the time, down otherwise
  874. if ((timestamp - state->lastRemovedTimestamp > 145) &&
  875. (timestamp - state->lastRemovedTimestamp < 175))
  876. {
  877. if (state->ulPulldownActiveTimerIntl < 95)
  878. state->ulPulldownActiveTimerIntl += 5;
  879. else
  880. {
  881. state->ulPulldownActiveTimerIntl = 100;
  882. state->bInterlacedTelecineSeen = TRUE;
  883. }
  885. if (state->ulPulldownActiveTimerProg > 5)
  886. state->ulPulldownActiveTimerProg -= 5;
  887. else
  888. state->ulPulldownActiveTimerProg = 0;
  889. }
  890. else if (timestamp - state->lastRemovedTimestamp < 300)
  891. {
  892. if (state->ulPulldownActiveTimerIntl > 5)
  893. state->ulPulldownActiveTimerIntl -= 5;
  894. else
  895. state->ulPulldownActiveTimerIntl = 0;
  896. }
  897. state->lastRemovedTimestamp = timestamp;
  899. goto REMOVE_FRAME;
  900. }
  901. else if (i == ((PULLDOWN_HIST_LEN - 2) % 5))
  902. {
  903. obviousPatternFlag = TRUE;
  904. goto INTERLEAVE_ODD;
  905. }
  906. else 
  907. goto DO_NOTHING;
  908. }
  910. if ((state->ulPulldownActiveTimerIntl > 10) &&
  911. (inGroupMeanOdd[i]        + inThresh[patternStart]*inGroupStdOdd[i]        < outMinOdd[i]       ) &&
  912. (inGroupMeanEven[(i+2)%5] + inThresh[patternStart]*inGroupStdEven[(i+2)%5] < outMinEven[(i+2)%5]) &&
  913. (inGroupMeanOdd[i]        + inGroupStdOdd[i]        < inGroupMeanEven[i]     ) &&
  914. (inGroupMeanEven[(i+2)%5] + inGroupStdEven[(i+2)%5] < inGroupMeanOdd[(i+2)%5]))
  915. {
  916. #ifdef CODEC_DEBUG_32PULLDOWN
  917. fprintf(fp_log,"pretty clear pattern, i is %d, pulldown timer is %d, patternStart is %dn",i,state->ulPulldownActiveTimerIntl,patternStart);
  918. #endif
  919. // Set the removal pattern phase
  920. state->frameRemovalPattern=i;
  922. // If this is the right frame remove it!
  923. if(i == (PULLDOWN_HIST_LEN - 1) % 5)
  924. {
  925. // Set a counter that goes up if we have a consistent pattern 80+% of the time, down otherwise
  926. if ((timestamp - state->lastRemovedTimestamp > 145) && 
  927. (timestamp - state->lastRemovedTimestamp < 175))
  928. {
  929. if (state->ulPulldownActiveTimerIntl < 95)
  930. state->ulPulldownActiveTimerIntl += 5;
  931. else
  932. {
  933. state->ulPulldownActiveTimerIntl = 100;
  934. state->bInterlacedTelecineSeen = TRUE;
  935. }
  937. if (state->ulPulldownActiveTimerProg > 5)
  938. state->ulPulldownActiveTimerProg -= 5;
  939. else
  940. state->ulPulldownActiveTimerProg = 0;
  941. }
  942. else if (timestamp - state->lastRemovedTimestamp < 300)
  943. {
  944. if (state->ulPulldownActiveTimerIntl > 5)
  945. state->ulPulldownActiveTimerIntl -= 5;
  946. else
  947. state->ulPulldownActiveTimerIntl = 0;
  948. }
  949. state->lastRemovedTimestamp = timestamp;
  951. goto REMOVE_FRAME;
  952. }
  953. else if (i == ((PULLDOWN_HIST_LEN - 2) % 5))
  954. {
  955. obviousPatternFlag = TRUE;
  956. goto INTERLEAVE_EVEN;
  957. }
  958. else 
  959. goto DO_NOTHING;
  960. }
  961. }
  962. }
  964. // Rule that maintains the pattern
  965. // No pattern, but things are VERY quiet, and we have been seeing a 3:2 pattern 
  966. if ((state->frameRemovalPattern == ((PULLDOWN_HIST_LEN-1)%5)) &&
  967. (state->ulPulldownActiveTimerIntl > 50) &&
  968. (inMaxEven [(PULLDOWN_HIST_LEN-1)%5] < 13) && 
  969. (inMaxOdd  [(PULLDOWN_HIST_LEN-1)%5] < 13) && 
  970. (outMaxOdd [(PULLDOWN_HIST_LEN-1)%5] < 13) &&
  971. (outMaxEven[(PULLDOWN_HIST_LEN-1)%5] < 13) && 
  972. (groupValidFlagEven[(PULLDOWN_HIST_LEN-1)%5] == TRUE) &&
  973. (groupValidFlagOdd[(PULLDOWN_HIST_LEN-1)%5] == TRUE))
  974. {
  975. #ifdef CODEC_DEBUG_32PULLDOWN
  976. fprintf(fp_log,"maintain pattern 1 - things are very quiet, pulldown timer is %d, patternStart is %dn",state->ulPulldownActiveTimerIntl,patternStart);
  977. #endif
  978. state->lastRemovedTimestamp = timestamp;
  979. state->checkNextFrameForInterlace = TRUE;
  981. goto REMOVE_FRAME;
  982. }
  984. // Rule that maintains the pattern
  985. // If we have been seeing consistent pulldown, 
  986. // and the last frame looks a bit interlaced, but it is in the right place.
  987. // This is a weak test.
  988. if ((state->frameRemovalPattern == ((PULLDOWN_HIST_LEN-1)%5)) &&
  989. (state->ulPulldownActiveTimerIntl > 50) &&
  990. (!state->checkNextFrameForInterlace) &&
  991. (state->pulldownSadHistEven[(PULLDOWN_HIST_LEN-1)] < (.6*state->pulldownSadHistOdd[(PULLDOWN_HIST_LEN-1)]) ||
  992.  state->pulldownSadHistOdd[(PULLDOWN_HIST_LEN-1)] < (.6*state->pulldownSadHistEven[(PULLDOWN_HIST_LEN-1)])))
  993. {
  994. #ifdef CODEC_DEBUG_32PULLDOWN
  995. fprintf(fp_log,"maintain pattern 2, pulldown timer is %d, patternStart is %dn",state->ulPulldownActiveTimerIntl,patternStart);
  996. #endif
  997. state->lastRemovedTimestamp = timestamp;
  998. state->checkNextFrameForInterlace = TRUE;
  999. goto REMOVE_FRAME;
  1000. }
  1002. // If we have been seeing consistent pulldown, and the last frame looks very interlaced.
  1003. // This is a weak test
  1004. if ((state->ulPulldownActiveTimerIntl > 50) &&
  1005. (!state->checkNextFrameForInterlace) &&
  1006. (
  1007.  (state->pulldownSadHistEven[(PULLDOWN_HIST_LEN-1)] < (state->pulldownSadHistOdd[(PULLDOWN_HIST_LEN-1)]*.3)) &&
  1008.  (state->pulldownSadHistOdd[(PULLDOWN_HIST_LEN-1)] > 9)
  1009. ) || (
  1010.  (state->pulldownSadHistOdd[(PULLDOWN_HIST_LEN-1)] < (state->pulldownSadHistEven[(PULLDOWN_HIST_LEN-1)]*.3)) &&
  1011.  (state->pulldownSadHistEven[(PULLDOWN_HIST_LEN-1)] > 9)
  1012. )
  1013.    )
  1014. {
  1015. #ifdef CODEC_DEBUG_32PULLDOWN
  1016. fprintf(fp_log,"things look interlaced, pulldown timer is %d, patternStart is %dn",state->ulPulldownActiveTimerIntl,patternStart);
  1017. #endif
  1018. state->lastRemovedTimestamp = timestamp;
  1019. state->checkNextFrameForInterlace = TRUE;
  1020. goto REMOVE_FRAME;
  1021. }
  1023. if(state->checkNextFrameForInterlace)
  1024. {
  1025. #ifdef CODEC_DEBUG_32PULLDOWN
  1026. fprintf(fp_log,"checking frame for interlacen",i,state->ulPulldownActiveTimerIntl,patternStart);
  1027. #endif
  1028. state->checkNextFrameForInterlace = FALSE;
  1029. if(state->interleaveEvenFlag)
  1030. goto INTERLEAVE_EVEN;
  1031. if(state->interleaveOddFlag)
  1032. goto INTERLEAVE_ODD;
  1033. }
  1035. // Otherwise no pulldown!
  1036. #ifdef CODEC_DEBUG_32PULLDOWN
  1037. fprintf(fp_log,"no pattern, pulldown timer is %d, patternStart is %dn",state->ulPulldownActiveTimerIntl,patternStart);
  1038. #endif
  1039. if ((inMaxEven[(PULLDOWN_HIST_LEN-1)%5] > 30) || 
  1040. (outMaxEven[(PULLDOWN_HIST_LEN-1)%5] > 30))
  1041. {
  1042. if (state->ulPulldownActiveTimerIntl > 0)
  1043. state->ulPulldownActiveTimerIntl--;
  1044. }
  1046. // should we attempt progressive patterns?
  1047. if ((lines > 242) || 
  1048. (state->ulPulldownActiveTimerIntl > 90 && state->ulPulldownActiveTimerProg < 10))
  1049. {
  1050. goto NO_PATTERN;
  1051. }
  1053. PROGRESSIVE_TESTS:
  1055. // Now test to see if there is an entire repeated frame
  1056. for (patternStart = histLength; patternStart < PULLDOWN_HIST_LEN; patternStart += 5)
  1057. {
  1058. for (i = 0; i < 5; i++)
  1059. {
  1060. inGroupMean[i]  = 0;
  1061. outGroupMean[i] = 0;
  1062. inGroupStd[i]   = 0;
  1063. outGroupStd[i]  = 0;
  1064. inGroupCount    = 0;
  1065. outGroupCount   = 0;
  1066. outMin[i] = 255*255;
  1067. outMax[i] = 0;
  1068. inMax[i]  = 0;
  1070. for (j = patternStart + i; j < PULLDOWN_HIST_LEN; j++)
  1071. {
  1072. if (state->pulldownSadHistAll[j] == MISSING_SAD ||
  1073. state->pulldownSadHistAll[j] == UN_INIT_SAD)
  1074. continue;
  1076. if (((j - i) % 5) == 0)
  1077. {
  1078. inGroupMean[i] += state->pulldownSadHistAll[j];
  1079. inGroupStd[i] += state->pulldownSadHistAll[j] * state->pulldownSadHistAll[j];
  1080. if (inMax[i] < state->pulldownSadHistAll[j])
  1081. inMax[i] = state->pulldownSadHistAll[j];
  1082. inGroupCount++;
  1083. }
  1084. else
  1085. {
  1086. outGroupMean[i] += state->pulldownSadHistAll[j];
  1087. outGroupStd[i] += state->pulldownSadHistAll[j] * state->pulldownSadHistAll[j];
  1088. if (outMin[i] > state->pulldownSadHistAll[j])
  1089. outMin[i] = state->pulldownSadHistAll[j];
  1090. if (outMax[i] < state->pulldownSadHistAll[j])
  1091. outMax[i] = state->pulldownSadHistAll[j];
  1092. outGroupCount++;
  1093. }
  1094. }
  1095. if ((inGroupCount > 1) && (outGroupCount > 3))
  1096. {
  1097. groupValidFlag[i] = TRUE;
  1099. inGroupMean[i] = inGroupMean[i]/inGroupCount;
  1100. if ((inGroupStd[i]/inGroupCount)-(inGroupMean[i]*inGroupMean[i]) > 0.0f)
  1101. inGroupStd[i] = (float)sqrt((inGroupStd[i]/inGroupCount)-(inGroupMean[i]*inGroupMean[i]));
  1102. else
  1103. inGroupStd[i] = 0.0f;
  1105. outGroupMean[i] = outGroupMean[i]/outGroupCount;
  1106. if ((outGroupStd[i]/outGroupCount)-(outGroupMean[i]*outGroupMean[i]) > 0.0f)
  1107. outGroupStd[i] = (float)sqrt((outGroupStd[i]/outGroupCount)-(outGroupMean[i]*outGroupMean[i]));
  1108. else
  1109. outGroupStd[i] = 0.0f;
  1110. }
  1111. else
  1112. {
  1113. groupValidFlag[i] = FALSE;
  1114. inGroupMean[i] = 0;
  1115. outGroupMean[i] = 0;
  1116. inGroupStd[i] = 1;
  1117. outGroupStd[i] = 1;
  1118. }
  1119. }
  1121. // Do we have a clear pattern? Always trust this test.
  1122. for (i = 0;i < 5; i++)
  1123. {
  1124. if ((inGroupMean[i]+inThresh[patternStart]*inGroupStd[i] < outGroupMean[i] - outThresh[patternStart]*outGroupStd[i]) &&
  1125. (groupValidFlag[i] == TRUE))
  1126. {
  1127. #ifdef CODEC_DEBUG_32PULLDOWN
  1128. fprintf(fp_log,"clear pattern, i is %d, pulldown timer is %d, patternStart is %dn",i,state->ulPulldownActiveTimerProg,patternStart);
  1129. #endif
  1130. // If this is the right frame remove it!
  1131. state->frameRemovalPattern=i;
  1132. if(i==(PULLDOWN_HIST_LEN-1)%5)
  1133. {
  1134. // Set a counter that goes up if we have a consistent pattern 80+% of the time, down otherwise
  1135. if ((timestamp - state->lastRemovedTimestamp > 145) &&
  1136. (timestamp - state->lastRemovedTimestamp < 175))
  1137. {
  1138. if (state->ulPulldownActiveTimerProg < 95)
  1139. state->ulPulldownActiveTimerProg += 5;
  1140. else
  1141. {
  1142. state->ulPulldownActiveTimerProg = 100;
  1143. state->bProgressiveTelecineSeen = TRUE;
  1144. }
  1146. if (state->ulPulldownActiveTimerIntl > 5)
  1147. state->ulPulldownActiveTimerIntl -= 5;
  1148. else
  1149. state->ulPulldownActiveTimerIntl = 0;
  1150. }
  1151. else if (timestamp - state->lastRemovedTimestamp < 300)
  1152. {
  1153. if (state->ulPulldownActiveTimerProg > 5)
  1154. state->ulPulldownActiveTimerProg -= 5;
  1155. else
  1156. state->ulPulldownActiveTimerProg = 0;
  1157. }
  1158. state->lastRemovedTimestamp = timestamp;
  1159. goto REMOVE_FRAME;
  1160. }
  1161. else 
  1162. goto DO_NOTHING;
  1163. }
  1164. }
  1166. // Do we have a pretty clear pattern? Only trust this test if we have succeeded with the strongest test a couple of times
  1167. for(i = 0; i < 5; i++)
  1168. {
  1169. if ((inGroupMean[i]+inThresh[patternStart]*inGroupStd[i] < outMin[i]) &&
  1170. (state->ulPulldownActiveTimerProg > 10) &&
  1171. (groupValidFlag[i] == TRUE))
  1172. {
  1173. #ifdef CODEC_DEBUG_32PULLDOWN
  1174. fprintf(fp_log,"pretty clear pattern, i is %d, pulldown timer is %d, patternStart is %dn",i,state->ulPulldownActiveTimerProg,patternStart);
  1175. #endif
  1176. // If this is the right frame remove it!
  1177. state->frameRemovalPattern = i;
  1178. if (i == (PULLDOWN_HIST_LEN-1)%5)
  1179. {
  1180. // Set a counter that goes up if we have a consistent pattern 80+% of the time, down otherwise
  1181. if ((timestamp - state->lastRemovedTimestamp > 145) && 
  1182. (timestamp - state->lastRemovedTimestamp < 175))
  1183. {
  1184. if (state->ulPulldownActiveTimerProg < 95)
  1185. state->ulPulldownActiveTimerProg += 5;
  1186. else
  1187. {
  1188. state->ulPulldownActiveTimerProg = 100;
  1189. state->bProgressiveTelecineSeen = TRUE;
  1190. }
  1192. if (state->ulPulldownActiveTimerIntl > 5)
  1193. state->ulPulldownActiveTimerIntl -= 5;
  1194. else
  1195. state->ulPulldownActiveTimerIntl = 0;
  1196. }
  1197. else if (timestamp - state->lastRemovedTimestamp < 300)
  1198. {
  1199. if (state->ulPulldownActiveTimerProg > 5)
  1200. state->ulPulldownActiveTimerProg -= 5;
  1201. else
  1202. state->ulPulldownActiveTimerProg = 0;
  1203. }
  1204. state->lastRemovedTimestamp = timestamp;
  1205. goto REMOVE_FRAME;
  1206. }
  1207. else 
  1208. goto DO_NOTHING;
  1209. }
  1210. }
  1212. // No pattern, but things are VERY quiet, and we have been seeing a 3:2 pattern 
  1213. if ((inMax[(PULLDOWN_HIST_LEN-1)%5] < 9) && (state->ulPulldownActiveTimerProg > 50) &&
  1214. (outMax[(PULLDOWN_HIST_LEN-1)%5] < 9) && (groupValidFlag[(PULLDOWN_HIST_LEN-1)%5] == TRUE) &&
  1215. (state->frameRemovalPattern==((PULLDOWN_HIST_LEN-1)%5))
  1216.    )
  1217. {
  1218. #ifdef CODEC_DEBUG_32PULLDOWN
  1219. fprintf(fp_log,"things are quiet, pulldown timer is %d, patternStart is %dn",state->ulPulldownActiveTimerProg,patternStart);
  1220. #endif
  1221. state->lastRemovedTimestamp = timestamp;
  1222. goto REMOVE_FRAME;
  1223. }
  1224. }
  1226. // If we have been seeing consistent pulldown, and the last two frames have been quiet frames.
  1227. // This is our weakest test
  1228. if (((state->pulldownSadHistAll[(PULLDOWN_HIST_LEN-1)] < 9) ||
  1229. (state->pulldownSadHistAll[(PULLDOWN_HIST_LEN-1)] < state->pulldownSadHistAll[(PULLDOWN_HIST_LEN-2)])) &&
  1230. (state->ulPulldownActiveTimerProg > 50) &&
  1231. (groupValidFlag[(PULLDOWN_HIST_LEN-1)%5] == TRUE)&&(state->frameRemovalPattern==((PULLDOWN_HIST_LEN-1)%5))
  1232.    )
  1233. {
  1234. #ifdef CODEC_DEBUG_32PULLDOWN
  1235. fprintf(fp_log,"things are quiet, pulldown timer is %d, patternStart is %dn",state->ulPulldownActiveTimerProg,patternStart);
  1236. #endif
  1237. state->lastRemovedTimestamp = timestamp;
  1238. goto REMOVE_FRAME;
  1239. }
  1242. // If we have been seeing consistent pulldown, and the last frame looks very interlaced.
  1243. // This is a weak test
  1244. if ((state->pulldownSadHistAll[(PULLDOWN_HIST_LEN-1)] < state->pulldownSadHistAll[(PULLDOWN_HIST_LEN-2)] * 0.5) &&
  1245. (state->ulPulldownActiveTimerProg > 50) &&
  1246. (groupValidFlag[(PULLDOWN_HIST_LEN-1)%5] == TRUE))
  1247. {
  1248. state->frameRemovalPattern = (PULLDOWN_HIST_LEN-1)%5;
  1249. #ifdef CODEC_DEBUG_32PULLDOWN
  1250. fprintf(fp_log,"things look interlaced, pulldown timer is %d, patternStart is %dn",state->ulPulldownActiveTimerProg,patternStart);
  1251. #endif
  1252. state->lastRemovedTimestamp = timestamp;
  1253. goto REMOVE_FRAME;
  1254. }
  1256. // Otherwise no pulldown!
  1257. #ifdef CODEC_DEBUG_32PULLDOWN
  1258. fprintf(fp_log,"no pattern, pulldown timer is %d, patternStart is %dn",state->ulPulldownActiveTimerProg,patternStart);
  1259. #endif
  1261. if((inMax[(PULLDOWN_HIST_LEN-1)%5] > 30) || (outMax[(PULLDOWN_HIST_LEN-1)%5] >30))
  1262. if (state->ulPulldownActiveTimerProg > 0)
  1263. state->ulPulldownActiveTimerProg--;
  1265. NO_PATTERN:
  1267. // If there was no clear pattern, do nothing
  1268. state->checkNextFrameForProgressive = FALSE;
  1269. return INVTELE_RESULT_NO_PATTERN;
  1271. INTERLEAVE_ODD:
  1273. state->checkNextFrameForProgressive = FALSE;
  1275. // Test if data should be re-interleaved.
  1276. // Look at cross difference of old vs. re-stitched. Only replace if better
  1277. if (obviousPatternFlag == FALSE || sceneChangeFlag == TRUE)
  1278. {
  1279. switch (state->impl_id)
  1280. {
  1281. #ifdef ALLOW_MMX_INVTELE
  1282. case INVTELE_IMPL_ID_MMX:
  1283. {
  1284. RestitchCheck_MMX(data, prevData, 
  1285. pels, lines, pels, &sumOld, &sumNew);
  1286. }
  1287. break;
  1288. #endif
  1289. case INVTELE_IMPL_ID_C:
  1290. default:
  1291. {
  1292. pNew = (LONG32 *)(data);
  1293. pOld = (LONG32 *)(prevData);
  1294. for (i = 0; i < lines; i += 2)  //  only do the luma.
  1295. {
  1296. for(j = 0; j < ll; j++)
  1297. {
  1298. temp = (float)((pNew[j]&0xff00) - (pNew[j+ll]&0xff00));
  1299. sumOld += (temp*temp);
  1300. temp = (float)((pNew[j]&0xff00) - (pOld[j+ll]&0xff00));
  1301. sumNew += (temp*temp);
  1302. }
  1303. pOld += 2*ll;
  1304. pNew += 2*ll;
  1305. }
  1306. }
  1307. break;
  1308. }
  1310. if (sumNew > sumOld)
  1311. {
  1312. return INVTELE_RESULT_FRAME_OK;
  1313. }
  1314. }
  1316. state->interleaveOddFlag = TRUE;
  1318. #ifdef CODEC_DEBUG_32PULLDOWN
  1319. fprintf(fp_log,"interleaving oddn");
  1320. #endif
  1322. // Re-interleave
  1323. pNew = ((LONG32 *)data)+ll;
  1324. pOld = ((LONG32 *)prevData)+ll;
  1326. for (k = 1; k < lines; k += 2)  //  only do the luma.
  1327. {
  1328. memcpy(pNew,pOld,sizeof(ULONG32)*ll); /* Flawfinder: ignore */
  1329. pOld+=2*ll;
  1330. pNew+=2*ll;
  1331. }
  1333. return INVTELE_RESULT_FRAME_OK;
  1335. INTERLEAVE_EVEN:
  1337. state->checkNextFrameForProgressive = FALSE;
  1339. // Test if data should be re-interleaved.
  1340. // Look at cross difference of old vs. re-stitched. Only replace if better
  1342. if (obviousPatternFlag == FALSE || sceneChangeFlag == TRUE)
  1343. {
  1344. switch (state->impl_id)
  1345. {
  1346. #ifdef ALLOW_MMX_INVTELE
  1347. case INVTELE_IMPL_ID_MMX:
  1348. {
  1349. RestitchCheck_MMX(data + pels, prevData + pels, 
  1350. pels, lines - 2, pels, &sumOld, &sumNew);
  1351. }
  1352. break;
  1353. #endif
  1354. case INVTELE_IMPL_ID_C:
  1355. default:
  1356. {
  1357. pNew = (LONG32 *)(data);
  1358. pOld = (LONG32 *)(prevData);
  1359. for (i = 0; i < lines; i += 2)  //  only do the luma.
  1360. {
  1361. for(j = 0; j < ll; j++)
  1362. {
  1363. temp = (float)((pNew[j]&0xff00) - (pNew[j+ll]&0xff00));
  1364. sumOld += (temp*temp);
  1365. temp = (float)((pNew[j+ll]&0xff00) - (pOld[j]&0xff00));
  1366. sumNew += (temp*temp);
  1367. }
  1368. pOld+=2*ll;
  1369. pNew+=2*ll;
  1370. }
  1371. }
  1372. break;
  1373. }
  1375. if (sumNew > sumOld)
  1376. {
  1377. return INVTELE_RESULT_FRAME_OK;
  1378. }
  1379. }
  1381. state->interleaveEvenFlag = TRUE;
  1383. #ifdef CODEC_DEBUG_32PULLDOWN
  1384. fprintf(fp_log,"interleaving evenn");
  1385. #endif
  1387. // Re-interleave
  1388. pNew = ((LONG32 *)data);
  1389. pOld = ((LONG32 *)prevData);
  1391. for (k = 0; k < lines; k += 2)  //  only do the luma.
  1392. {
  1393. memcpy(pNew,pOld,sizeof(ULONG32)*ll); /* Flawfinder: ignore */
  1394. pOld+=2*ll;
  1395. pNew+=2*ll;
  1396. }
  1398. return INVTELE_RESULT_FRAME_OK;
  1400. DO_NOTHING:
  1402. // One final check in this case
  1403. // If we are here, we think the frame is progressive.
  1404. // If we think the previous frame was also progressive, then
  1405. // the odd and even SADs should be somewhat similar.  If not,
  1406. // we're in trouble.
  1408. if (state->checkNextFrameForProgressive)
  1409. {
  1410. if (state->ulPulldownActiveTimerProg < 10 &&
  1411. state->ulPulldownActiveTimerIntl > 90 &&
  1412. (sumEven > 8 * sumOdd || sumOdd > 8 * sumEven))
  1413. {
  1414. goto NO_PATTERN;
  1415. }
  1417. if (sceneChangeFlag == TRUE)
  1418. {
  1419. // Just return here because we want to be sure
  1420. // state->checkNextFrameForProgressive is TRUE
  1421. return INVTELE_RESULT_NO_PATTERN;
  1422. }
  1423. }
  1425. state->checkNextFrameForProgressive = TRUE;
  1427. return INVTELE_RESULT_FRAME_OK;
  1429. REMOVE_FRAME:
  1431. #ifdef CODEC_DEBUG_32PULLDOWN
  1432. fprintf(fp_log,"removing framen");
  1433. #endif
  1435. state->checkNextFrameForProgressive = FALSE;
  1437. return INVTELE_RESULT_DROP_FRAME;
  1439. TOO_EARLY:
  1441. state->checkNextFrameForProgressive = FALSE;
  1443. return INVTELE_RESULT_TOO_EARLY;
  1445. }
  1447. // Platform specific SSD functions
  1449. #ifdef ALLOW_MMX_INVTELE
  1451. void
  1452. SumSqaredFrameDiff_MMX(
  1453. unsigned char *frame, 
  1454. unsigned char *prev_frame,
  1455. int pels,
  1456. int lines,
  1457. int pitch,
  1458. float *ssd_odd,
  1459. float *ssd_even)
  1460. {
  1461. unsigned int res_odd[2];
  1462. unsigned int res_even[2];
  1464. float pel_avg;
  1466. const unsigned int mask[2] = {0x00FF00FF, 0x00FF00FF};
  1467. int line_shift;
  1468. int pels_div8;
  1470. pels_div8 = (pels >> 3); // round down
  1471. line_shift = ((pitch) - (pels & ~7));
  1473. __asm {
  1475. mov ecx, lines // ecx -> lines
  1476. shr ecx, 1 // ecx -> lines/2
  1478. mov esi, frame // esi -> current frame
  1479. mov edi, prev_frame // edi -> previous frame
  1481. movq mm5, [mask]
  1482. pxor mm6, mm6 // mm6 -> odd ssd
  1483. pxor mm7, mm7 // mm7 -> even ssd
  1485. ALIGN 16
  1486. line_loop:
  1487. mov ebx, pels_div8 // ebx -> pels/8 (rounded down)
  1488. ALIGN 16
  1489. pel_loop_even:
  1490. movq mm0,[esi]
  1491. movq mm1,[edi]
  1493. pand mm0, mm5
  1494. pand mm1, mm5
  1496. psubw mm0, mm1
  1497. pmaddwd mm0, mm0
  1498. paddd mm6, mm0
  1500. lea esi,[esi+8]
  1501. lea edi,[edi+8]
  1503. dec ebx
  1504. jnz pel_loop_even
  1506. add esi, line_shift; // move esi to the next line
  1507. add edi, line_shift; // move edi to the next line
  1509. mov ebx, pels_div8 // ebx -> pels/8 (rounded down)
  1510. ALIGN 16
  1511. pel_loop_odd:
  1512. movq mm0,[esi]
  1513. movq mm1,[edi]
  1515. pand mm0, mm5
  1516. pand mm1, mm5
  1518. psubw mm0, mm1
  1519. pmaddwd mm0, mm0
  1520. paddd mm7, mm0
  1522. lea esi,[esi+8]
  1523. lea edi,[edi+8]
  1525. dec ebx
  1526. jnz pel_loop_odd
  1528. add esi, line_shift; // move esi to the next line
  1529. add edi, line_shift; // move edi to the next line
  1531. dec ecx
  1532. jnz line_loop
  1534. movq res_odd, mm6
  1535. movq res_even, mm7
  1537. emms
  1538. }
  1540. // fill "even" result
  1541. pel_avg = (float)(res_even[0] + res_even[1]);
  1542. pel_avg /= (float)((pels*lines)>>2);
  1543. *ssd_even = pel_avg;
  1545. // fill "odd" result
  1546. pel_avg = (float)(res_odd[0] + res_odd[1]);
  1547. pel_avg /= (float)((pels*lines)>>2);
  1548. *ssd_odd = pel_avg;
  1550. }
  1552. void
  1553. RestitchCheck_MMX(
  1554. unsigned char *frame, 
  1555. unsigned char *prev_frame,
  1556. int pels,
  1557. int lines,
  1558. int pitch,
  1559. float *ssd_new,
  1560. float *ssd_old)
  1561. {
  1562. unsigned int res_new[2];
  1563. unsigned int res_old[2];
  1565. const unsigned int mask[2] = {0x00FF00FF, 0x00FF00FF};
  1566. int line_shift;
  1567. int pels_div8;
  1569. pels_div8 = (pels >> 3); // round down
  1570. line_shift = ((pitch << 1) - (pels & ~7));
  1572. __asm {
  1574. mov ecx, lines // ecx -> lines
  1575. shr ecx, 1 // ecx -> lines/2
  1577. mov esi, frame // esi -> current frame
  1578. mov edi, prev_frame // edi -> previous frame
  1580. mov edx, pitch // pitch
  1581. lea edi, [edi+edx] // edi -> previous frame + pitch
  1583. movq mm5, [mask]
  1584. pxor mm6, mm6 // mm6 -> odd ssd
  1585. pxor mm7, mm7 // mm7 -> even ssd
  1587. ALIGN 16
  1588. line_loop:
  1589. mov ebx, pels_div8 // ebx -> pels/8 (rounded down)
  1590. ALIGN 16
  1591. pel_loop:
  1592. movq mm0,[esi]
  1593. movq mm1,[esi + edx]
  1594. movq mm2,[edi]
  1596. pand mm0, mm5
  1597. pand mm1, mm5
  1598. pand mm2, mm5
  1600. psubw mm1, mm0
  1601. pmaddwd mm1, mm1
  1602. paddd mm6, mm1
  1604. psubw mm2, mm0
  1605. pmaddwd mm2, mm2
  1606. paddd mm7, mm2
  1608. lea esi, [esi+8]
  1609. lea edi, [edi+8]
  1611. dec ebx
  1612. jnz pel_loop
  1614. add esi, line_shift // move esi down 2 lines
  1615. add edi, line_shift // move edi down 2 lines
  1617. dec ecx
  1618. jnz line_loop
  1620. movq res_new, mm6
  1621. movq res_old, mm7
  1623. emms
  1624. }
  1626. // fill "new" result
  1627. *ssd_new = (float)(res_new[0] + res_new[1]);
  1629. // fill "old" result
  1630. *ssd_old = (float)(res_old[0] + res_old[1]);
  1632. }
  1634. #endif