PageRenderTime 66ms CodeModel.GetById 25ms RepoModel.GetById 0ms app.codeStats 0ms

/H264Dec/source/h264bsd_deblocking.c

http://github.com/mbebenita/Broadway
C | 2417 lines | 1698 code | 295 blank | 424 comment | 323 complexity | 7c34d152f359d1bdba24d54c513ce489 MD5 | raw file
Possible License(s): BSD-3-Clause 
    

  1. /*
    2. 

  2.  * Copyright (C) 2009 The Android Open Source Project
    3. 

  3.  *
    4. 

  4.  * Licensed under the Apache License, Version 2.0 (the "License");
    5. 

  5.  * you may not use this file except in compliance with the License.
    6. 

  6.  * You may obtain a copy of the License at
    7. 

  7.  *
    8. 

  8.  *      http://www.apache.org/licenses/LICENSE-2.0
    9. 

  9.  *
    10. 

  10.  * Unless required by applicable law or agreed to in writing, software
    11. 

  11.  * distributed under the License is distributed on an "AS IS" BASIS,
    12. 

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13. 

  13.  * See the License for the specific language governing permissions and
    14. 

  14.  * limitations under the License.
    15. 

  15.  */
    16. 

  16. 

  17. /*------------------------------------------------------------------------------
    18. 

    19. 

  19.     Table of contents
    20. 

    21. 

  21.      1. Include headers
    22. 

  22.      2. External compiler flags
    23. 

  23.      3. Module defines
    24. 

  24.      4. Local function prototypes
    25. 

  25.      5. Functions
    26. 

  26.           h264bsdFilterPicture
    27. 

  27.           FilterVerLumaEdge
    28. 

  28.           FilterHorLumaEdge
    29. 

  29.           FilterHorLuma
    30. 

  30.           FilterVerChromaEdge
    31. 

  31.           FilterHorChromaEdge
    32. 

  32.           FilterHorChroma
    33. 

  33.           InnerBoundaryStrength
    34. 

  34.           EdgeBoundaryStrength
    35. 

  35.           GetBoundaryStrengths
    36. 

  36.           IsSliceBoundaryOnLeft
    37. 

  37.           IsSliceBoundaryOnTop
    38. 

  38.           GetMbFilteringFlags
    39. 

  39.           GetLumaEdgeThresholds
    40. 

  40.           GetChromaEdgeThresholds
    41. 

  41.           FilterLuma
    42. 

  42.           FilterChroma
    43. 

    44. 

  44. ------------------------------------------------------------------------------*/
    45. 

  45. 

  46. /*------------------------------------------------------------------------------
    47. 

  47.     1. Include headers
    48. 

  48. ------------------------------------------------------------------------------*/
    49. 

  49. 

  50. #include "basetype.h"
    51. 

  51. #include "h264bsd_util.h"
    52. 

  52. #include "h264bsd_macroblock_layer.h"
    53. 

  53. #include "h264bsd_deblocking.h"
    54. 

  54. #include "h264bsd_dpb.h"
    55. 

  55. 

  56. #ifdef H264DEC_OMXDL
    57. 

  57. #include "omxtypes.h"
    58. 

  58. #include "omxVC.h"
    59. 

  59. #include "armVC.h"
    60. 

  60. #endif /* H264DEC_OMXDL */
    61. 

  61. 

  62. /*------------------------------------------------------------------------------
    63. 

  63.     2. External compiler flags
    64. 

  64. --------------------------------------------------------------------------------
    65. 

    66. 

  66. --------------------------------------------------------------------------------
    67. 

  67.     3. Module defines
    68. 

  68. ------------------------------------------------------------------------------*/
    69. 

  69. 

  70. /* Switch off the following Lint messages for this file:
    71. 

  71.  * Info 701: Shift left of signed quantity (int)
    72. 

  72.  * Info 702: Shift right of signed quantity (int)
    73. 

  73.  */
    74. 

  74. /*lint -e701 -e702 */
    75. 

  75. 

  76. /* array of alpha values, from the standard */
    77. 

  77. static const u8 alphas[52] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,5,6,7,8,9,10,
    78. 

  78.     12,13,15,17,20,22,25,28,32,36,40,45,50,56,63,71,80,90,101,113,127,144,162,
    79. 

  79.     182,203,226,255,255};
    80. 

  80. 

  81. /* array of beta values, from the standard */
    82. 

  82. static const u8 betas[52] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,3,3,3,3,4,4,
    83. 

  83.     4,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18};
    84. 

  84. 

  85. 

  86. 

  87. #ifndef H264DEC_OMXDL
    88. 

  88. /* array of tc0 values, from the standard, each triplet corresponds to a
    89. 

  89.  * column in the table. Indexing goes as tc0[indexA][bS-1] */
    90. 

  90. static const u8 tc0[52][3] = {
    91. 

  91.     {0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},
    92. 

  92.     {0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},
    93. 

  93.     {0,0,0},{0,0,1},{0,0,1},{0,0,1},{0,0,1},{0,1,1},{0,1,1},{1,1,1},
    94. 

  94.     {1,1,1},{1,1,1},{1,1,1},{1,1,2},{1,1,2},{1,1,2},{1,1,2},{1,2,3},
    95. 

  95.     {1,2,3},{2,2,3},{2,2,4},{2,3,4},{2,3,4},{3,3,5},{3,4,6},{3,4,6},
    96. 

  96.     {4,5,7},{4,5,8},{4,6,9},{5,7,10},{6,8,11},{6,8,13},{7,10,14},{8,11,16},
    97. 

  97.     {9,12,18},{10,13,20},{11,15,23},{13,17,25}
    98. 

  98. };
    99. 

  99. #else
    100. 

  100. /* array of tc0 values, from the standard, each triplet corresponds to a
    101. 

  101.  * column in the table. Indexing goes as tc0[indexA][bS] */
    102. 

  102. static const u8 tc0[52][5] = {
    103. 

  103.     {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0},
    104. 

  104.     {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0},
    105. 

  105.     {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0},
    106. 

  106.     {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0},
    107. 

  107.     {0, 0, 0, 0, 0}, {0, 0, 0, 1, 0}, {0, 0, 0, 1, 0}, {0, 0, 0, 1, 0},
    108. 

  108.     {0, 0, 0, 1, 0}, {0, 0, 1, 1, 0}, {0, 0, 1, 1, 0}, {0, 1, 1, 1, 0},
    109. 

  109.     {0, 1, 1, 1, 0}, {0, 1, 1, 1, 0}, {0, 1, 1, 1, 0}, {0, 1, 1, 2, 0},
    110. 

  110.     {0, 1, 1, 2, 0}, {0, 1, 1, 2, 0}, {0, 1, 1, 2, 0}, {0, 1, 2, 3, 0},
    111. 

  111.     {0, 1, 2, 3, 0}, {0, 2, 2, 3, 0}, {0, 2, 2, 4, 0}, {0, 2, 3, 4, 0},
    112. 

  112.     {0, 2, 3, 4, 0}, {0, 3, 3, 5, 0}, {0, 3, 4, 6, 0}, {0, 3, 4, 6, 0},
    113. 

  113.     {0, 4, 5, 7, 0}, {0, 4, 5, 8, 0}, {0, 4, 6, 9, 0}, {0, 5, 7, 10, 0},
    114. 

  114.     {0, 6, 8, 11, 0}, {0, 6, 8, 13, 0}, {0, 7, 10, 14, 0},
    115. 

  115.     {0, 8, 11, 16, 0}, {0, 9, 12, 18, 0}, {0, 10, 13, 20, 0},
    116. 

  116.     {0, 11, 15, 23, 0}, {0, 13, 17, 25, 0}
    117. 

  117. };
    118. 

  118. #endif
    119. 

  119. 

  120. 

  121. #ifndef H264DEC_OMXDL
    122. 

  122. /* mapping of raster scan block index to 4x4 block index */
    123. 

  123. static const u32 mb4x4Index[16] =
    124. 

  124.     {0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15};
    125. 

  125. 

  126. typedef struct {
    127. 

  127.     const u8 *tc0;
    128. 

  128.     u32 alpha;
    129. 

  129.     u32 beta;
    130. 

  130. } edgeThreshold_t;
    131. 

  131. 

  132. typedef struct {
    133. 

  133.     u32 top;
    134. 

  134.     u32 left;
    135. 

  135. } bS_t;
    136. 

  136. 

  137. enum { TOP = 0, LEFT = 1, INNER = 2 };
    138. 

  138. #endif /* H264DEC_OMXDL */
    139. 

  139. 

  140. #define FILTER_LEFT_EDGE    0x04
    141. 

  141. #define FILTER_TOP_EDGE     0x02
    142. 

  142. #define FILTER_INNER_EDGE   0x01
    143. 

  143. 

  144. 

  145. /* clipping table defined in intra_prediction.c */
    146. 

  146. extern const u8 h264bsdClip[];
    147. 

  147. 

  148. /*------------------------------------------------------------------------------
    149. 

  149.     4. Local function prototypes
    150. 

  150. ------------------------------------------------------------------------------*/
    151. 

  151. 

  152. static u32 InnerBoundaryStrength(mbStorage_t *mb1, u32 i1, u32 i2);
    153. 

  153. 

  154. #ifndef H264DEC_OMXDL
    155. 

  155. static u32 EdgeBoundaryStrength(mbStorage_t *mb1, mbStorage_t *mb2,
    156. 

  156.     u32 i1, u32 i2);
    157. 

  157. #else
    158. 

  158. static u32 InnerBoundaryStrength2(mbStorage_t *mb1, u32 i1, u32 i2);
    159. 

  159. static u32 EdgeBoundaryStrengthLeft(mbStorage_t *mb1, mbStorage_t *mb2);
    160. 

  160. static u32 EdgeBoundaryStrengthTop(mbStorage_t *mb1, mbStorage_t *mb2);
    161. 

  161. #endif
    162. 

  162. 

  163. static u32 IsSliceBoundaryOnLeft(mbStorage_t *mb);
    164. 

  164. 

  165. static u32 IsSliceBoundaryOnTop(mbStorage_t *mb);
    166. 

  166. 

  167. static u32 GetMbFilteringFlags(mbStorage_t *mb);
    168. 

  168. 

  169. #ifndef H264DEC_OMXDL
    170. 

  170. 

  171. static u32 GetBoundaryStrengths(mbStorage_t *mb, bS_t *bs, u32 flags);
    172. 

  172. 

  173. static void FilterLuma(u8 *data, bS_t *bS, edgeThreshold_t *thresholds,
    174. 

  174.         u32 imageWidth);
    175. 

  175. 

  176. static void FilterChroma(u8 *cb, u8 *cr, bS_t *bS, edgeThreshold_t *thresholds,
    177. 

  177.         u32 imageWidth);
    178. 

  178. 

  179. static void FilterVerLumaEdge( u8 *data, u32 bS, edgeThreshold_t *thresholds,
    180. 

  180.         u32 imageWidth);
    181. 

  181. static void FilterHorLumaEdge( u8 *data, u32 bS, edgeThreshold_t *thresholds,
    182. 

  182.         i32 imageWidth);
    183. 

  183. static void FilterHorLuma( u8 *data, u32 bS, edgeThreshold_t *thresholds,
    184. 

  184.         i32 imageWidth);
    185. 

  185. 

  186. static void FilterVerChromaEdge( u8 *data, u32 bS, edgeThreshold_t *thresholds,
    187. 

  187.   u32 imageWidth);
    188. 

  188. static void FilterHorChromaEdge( u8 *data, u32 bS, edgeThreshold_t *thresholds,
    189. 

  189.   i32 imageWidth);
    190. 

  190. static void FilterHorChroma( u8 *data, u32 bS, edgeThreshold_t *thresholds,
    191. 

  191.   i32 imageWidth);
    192. 

  192. 

  193. static void GetLumaEdgeThresholds(
    194. 

  194.   edgeThreshold_t *thresholds,
    195. 

  195.   mbStorage_t *mb,
    196. 

  196.   u32 filteringFlags);
    197. 

  197. 

  198. static void GetChromaEdgeThresholds(
    199. 

  199.   edgeThreshold_t *thresholds,
    200. 

  200.   mbStorage_t *mb,
    201. 

  201.   u32 filteringFlags,
    202. 

  202.   i32 chromaQpIndexOffset);
    203. 

  203. 

  204. #else /* H264DEC_OMXDL */
    205. 

  205. 

  206. static u32 GetBoundaryStrengths(mbStorage_t *mb, u8 (*bs)[16], u32 flags);
    207. 

  207. 

  208. static void GetLumaEdgeThresholds(
    209. 

  209.     mbStorage_t *mb,
    210. 

  210.     u8 (*alpha)[2],
    211. 

  211.     u8 (*beta)[2],
    212. 

  212.     u8 (*threshold)[16],
    213. 

  213.     u8 (*bs)[16],
    214. 

  214.     u32 filteringFlags );
    215. 

  215. 

  216. static void GetChromaEdgeThresholds(
    217. 

  217.     mbStorage_t *mb,
    218. 

  218.     u8 (*alpha)[2],
    219. 

  219.     u8 (*beta)[2],
    220. 

  220.     u8 (*threshold)[8],
    221. 

  221.     u8 (*bs)[16],
    222. 

  222.     u32 filteringFlags,
    223. 

  223.     i32 chromaQpIndexOffset);
    224. 

  224. 

  225. #endif /* H264DEC_OMXDL */
    226. 

  226. 

  227. /*------------------------------------------------------------------------------
    228. 

    229. 

  229.     Function: IsSliceBoundaryOnLeft
    230. 

    231. 

  231.         Functional description:
    232. 

  232.             Function to determine if there is a slice boundary on the left side
    233. 

  233.             of a macroblock.
    234. 

    235. 

  235. ------------------------------------------------------------------------------*/
    236. 

  236. u32 IsSliceBoundaryOnLeft(mbStorage_t *mb)
    237. 

  237. {
    238. 

  238. 

  239. /* Variables */
    240. 

  240. 

  241. /* Code */
    242. 

  242. 

  243.     ASSERT(mb && mb->mbA);
    244. 

  244. 

  245.     if (mb->sliceId != mb->mbA->sliceId)
    246. 

  246.         return(HANTRO_TRUE);
    247. 

  247.     else
    248. 

  248.         return(HANTRO_FALSE);
    249. 

  249. 

  250. }
    251. 

  251. 

  252. /*------------------------------------------------------------------------------
    253. 

    254. 

  254.     Function: IsSliceBoundaryOnTop
    255. 

    256. 

  256.         Functional description:
    257. 

  257.             Function to determine if there is a slice boundary above the
    258. 

  258.             current macroblock.
    259. 

    260. 

  260. ------------------------------------------------------------------------------*/
    261. 

  261. u32 IsSliceBoundaryOnTop(mbStorage_t *mb)
    262. 

  262. {
    263. 

  263. 

  264. /* Variables */
    265. 

  265. 

  266. /* Code */
    267. 

  267. 

  268.     ASSERT(mb && mb->mbB);
    269. 

  269. 

  270.     if (mb->sliceId != mb->mbB->sliceId)
    271. 

  271.         return(HANTRO_TRUE);
    272. 

  272.     else
    273. 

  273.         return(HANTRO_FALSE);
    274. 

  274. 

  275. }
    276. 

  276. 

  277. /*------------------------------------------------------------------------------
    278. 

    279. 

  279.     Function: GetMbFilteringFlags
    280. 

    281. 

  281.         Functional description:
    282. 

  282.           Function to determine which edges of a macroblock has to be
    283. 

  283.           filtered. Output is a bit-wise OR of FILTER_LEFT_EDGE,
    284. 

  284.           FILTER_TOP_EDGE and FILTER_INNER_EDGE, depending on which edges
    285. 

  285.           shall be filtered.
    286. 

    287. 

  287. ------------------------------------------------------------------------------*/
    288. 

  288. u32 GetMbFilteringFlags(mbStorage_t *mb)
    289. 

  289. {
    290. 

  290. 

  291. /* Variables */
    292. 

  292. 

  293.     u32 flags = 0;
    294. 

  294. 

  295. /* Code */
    296. 

  296. 

  297.     ASSERT(mb);
    298. 

  298. 

  299.     /* nothing will be filtered if disableDeblockingFilterIdc == 1 */
    300. 

  300.     if (mb->disableDeblockingFilterIdc != 1)
    301. 

  301.     {
    302. 

  302.         flags |= FILTER_INNER_EDGE;
    303. 

  303. 

  304.         /* filterLeftMbEdgeFlag, left mb is MB_A */
    305. 

  305.         if (mb->mbA &&
    306. 

  306.             ((mb->disableDeblockingFilterIdc != 2) ||
    307. 

  307.              !IsSliceBoundaryOnLeft(mb)))
    308. 

  308.             flags |= FILTER_LEFT_EDGE;
    309. 

  309. 

  310.         /* filterTopMbEdgeFlag */
    311. 

  311.         if (mb->mbB &&
    312. 

  312.             ((mb->disableDeblockingFilterIdc != 2) ||
    313. 

  313.              !IsSliceBoundaryOnTop(mb)))
    314. 

  314.             flags |= FILTER_TOP_EDGE;
    315. 

  315.     }
    316. 

  316. 

  317.     return(flags);
    318. 

  318. 

  319. }
    320. 

  320. 

  321. /*------------------------------------------------------------------------------
    322. 

    323. 

  323.     Function: InnerBoundaryStrength
    324. 

    325. 

  325.         Functional description:
    326. 

  326.             Function to calculate boundary strength value bs for an inner
    327. 

  327.             edge of a macroblock. Macroblock type is checked before this is
    328. 

  328.             called -> no intra mb condition here.
    329. 

    330. 

  330. ------------------------------------------------------------------------------*/
    331. 

  331. u32 InnerBoundaryStrength(mbStorage_t *mb1, u32 ind1, u32 ind2)
    332. 

  332. {
    333. 

  333.     i32 tmp1, tmp2;
    334. 

  334.     i32 mv1, mv2, mv3, mv4;
    335. 

  335. 

  336.     tmp1 = mb1->totalCoeff[ind1];
    337. 

  337.     tmp2 = mb1->totalCoeff[ind2];
    338. 

  338.     mv1 = mb1->mv[ind1].hor;
    339. 

  339.     mv2 = mb1->mv[ind2].hor;
    340. 

  340.     mv3 = mb1->mv[ind1].ver;
    341. 

  341.     mv4 = mb1->mv[ind2].ver;
    342. 

  342. 

  343.     if (tmp1 || tmp2)
    344. 

  344.     {
    345. 

  345.         return 2;
    346. 

  346.     }
    347. 

  347.     else if ( (ABS(mv1 - mv2) >= 4) || (ABS(mv3 - mv4) >= 4) ||
    348. 

  348.               (mb1->refAddr[ind1 >> 2] != mb1->refAddr[ind2 >> 2]) )
    349. 

  349.     {
    350. 

  350.         return 1;
    351. 

  351.     }
    352. 

  352.     else
    353. 

  353.         return 0;
    354. 

  354. }
    355. 

  355. 

  356. /*------------------------------------------------------------------------------
    357. 

    358. 

  358.     Function: InnerBoundaryStrength2
    359. 

    360. 

  360.         Functional description:
    361. 

  361.             Function to calculate boundary strength value bs for an inner
    362. 

  362.             edge of a macroblock. The function is the same as
    363. 

  363.             InnerBoundaryStrength but without checking totalCoeff.
    364. 

    365. 

  365. ------------------------------------------------------------------------------*/
    366. 

  366. u32 InnerBoundaryStrength2(mbStorage_t *mb1, u32 ind1, u32 ind2)
    367. 

  367. {
    368. 

  368.     i32 tmp1, tmp2, tmp3, tmp4;
    369. 

  369. 

  370.     tmp1 = mb1->mv[ind1].hor;
    371. 

  371.     tmp2 = mb1->mv[ind2].hor;
    372. 

  372.     tmp3 = mb1->mv[ind1].ver;
    373. 

  373.     tmp4 = mb1->mv[ind2].ver;
    374. 

  374. 

  375.     if ( (ABS(tmp1 - tmp2) >= 4) || (ABS(tmp3 - tmp4) >= 4) ||
    376. 

  376.          (mb1->refAddr[ind1 >> 2] != mb1->refAddr[ind2 >> 2]))
    377. 

  377.     {
    378. 

  378.         return 1;
    379. 

  379.     }
    380. 

  380.     else
    381. 

  381.         return 0;
    382. 

  382. }
    383. 

  383. #ifndef H264DEC_OMXDL
    384. 

  384. /*------------------------------------------------------------------------------
    385. 

    386. 

  386.     Function: EdgeBoundaryStrength
    387. 

    388. 

  388.         Functional description:
    389. 

  389.             Function to calculate boundary strength value bs for left- or
    390. 

  390.             top-most edge of a macroblock. Macroblock types are checked
    391. 

  391.             before this is called -> no intra mb conditions here.
    392. 

    393. 

  393. ------------------------------------------------------------------------------*/
    394. 

  394. u32 EdgeBoundaryStrength(mbStorage_t *mb1, mbStorage_t *mb2,
    395. 

  395.     u32 ind1, u32 ind2)
    396. 

  396. {
    397. 

  397. 

  398.     if (mb1->totalCoeff[ind1] || mb2->totalCoeff[ind2])
    399. 

  399.     {
    400. 

  400.         return 2;
    401. 

  401.     }
    402. 

  402.     else if ((mb1->refAddr[ind1 >> 2] != mb2->refAddr[ind2 >> 2]) ||
    403. 

  403.              (ABS(mb1->mv[ind1].hor - mb2->mv[ind2].hor) >= 4) ||
    404. 

  404.              (ABS(mb1->mv[ind1].ver - mb2->mv[ind2].ver) >= 4))
    405. 

  405.     {
    406. 

  406.         return 1;
    407. 

  407.     }
    408. 

  408.     else
    409. 

  409.         return 0;
    410. 

  410. }
    411. 

  411. 

  412. #else /* H264DEC_OMXDL */
    413. 

  413. 

  414. /*------------------------------------------------------------------------------
    415. 

    416. 

  416.     Function: EdgeBoundaryStrengthTop
    417. 

    418. 

  418.         Functional description:
    419. 

  419.             Function to calculate boundary strength value bs for
    420. 

  420.             top-most edge of a macroblock. Macroblock types are checked
    421. 

  421.             before this is called -> no intra mb conditions here.
    422. 

    423. 

  423. ------------------------------------------------------------------------------*/
    424. 

  424. u32 EdgeBoundaryStrengthTop(mbStorage_t *mb1, mbStorage_t *mb2)
    425. 

  425. {
    426. 

  426.     u32 topBs = 0;
    427. 

  427.     u32 tmp1, tmp2, tmp3, tmp4;
    428. 

  428. 

  429.     tmp1 = mb1->totalCoeff[0];
    430. 

  430.     tmp2 = mb2->totalCoeff[10];
    431. 

  431.     tmp3 = mb1->totalCoeff[1];
    432. 

  432.     tmp4 = mb2->totalCoeff[11];
    433. 

  433.     if (tmp1 || tmp2)
    434. 

  434.     {
    435. 

  435.         topBs = 2<<0;
    436. 

  436.     }
    437. 

  437.     else if ((ABS(mb1->mv[0].hor - mb2->mv[10].hor) >= 4) ||
    438. 

  438.              (ABS(mb1->mv[0].ver - mb2->mv[10].ver) >= 4) ||
    439. 

  439.              (mb1->refAddr[0] != mb2->refAddr[10 >> 2]))
    440. 

  440.     {
    441. 

  441.         topBs = 1<<0;
    442. 

  442.     }
    443. 

  443.     tmp1 = mb1->totalCoeff[4];
    444. 

  444.     tmp2 = mb2->totalCoeff[14];
    445. 

  445.     if (tmp3 || tmp4)
    446. 

  446.     {
    447. 

  447.         topBs += 2<<8;
    448. 

  448.     }
    449. 

  449.     else if ((ABS(mb1->mv[1].hor - mb2->mv[11].hor) >= 4) ||
    450. 

  450.              (ABS(mb1->mv[1].ver - mb2->mv[11].ver) >= 4) ||
    451. 

  451.              (mb1->refAddr[0] != mb2->refAddr[11 >> 2]))
    452. 

  452.     {
    453. 

  453.         topBs += 1<<8;
    454. 

  454.     }
    455. 

  455.     tmp3 = mb1->totalCoeff[5];
    456. 

  456.     tmp4 = mb2->totalCoeff[15];
    457. 

  457.     if (tmp1 || tmp2)
    458. 

  458.     {
    459. 

  459.         topBs += 2<<16;
    460. 

  460.     }
    461. 

  461.     else if ((ABS(mb1->mv[4].hor - mb2->mv[14].hor) >= 4) ||
    462. 

  462.              (ABS(mb1->mv[4].ver - mb2->mv[14].ver) >= 4) ||
    463. 

  463.              (mb1->refAddr[4 >> 2] != mb2->refAddr[14 >> 2]))
    464. 

  464.     {
    465. 

  465.         topBs += 1<<16;
    466. 

  466.     }
    467. 

  467.     if (tmp3 || tmp4)
    468. 

  468.     {
    469. 

  469.         topBs += 2<<24;
    470. 

  470.     }
    471. 

  471.     else if ((ABS(mb1->mv[5].hor - mb2->mv[15].hor) >= 4) ||
    472. 

  472.              (ABS(mb1->mv[5].ver - mb2->mv[15].ver) >= 4) ||
    473. 

  473.              (mb1->refAddr[5 >> 2] != mb2->refAddr[15 >> 2]))
    474. 

  474.     {
    475. 

  475.         topBs += 1<<24;
    476. 

  476.     }
    477. 

  477. 

  478.     return topBs;
    479. 

  479. }
    480. 

  480. 

  481. /*------------------------------------------------------------------------------
    482. 

    483. 

  483.     Function: EdgeBoundaryStrengthLeft
    484. 

    485. 

  485.         Functional description:
    486. 

  486.             Function to calculate boundary strength value bs for left-
    487. 

  487.             edge of a macroblock. Macroblock types are checked
    488. 

  488.             before this is called -> no intra mb conditions here.
    489. 

    490. 

  490. ------------------------------------------------------------------------------*/
    491. 

  491. u32 EdgeBoundaryStrengthLeft(mbStorage_t *mb1, mbStorage_t *mb2)
    492. 

  492. {
    493. 

  493.     u32 leftBs = 0;
    494. 

  494.     u32 tmp1, tmp2, tmp3, tmp4;
    495. 

  495. 

  496.     tmp1 = mb1->totalCoeff[0];
    497. 

  497.     tmp2 = mb2->totalCoeff[5];
    498. 

  498.     tmp3 = mb1->totalCoeff[2];
    499. 

  499.     tmp4 = mb2->totalCoeff[7];
    500. 

  500. 

  501.     if (tmp1 || tmp2)
    502. 

  502.     {
    503. 

  503.         leftBs = 2<<0;
    504. 

  504.     }
    505. 

  505.     else if ((ABS(mb1->mv[0].hor - mb2->mv[5].hor) >= 4) ||
    506. 

  506.              (ABS(mb1->mv[0].ver - mb2->mv[5].ver) >= 4) ||
    507. 

  507.              (mb1->refAddr[0] != mb2->refAddr[5 >> 2]))
    508. 

  508.     {
    509. 

  509.         leftBs = 1<<0;
    510. 

  510.     }
    511. 

  511.     tmp1 = mb1->totalCoeff[8];
    512. 

  512.     tmp2 = mb2->totalCoeff[13];
    513. 

  513.     if (tmp3 || tmp4)
    514. 

  514.     {
    515. 

  515.         leftBs += 2<<8;
    516. 

  516.     }
    517. 

  517.     else if ((ABS(mb1->mv[2].hor - mb2->mv[7].hor) >= 4) ||
    518. 

  518.              (ABS(mb1->mv[2].ver - mb2->mv[7].ver) >= 4) ||
    519. 

  519.              (mb1->refAddr[0] != mb2->refAddr[7 >> 2]))
    520. 

  520.     {
    521. 

  521.         leftBs += 1<<8;
    522. 

  522.     }
    523. 

  523.     tmp3 = mb1->totalCoeff[10];
    524. 

  524.     tmp4 = mb2->totalCoeff[15];
    525. 

  525.     if (tmp1 || tmp2)
    526. 

  526.     {
    527. 

  527.         leftBs += 2<<16;
    528. 

  528.     }
    529. 

  529.     else if ((ABS(mb1->mv[8].hor - mb2->mv[13].hor) >= 4) ||
    530. 

  530.              (ABS(mb1->mv[8].ver - mb2->mv[13].ver) >= 4) ||
    531. 

  531.              (mb1->refAddr[8 >> 2] != mb2->refAddr[13 >> 2]))
    532. 

  532.     {
    533. 

  533.         leftBs += 1<<16;
    534. 

  534.     }
    535. 

  535.     if (tmp3 || tmp4)
    536. 

  536.     {
    537. 

  537.         leftBs += 2<<24;
    538. 

  538.     }
    539. 

  539.     else if ((ABS(mb1->mv[10].hor - mb2->mv[15].hor) >= 4) ||
    540. 

  540.              (ABS(mb1->mv[10].ver - mb2->mv[15].ver) >= 4) ||
    541. 

  541.              (mb1->refAddr[10 >> 2] != mb2->refAddr[15 >> 2]))
    542. 

  542.     {
    543. 

  543.         leftBs += 1<<24;
    544. 

  544.     }
    545. 

  545. 

  546.     return leftBs;
    547. 

  547. }
    548. 

  548. #endif /* H264DEC_OMXDL */
    549. 

  549. /*------------------------------------------------------------------------------
    550. 

    551. 

  551.     Function: h264bsdFilterPicture
    552. 

    553. 

  553.         Functional description:
    554. 

  554.           Perform deblocking filtering for a picture. Filter does not copy
    555. 

  555.           the original picture anywhere but filtering is performed directly
    556. 

  556.           on the original image. Parameters controlling the filtering process
    557. 

  557.           are computed based on information in macroblock structures of the
    558. 

  558.           filtered macroblock, macroblock above and macroblock on the left of
    559. 

  559.           the filtered one.
    560. 

    561. 

  561.         Inputs:
    562. 

  562.           image         pointer to image to be filtered
    563. 

  563.           mb            pointer to macroblock data structure of the top-left
    564. 

  564.                         macroblock of the picture
    565. 

    566. 

  566.         Outputs:
    567. 

  567.           image         filtered image stored here
    568. 

    569. 

  569.         Returns:
    570. 

  570.           none
    571. 

    572. 

  572. ------------------------------------------------------------------------------*/
    573. 

  573. #ifndef H264DEC_OMXDL
    574. 

  574. void h264bsdFilterPicture(
    575. 

  575.   image_t *image,
    576. 

  576.   mbStorage_t *mb)
    577. 

  577. {
    578. 

  578. 

  579. /* Variables */
    580. 

  580. 

  581.     u32 flags;
    582. 

  582.     u32 picSizeInMbs, mbRow, mbCol;
    583. 

  583.     u32 picWidthInMbs;
    584. 

  584.     u8 *data;
    585. 

  585.     mbStorage_t *pMb;
    586. 

  586.     bS_t bS[16];
    587. 

  587.     edgeThreshold_t thresholds[3];
    588. 

  588. 

  589. /* Code */
    590. 

  590. 

  591.     ASSERT(image);
    592. 

  592.     ASSERT(mb);
    593. 

  593.     ASSERT(image->data);
    594. 

  594.     ASSERT(image->width);
    595. 

  595.     ASSERT(image->height);
    596. 

  596. 

  597.     picWidthInMbs = image->width;
    598. 

  598.     data = image->data;
    599. 

  599.     picSizeInMbs = picWidthInMbs * image->height;
    600. 

  600. 

  601.     pMb = mb;
    602. 

  602. 

  603.     for (mbRow = 0, mbCol = 0; mbRow < image->height; pMb++)
    604. 

  604.     {
    605. 

  605.         flags = GetMbFilteringFlags(pMb);
    606. 

  606. 

  607.         if (flags)
    608. 

  608.         {
    609. 

  609.             /* GetBoundaryStrengths function returns non-zero value if any of
    610. 

  610.              * the bS values for the macroblock being processed was non-zero */
    611. 

  611.             if (GetBoundaryStrengths(pMb, bS, flags))
    612. 

  612.             {
    613. 

  613.                 /* luma */
    614. 

  614.                 GetLumaEdgeThresholds(thresholds, pMb, flags);
    615. 

  615.                 data = image->data + mbRow * picWidthInMbs * 256 + mbCol * 16;
    616. 

  616. 

  617.                 FilterLuma((u8*)data, bS, thresholds, picWidthInMbs*16);
    618. 

  618. 

  619.                 /* chroma */
    620. 

  620.                 GetChromaEdgeThresholds(thresholds, pMb, flags,
    621. 

  621.                     pMb->chromaQpIndexOffset);
    622. 

  622.                 data = image->data + picSizeInMbs * 256 +
    623. 

  623.                     mbRow * picWidthInMbs * 64 + mbCol * 8;
    624. 

  624. 

  625.                 FilterChroma((u8*)data, data + 64*picSizeInMbs, bS,
    626. 

  626.                         thresholds, picWidthInMbs*8);
    627. 

  627. 

  628.             }
    629. 

  629.         }
    630. 

  630. 

  631.         mbCol++;
    632. 

  632.         if (mbCol == picWidthInMbs)
    633. 

  633.         {
    634. 

  634.             mbCol = 0;
    635. 

  635.             mbRow++;
    636. 

  636.         }
    637. 

  637.     }
    638. 

  638. 

  639. }
    640. 

  640. 

  641. /*------------------------------------------------------------------------------
    642. 

    643. 

  643.     Function: FilterVerLumaEdge
    644. 

    645. 

  645.         Functional description:
    646. 

  646.             Filter one vertical 4-pixel luma edge.
    647. 

    648. 

  648. ------------------------------------------------------------------------------*/
    649. 

  649. void FilterVerLumaEdge(
    650. 

  650.   u8 *data,
    651. 

  651.   u32 bS,
    652. 

  652.   edgeThreshold_t *thresholds,
    653. 

  653.   u32 imageWidth)
    654. 

  654. {
    655. 

  655. 

  656. /* Variables */
    657. 

  657. 

  658.     i32 delta, tc, tmp;
    659. 

  659.     u32 i;
    660. 

  660.     u8 p0, q0, p1, q1, p2, q2;
    661. 

  661.     u32 tmpFlag;
    662. 

  662.     const u8 *clp = h264bsdClip + 512;
    663. 

  663. 

  664. /* Code */
    665. 

  665. 

  666.     ASSERT(data);
    667. 

  667.     ASSERT(bS && bS <= 4);
    668. 

  668.     ASSERT(thresholds);
    669. 

  669. 

  670.     if (bS < 4)
    671. 

  671.     {
    672. 

  672.         tc = thresholds->tc0[bS-1];
    673. 

  673.         tmp = tc;
    674. 

  674.         for (i = 4; i; i--, data += imageWidth)
    675. 

  675.         {
    676. 

  676.             p1 = data[-2]; p0 = data[-1];
    677. 

  677.             q0 = data[0]; q1 = data[1];
    678. 

  678.             if ( ((unsigned)ABS(p0-q0) < thresholds->alpha) &&
    679. 

  679.                  ((unsigned)ABS(p1-p0) < thresholds->beta)  &&
    680. 

  680.                  ((unsigned)ABS(q1-q0) < thresholds->beta) )
    681. 

  681.             {
    682. 

  682.                 p2 = data[-3];
    683. 

  683.                 q2 = data[2];
    684. 

  684. 

  685.                 if ((unsigned)ABS(p2-p0) < thresholds->beta)
    686. 

  686.                 {
    687. 

  687.                     data[-2] = (u8)(p1 + CLIP3(-tc,tc,
    688. 

  688.                         (p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1));
    689. 

  689.                     tmp++;
    690. 

  690.                 }
    691. 

  691. 

  692.                 if ((unsigned)ABS(q2-q0) < thresholds->beta)
    693. 

  693.                 {
    694. 

  694.                     data[1] = (u8)(q1 + CLIP3(-tc,tc,
    695. 

  695.                         (q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1));
    696. 

  696.                     tmp++;
    697. 

  697.                 }
    698. 

  698. 

  699.                 delta = CLIP3(-tmp, tmp, ((((q0 - p0) << 2) +
    700. 

  700.                           (p1 - q1) + 4) >> 3));
    701. 

  701. 

  702.                 p0 = clp[p0 + delta];
    703. 

  703.                 q0 = clp[q0 - delta];
    704. 

  704.                 tmp = tc;
    705. 

  705.                 data[-1] = p0;
    706. 

  706.                 data[ 0] = q0;
    707. 

  707.             }
    708. 

  708.         }
    709. 

  709.     }
    710. 

  710.     else
    711. 

  711.     {
    712. 

  712.         for (i = 4; i; i--, data += imageWidth)
    713. 

  713.         {
    714. 

  714.             p1 = data[-2]; p0 = data[-1];
    715. 

  715.             q0 = data[0]; q1 = data[1];
    716. 

  716.             if ( ((unsigned)ABS(p0-q0) < thresholds->alpha) &&
    717. 

  717.                  ((unsigned)ABS(p1-p0) < thresholds->beta)  &&
    718. 

  718.                  ((unsigned)ABS(q1-q0) < thresholds->beta) )
    719. 

  719.             {
    720. 

  720.                 tmpFlag =
    721. 

  721.                     ((unsigned)ABS(p0-q0) < ((thresholds->alpha >> 2) +2)) ?
    722. 

  722.                         HANTRO_TRUE : HANTRO_FALSE;
    723. 

  723. 

  724.                 p2 = data[-3];
    725. 

  725.                 q2 = data[2];
    726. 

  726. 

  727.                 if (tmpFlag && (unsigned)ABS(p2-p0) < thresholds->beta)
    728. 

  728.                 {
    729. 

  729.                     tmp = p1 + p0 + q0;
    730. 

  730.                     data[-1] = (u8)((p2 + 2 * tmp + q1 + 4) >> 3);
    731. 

  731.                     data[-2] = (u8)((p2 + tmp + 2) >> 2);
    732. 

  732.                     data[-3] = (u8)((2 * data[-4] + 3 * p2 + tmp + 4) >> 3);
    733. 

  733.                 }
    734. 

  734.                 else
    735. 

  735.                     data[-1] = (2 * p1 + p0 + q1 + 2) >> 2;
    736. 

  736. 

  737.                 if (tmpFlag && (unsigned)ABS(q2-q0) < thresholds->beta)
    738. 

  738.                 {
    739. 

  739.                     tmp = p0 + q0 + q1;
    740. 

  740.                     data[0] = (u8)((p1 + 2 * tmp + q2 + 4) >> 3);
    741. 

  741.                     data[1] = (u8)((tmp + q2 + 2) >> 2);
    742. 

  742.                     data[2] = (u8)((2 * data[3] + 3 * q2 + tmp + 4) >> 3);
    743. 

  743.                 }
    744. 

  744.                 else
    745. 

  745.                     data[0] = (u8)((2 * q1 + q0 + p1 + 2) >> 2);
    746. 

  746.             }
    747. 

  747.         }
    748. 

  748.     }
    749. 

  749. 

  750. }
    751. 

  751. 

  752. /*------------------------------------------------------------------------------
    753. 

    754. 

  754.     Function: FilterHorLumaEdge
    755. 

    756. 

  756.         Functional description:
    757. 

  757.             Filter one horizontal 4-pixel luma edge
    758. 

    759. 

  759. ------------------------------------------------------------------------------*/
    760. 

  760. void FilterHorLumaEdge(
    761. 

  761.   u8 *data,
    762. 

  762.   u32 bS,
    763. 

  763.   edgeThreshold_t *thresholds,
    764. 

  764.   i32 imageWidth)
    765. 

  765. {
    766. 

  766. 

  767. /* Variables */
    768. 

  768. 

  769.     i32 delta, tc, tmp;
    770. 

  770.     u32 i;
    771. 

  771.     u8 p0, q0, p1, q1, p2, q2;
    772. 

  772.     const u8 *clp = h264bsdClip + 512;
    773. 

  773. 

  774. /* Code */
    775. 

  775. 

  776.     ASSERT(data);
    777. 

  777.     ASSERT(bS < 4);
    778. 

  778.     ASSERT(thresholds);
    779. 

  779. 

  780.     tc = thresholds->tc0[bS-1];
    781. 

  781.     tmp = tc;
    782. 

  782.     for (i = 4; i; i--, data++)
    783. 

  783.     {
    784. 

  784.         p1 = data[-imageWidth*2]; p0 = data[-imageWidth];
    785. 

  785.         q0 = data[0]; q1 = data[imageWidth];
    786. 

  786.         if ( ((unsigned)ABS(p0-q0) < thresholds->alpha) &&
    787. 

  787.              ((unsigned)ABS(p1-p0) < thresholds->beta)  &&
    788. 

  788.              ((unsigned)ABS(q1-q0) < thresholds->beta) )
    789. 

  789.         {
    790. 

  790.             p2 = data[-imageWidth*3];
    791. 

  791. 

  792.             if ((unsigned)ABS(p2-p0) < thresholds->beta)
    793. 

  793.             {
    794. 

  794.                 data[-imageWidth*2] = (u8)(p1 + CLIP3(-tc,tc,
    795. 

  795.                     (p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1));
    796. 

  796.                 tmp++;
    797. 

  797.             }
    798. 

  798. 

  799.             q2 = data[imageWidth*2];
    800. 

  800. 

  801.             if ((unsigned)ABS(q2-q0) < thresholds->beta)
    802. 

  802.             {
    803. 

  803.                 data[imageWidth] = (u8)(q1 + CLIP3(-tc,tc,
    804. 

  804.                     (q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1));
    805. 

  805.                 tmp++;
    806. 

  806.             }
    807. 

  807. 

  808.             delta = CLIP3(-tmp, tmp, ((((q0 - p0) << 2) +
    809. 

  809.                       (p1 - q1) + 4) >> 3));
    810. 

  810. 

  811.             p0 = clp[p0 + delta];
    812. 

  812.             q0 = clp[q0 - delta];
    813. 

  813.             tmp = tc;
    814. 

  814.             data[-imageWidth] = p0;
    815. 

  815.             data[  0] = q0;
    816. 

  816.         }
    817. 

  817.     }
    818. 

  818. }
    819. 

  819. 

  820. /*------------------------------------------------------------------------------
    821. 

    822. 

  822.     Function: FilterHorLuma
    823. 

    824. 

  824.         Functional description:
    825. 

  825.             Filter all four successive horizontal 4-pixel luma edges. This can
    826. 

  826.             be done when bS is equal to all four edges.
    827. 

    828. 

  828. ------------------------------------------------------------------------------*/
    829. 

  829. void FilterHorLuma(
    830. 

  830.   u8 *data,
    831. 

  831.   u32 bS,
    832. 

  832.   edgeThreshold_t *thresholds,
    833. 

  833.   i32 imageWidth)
    834. 

  834. {
    835. 

  835. 

  836. /* Variables */
    837. 

  837. 

  838.     i32 delta, tc, tmp;
    839. 

  839.     u32 i;
    840. 

  840.     u8 p0, q0, p1, q1, p2, q2;
    841. 

  841.     u32 tmpFlag;
    842. 

  842.     const u8 *clp = h264bsdClip + 512;
    843. 

  843. 

  844. /* Code */
    845. 

  845. 

  846.     ASSERT(data);
    847. 

  847.     ASSERT(bS <= 4);
    848. 

  848.     ASSERT(thresholds);
    849. 

  849. 

  850.     if (bS < 4)
    851. 

  851.     {
    852. 

  852.         tc = thresholds->tc0[bS-1];
    853. 

  853.         tmp = tc;
    854. 

  854.         for (i = 16; i; i--, data++)
    855. 

  855.         {
    856. 

  856.             p1 = data[-imageWidth*2]; p0 = data[-imageWidth];
    857. 

  857.             q0 = data[0]; q1 = data[imageWidth];
    858. 

  858.             if ( ((unsigned)ABS(p0-q0) < thresholds->alpha) &&
    859. 

  859.                  ((unsigned)ABS(p1-p0) < thresholds->beta)  &&
    860. 

  860.                  ((unsigned)ABS(q1-q0) < thresholds->beta) )
    861. 

  861.             {
    862. 

  862.                 p2 = data[-imageWidth*3];
    863. 

  863. 

  864.                 if ((unsigned)ABS(p2-p0) < thresholds->beta)
    865. 

  865.                 {
    866. 

  866.                     data[-imageWidth*2] = (u8)(p1 + CLIP3(-tc,tc,
    867. 

  867.                         (p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1));
    868. 

  868.                     tmp++;
    869. 

  869.                 }
    870. 

  870. 

  871.                 q2 = data[imageWidth*2];
    872. 

  872. 

  873.                 if ((unsigned)ABS(q2-q0) < thresholds->beta)
    874. 

  874.                 {
    875. 

  875.                     data[imageWidth] = (u8)(q1 + CLIP3(-tc,tc,
    876. 

  876.                         (q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1));
    877. 

  877.                     tmp++;
    878. 

  878.                 }
    879. 

  879. 

  880.                 delta = CLIP3(-tmp, tmp, ((((q0 - p0) << 2) +
    881. 

  881.                           (p1 - q1) + 4) >> 3));
    882. 

  882. 

  883.                 p0 = clp[p0 + delta];
    884. 

  884.                 q0 = clp[q0 - delta];
    885. 

  885.                 tmp = tc;
    886. 

  886.                 data[-imageWidth] = p0;
    887. 

  887.                 data[  0] = q0;
    888. 

  888.             }
    889. 

  889.         }
    890. 

  890.     }
    891. 

  891.     else
    892. 

  892.     {
    893. 

  893.         for (i = 16; i; i--, data++)
    894. 

  894.         {
    895. 

  895.             p1 = data[-imageWidth*2]; p0 = data[-imageWidth];
    896. 

  896.             q0 = data[0]; q1 = data[imageWidth];
    897. 

  897.             if ( ((unsigned)ABS(p0-q0) < thresholds->alpha) &&
    898. 

  898.                  ((unsigned)ABS(p1-p0) < thresholds->beta)  &&
    899. 

  899.                  ((unsigned)ABS(q1-q0) < thresholds->beta) )
    900. 

  900.             {
    901. 

  901.                 tmpFlag = ((unsigned)ABS(p0-q0) < ((thresholds->alpha >> 2) +2))
    902. 

  902.                             ? HANTRO_TRUE : HANTRO_FALSE;
    903. 

  903. 

  904.                 p2 = data[-imageWidth*3];
    905. 

  905.                 q2 = data[imageWidth*2];
    906. 

  906. 

  907.                 if (tmpFlag && (unsigned)ABS(p2-p0) < thresholds->beta)
    908. 

  908.                 {
    909. 

  909.                     tmp = p1 + p0 + q0;
    910. 

  910.                     data[-imageWidth] = (u8)((p2 + 2 * tmp + q1 + 4) >> 3);
    911. 

  911.                     data[-imageWidth*2] = (u8)((p2 + tmp + 2) >> 2);
    912. 

  912.                     data[-imageWidth*3] = (u8)((2 * data[-imageWidth*4] +
    913. 

  913.                                            3 * p2 + tmp + 4) >> 3);
    914. 

  914.                 }
    915. 

  915.                 else
    916. 

  916.                     data[-imageWidth] = (u8)((2 * p1 + p0 + q1 + 2) >> 2);
    917. 

  917. 

  918.                 if (tmpFlag && (unsigned)ABS(q2-q0) < thresholds->beta)
    919. 

  919.                 {
    920. 

  920.                     tmp = p0 + q0 + q1;
    921. 

  921.                     data[ 0] = (u8)((p1 + 2 * tmp + q2 + 4) >> 3);
    922. 

  922.                     data[imageWidth] = (u8)((tmp + q2 + 2) >> 2);
    923. 

  923.                     data[imageWidth*2] = (u8)((2 * data[imageWidth*3] +
    924. 

  924.                                           3 * q2 + tmp + 4) >> 3);
    925. 

  925.                 }
    926. 

  926.                 else
    927. 

  927.                     data[0] = (2 * q1 + q0 + p1 + 2) >> 2;
    928. 

  928.             }
    929. 

  929.         }
    930. 

  930.     }
    931. 

  931. 

  932. }
    933. 

  933. 

  934. /*------------------------------------------------------------------------------
    935. 

    936. 

  936.     Function: FilterVerChromaEdge
    937. 

    938. 

  938.         Functional description:
    939. 

  939.             Filter one vertical 2-pixel chroma edge
    940. 

    941. 

  941. ------------------------------------------------------------------------------*/
    942. 

  942. void FilterVerChromaEdge(
    943. 

  943.   u8 *data,
    944. 

  944.   u32 bS,
    945. 

  945.   edgeThreshold_t *thresholds,
    946. 

  946.   u32 width)
    947. 

  947. {
    948. 

  948. 

  949. /* Variables */
    950. 

  950. 

  951.     i32 delta, tc;
    952. 

  952.     u8 p0, q0, p1, q1;
    953. 

  953.     const u8 *clp = h264bsdClip + 512;
    954. 

  954. 

  955. /* Code */
    956. 

  956. 

  957.     ASSERT(data);
    958. 

  958.     ASSERT(bS <= 4);
    959. 

  959.     ASSERT(thresholds);
    960. 

  960. 

  961.     p1 = data[-2]; p0 = data[-1];
    962. 

  962.     q0 = data[0]; q1 = data[1];
    963. 

  963.     if ( ((unsigned)ABS(p0-q0) < thresholds->alpha) &&
    964. 

  964.          ((unsigned)ABS(p1-p0) < thresholds->beta)  &&
    965. 

  965.          ((unsigned)ABS(q1-q0) < thresholds->beta) )
    966. 

  966.     {
    967. 

  967.         if (bS < 4)
    968. 

  968.         {
    969. 

  969.             tc = thresholds->tc0[bS-1] + 1;
    970. 

  970.             delta = CLIP3(-tc, tc, ((((q0 - p0) << 2) +
    971. 

  971.                       (p1 - q1) + 4) >> 3));
    972. 

  972.             p0 = clp[p0 + delta];
    973. 

  973.             q0 = clp[q0 - delta];
    974. 

  974.             data[-1] = p0;
    975. 

  975.             data[ 0] = q0;
    976. 

  976.         }
    977. 

  977.         else
    978. 

  978.         {
    979. 

  979.             data[-1] = (2 * p1 + p0 + q1 + 2) >> 2;
    980. 

  980.             data[ 0] = (2 * q1 + q0 + p1 + 2) >> 2;
    981. 

  981.         }
    982. 

  982.     }
    983. 

  983.     data += width;
    984. 

  984.     p1 = data[-2]; p0 = data[-1];
    985. 

  985.     q0 = data[0]; q1 = data[1];
    986. 

  986.     if ( ((unsigned)ABS(p0-q0) < thresholds->alpha) &&
    987. 

  987.          ((unsigned)ABS(p1-p0) < thresholds->beta)  &&
    988. 

  988.          ((unsigned)ABS(q1-q0) < thresholds->beta) )
    989. 

  989.     {
    990. 

  990.         if (bS < 4)
    991. 

  991.         {
    992. 

  992.             tc = thresholds->tc0[bS-1] + 1;
    993. 

  993.             delta = CLIP3(-tc, tc, ((((q0 - p0) << 2) +
    994. 

  994.                       (p1 - q1) + 4) >> 3));
    995. 

  995.             p0 = clp[p0 + delta];
    996. 

  996.             q0 = clp[q0 - delta];
    997. 

  997.             data[-1] = p0;
    998. 

  998.             data[ 0] = q0;
    999. 

  999.         }
    1000. 

  1000.         else
    1001. 

  1001.         {
    1002. 

  1002.             data[-1] = (2 * p1 + p0 + q1 + 2) >> 2;
    1003. 

  1003.             data[ 0] = (2 * q1 + q0 + p1 + 2) >> 2;
    1004. 

  1004.         }
    1005. 

  1005.     }
    1006. 

  1006. 

  1007. }
    1008. 

  1008. 

  1009. /*------------------------------------------------------------------------------
    1010. 

    1011. 

  1011.     Function: FilterHorChromaEdge
    1012. 

    1013. 

  1013.         Functional description:
    1014. 

  1014.             Filter one horizontal 2-pixel chroma edge
    1015. 

    1016. 

  1016. ------------------------------------------------------------------------------*/
    1017. 

  1017. void FilterHorChromaEdge(
    1018. 

  1018.   u8 *data,
    1019. 

  1019.   u32 bS,
    1020. 

  1020.   edgeThreshold_t *thresholds,
    1021. 

  1021.   i32 width)
    1022. 

  1022. {
    1023. 

  1023. 

  1024. /* Variables */
    1025. 

  1025. 

  1026.     i32 delta, tc;
    1027. 

  1027.     u32 i;
    1028. 

  1028.     u8 p0, q0, p1, q1;
    1029. 

  1029.     const u8 *clp = h264bsdClip + 512;
    1030. 

  1030. 

  1031. /* Code */
    1032. 

  1032. 

  1033.     ASSERT(data);
    1034. 

  1034.     ASSERT(bS < 4);
    1035. 

  1035.     ASSERT(thresholds);
    1036. 

  1036. 

  1037.     tc = thresholds->tc0[bS-1] + 1;
    1038. 

  1038.     for (i = 2; i; i--, data++)
    1039. 

  1039.     {
    1040. 

  1040.         p1 = data[-width*2]; p0 = data[-width];
    1041. 

  1041.         q0 = data[0]; q1 = data[width];
    1042. 

  1042.         if ( ((unsigned)ABS(p0-q0) < thresholds->alpha) &&
    1043. 

  1043.              ((unsigned)ABS(p1-p0) < thresholds->beta)  &&
    1044. 

  1044.              ((unsigned)ABS(q1-q0) < thresholds->beta) )
    1045. 

  1045.         {
    1046. 

  1046.             delta = CLIP3(-tc, tc, ((((q0 - p0) << 2) +
    1047. 

  1047.                       (p1 - q1) + 4) >> 3));
    1048. 

  1048.             p0 = clp[p0 + delta];
    1049. 

  1049.             q0 = clp[q0 - delta];
    1050. 

  1050.             data[-width] = p0;
    1051. 

  1051.             data[  0] = q0;
    1052. 

  1052.         }
    1053. 

  1053.     }
    1054. 

  1054. }
    1055. 

  1055. 

  1056. /*------------------------------------------------------------------------------
    1057. 

    1058. 

  1058.     Function: FilterHorChroma
    1059. 

    1060. 

  1060.         Functional description:
    1061. 

  1061.             Filter all four successive horizontal 2-pixel chroma edges. This
    1062. 

  1062.             can be done if bS is equal for all four edges.
    1063. 

    1064. 

  1064. ------------------------------------------------------------------------------*/
    1065. 

  1065. void FilterHorChroma(
    1066. 

  1066.   u8 *data,
    1067. 

  1067.   u32 bS,
    1068. 

  1068.   edgeThreshold_t *thresholds,
    1069. 

  1069.   i32 width)
    1070. 

  1070. {
    1071. 

  1071. 

  1072. /* Variables */
    1073. 

  1073. 

  1074.     i32 delta, tc;
    1075. 

  1075.     u32 i;
    1076. 

  1076.     u8 p0, q0, p1, q1;
    1077. 

  1077.     const u8 *clp = h264bsdClip + 512;
    1078. 

  1078. 

  1079. /* Code */
    1080. 

  1080. 

  1081.     ASSERT(data);
    1082. 

  1082.     ASSERT(bS <= 4);
    1083. 

  1083.     ASSERT(thresholds);
    1084. 

  1084. 

  1085.     if (bS < 4)
    1086. 

  1086.     {
    1087. 

  1087.         tc = thresholds->tc0[bS-1] + 1;
    1088. 

  1088.         for (i = 8; i; i--, data++)
    1089. 

  1089.         {
    1090. 

  1090.             p1 = data[-width*2]; p0 = data[-width];
    1091. 

  1091.             q0 = data[0]; q1 = data[width];
    1092. 

  1092.             if ( ((unsigned)ABS(p0-q0) < thresholds->alpha) &&
    1093. 

  1093.                  ((unsigned)ABS(p1-p0) < thresholds->beta)  &&
    1094. 

  1094.                  ((unsigned)ABS(q1-q0) < thresholds->beta) )
    1095. 

  1095.             {
    1096. 

  1096.                 delta = CLIP3(-tc, tc, ((((q0 - p0) << 2) +
    1097. 

  1097.                           (p1 - q1) + 4) >> 3));
    1098. 

  1098.                 p0 = clp[p0 + delta];
    1099. 

  1099.                 q0 = clp[q0 - delta];
    1100. 

  1100.                 data[-width] = p0;
    1101. 

  1101.                 data[  0] = q0;
    1102. 

  1102.             }
    1103. 

  1103.         }
    1104. 

  1104.     }
    1105. 

  1105.     else
    1106. 

  1106.     {
    1107. 

  1107.         for (i = 8; i; i--, data++)
    1108. 

  1108.         {
    1109. 

  1109.             p1 = data[-width*2]; p0 = data[-width];
    1110. 

  1110.             q0 = data[0]; q1 = data[width];
    1111. 

  1111.             if ( ((unsigned)ABS(p0-q0) < thresholds->alpha) &&
    1112. 

  1112.                  ((unsigned)ABS(p1-p0) < thresholds->beta)  &&
    1113. 

  1113.                  ((unsigned)ABS(q1-q0) < thresholds->beta) )
    1114. 

  1114.             {
    1115. 

  1115.                     data[-width] = (2 * p1 + p0 + q1 + 2) >> 2;
    1116. 

  1116.                     data[  0] = (2 * q1 + q0 + p1 + 2) >> 2;
    1117. 

  1117.             }
    1118. 

  1118.         }
    1119. 

  1119.     }
    1120. 

  1120. 

  1121. }
    1122. 

  1122. 

  1123. 

  1124. /*------------------------------------------------------------------------------
    1125. 

    1126. 

  1126.     Function: GetBoundaryStrengths
    1127. 

    1128. 

  1128.         Functional description:
    1129. 

  1129.             Function to calculate boundary strengths for all edges of a
    1130. 

  1130.             macroblock. Function returns HANTRO_TRUE if any of the bS values for
    1131. 

  1131.             the macroblock had non-zero value, HANTRO_FALSE otherwise.
    1132. 

    1133. 

  1133. ------------------------------------------------------------------------------*/
    1134. 

  1134. u32 GetBoundaryStrengths(mbStorage_t *mb, bS_t *bS, u32 flags)
    1135. 

  1135. {
    1136. 

  1136. 

  1137. /* Variables */
    1138. 

  1138. 

  1139.     /* this flag is set HANTRO_TRUE as soon as any boundary strength value is
    1140. 

  1140.      * non-zero */
    1141. 

  1141.     u32 nonZeroBs = HANTRO_FALSE;
    1142. 

  1142. 

  1143. /* Code */
    1144. 

  1144. 

  1145.     ASSERT(mb);
    1146. 

  1146.     ASSERT(bS);
    1147. 

  1147.     ASSERT(flags);
    1148. 

  1148. 

  1149.     /* top edges */
    1150. 

  1150.     if (flags & FILTER_TOP_EDGE)
    1151. 

  1151.     {
    1152. 

  1152.         if (IS_INTRA_MB(*mb) || IS_INTRA_MB(*mb->mbB))
    1153. 

  1153.         {
    1154. 

  1154.             bS[0].top = bS[1].top = bS[2].top = bS[3].top = 4;
    1155. 

  1155.             nonZeroBs = HANTRO_TRUE;
    1156. 

  1156.         }
    1157. 

  1157.         else
    1158. 

  1158.         {
    1159. 

  1159.             bS[0].top = EdgeBoundaryStrength(mb, mb->mbB, 0, 10);
    1160. 

  1160.             bS[1].top = EdgeBoundaryStrength(mb, mb->mbB, 1, 11);
    1161. 

  1161.             bS[2].top = EdgeBoundaryStrength(mb, mb->mbB, 4, 14);
    1162. 

  1162.             bS[3].top = EdgeBoundaryStrength(mb, mb->mbB, 5, 15);
    1163. 

  1163.             if (bS[0].top || bS[1].top || bS[2].top || bS[3].top)
    1164. 

  1164.                 nonZeroBs = HANTRO_TRUE;
    1165. 

  1165.         }
    1166. 

  1166.     }
    1167. 

  1167.     else
    1168. 

  1168.     {
    1169. 

  1169.         bS[0].top = bS[1].top = bS[2].top = bS[3].top = 0;
    1170. 

  1170.     }
    1171. 

  1171. 

  1172.     /* left edges */
    1173. 

  1173.     if (flags & FILTER_LEFT_EDGE)
    1174. 

  1174.     {
    1175. 

  1175.         if (IS_INTRA_MB(*mb) || IS_INTRA_MB(*mb->mbA))
    1176. 

  1176.         {
    1177. 

  1177.             bS[0].left = bS[4].left = bS[8].left = bS[12].left = 4;
    1178. 

  1178.             nonZeroBs = HANTRO_TRUE;
    1179. 

  1179.         }
    1180. 

  1180.         else
    1181. 

  1181.         {
    1182. 

  1182.             bS[0].left = EdgeBoundaryStrength(mb, mb->mbA, 0, 5);
    1183. 

  1183.             bS[4].left = EdgeBoundaryStrength(mb, mb->mbA, 2, 7);
    1184. 

  1184.             bS[8].left = EdgeBoundaryStrength(mb, mb->mbA, 8, 13);
    1185. 

  1185.             bS[12].left = EdgeBoundaryStrength(mb, mb->mbA, 10, 15);
    1186. 

  1186.             if (!nonZeroBs &&
    1187. 

  1187.                 (bS[0].left || bS[4].left || bS[8].left || bS[12].left))
    1188. 

  1188.                 nonZeroBs = HANTRO_TRUE;
    1189. 

  1189.         }
    1190. 

  1190.     }
    1191. 

  1191.     else
    1192. 

  1192.     {
    1193. 

  1193.         bS[0].left = bS[4].left = bS[8].left = bS[12].left = 0;
    1194. 

  1194.     }
    1195. 

  1195. 

  1196.     /* inner edges */
    1197. 

  1197.     if (IS_INTRA_MB(*mb))
    1198. 

  1198.     {
    1199. 

  1199.         bS[4].top  = bS[5].top  = bS[6].top  = bS[7].top  =
    1200. 

  1200.         bS[8].top  = bS[9].top  = bS[10].top = bS[11].top =
    1201. 

  1201.         bS[12].top = bS[13].top = bS[14].top = bS[15].top = 3;
    1202. 

  1202. 

  1203.         bS[1].left  = bS[2].left  = bS[3].left  =
    1204. 

  1204.         bS[5].left  = bS[6].left  = bS[7].left  =
    1205. 

  1205.         bS[9].left  = bS[10].left = bS[11].left =
    1206. 

  1206.         bS[13].left = bS[14].left = bS[15].left = 3;
    1207. 

  1207.         nonZeroBs = HANTRO_TRUE;
    1208. 

  1208.     }
    1209. 

  1209.     else
    1210. 

  1210.     {
    1211. 

  1211.         /* 16x16 inter mb -> ref addresses or motion vectors cannot differ,
    1212. 

  1212.          * only check if either of the blocks contain coefficients */
    1213. 

  1213.         if (h264bsdNumMbPart(mb->mbType) == 1)
    1214. 

  1214.         {
    1215. 

  1215.             bS[4].top = mb->totalCoeff[2] || mb->totalCoeff[0] ? 2 : 0;
    1216. 

  1216.             bS[5].top = mb->totalCoeff[3] || mb->totalCoeff[1] ? 2 : 0;
    1217. 

  1217.             bS[6].top = mb->totalCoeff[6] || mb->totalCoeff[4] ? 2 : 0;
    1218. 

  1218.             bS[7].top = mb->totalCoeff[7] || mb->totalCoeff[5] ? 2 : 0;
    1219. 

  1219.             bS[8].top = mb->totalCoeff[8] || mb->totalCoeff[2] ? 2 : 0;
    1220. 

  1220.             bS[9].top = mb->totalCoeff[9] || mb->totalCoeff[3] ? 2 : 0;
    1221. 

  1221.             bS[10].top = mb->totalCoeff[12] || mb->totalCoeff[6] ? 2 : 0;
    1222. 

  1222.             bS[11].top = mb->totalCoeff[13] || mb->totalCoeff[7] ? 2 : 0;
    1223. 

  1223.             bS[12].top = mb->totalCoeff[10] || mb->totalCoeff[8] ? 2 : 0;
    1224. 

  1224.             bS[13].top = mb->totalCoeff[11] || mb->totalCoeff[9] ? 2 : 0;
    1225. 

  1225.             bS[14].top = mb->totalCoeff[14] || mb->totalCoeff[12] ? 2 : 0;
    1226. 

  1226.             bS[15].top = mb->totalCoeff[15] || mb->totalCoeff[13] ? 2 : 0;
    1227. 

  1227. 

  1228.             bS[1].left = mb->totalCoeff[1] || mb->totalCoeff[0] ? 2 : 0;
    1229. 

  1229.             bS[2].left = mb->totalCoeff[4] || mb->totalCoeff[1] ? 2 : 0;
    1230. 

  1230.             bS[3].left = mb->totalCoeff[5] || mb->totalCoeff[4] ? 2 : 0;
    1231. 

  1231.             bS[5].left = mb->totalCoeff[3] || mb->totalCoeff[2] ? 2 : 0;
    1232. 

  1232.             bS[6].left = mb->totalCoeff[6] || mb->totalCoeff[3] ? 2 : 0;
    1233. 

  1233.             bS[7].left = mb->totalCoeff[7] || mb->totalCoeff[6] ? 2 : 0;
    1234. 

  1234.             bS[9].left = mb->totalCoeff[9] || mb->totalCoeff[8] ? 2 : 0;
    1235. 

  1235.             bS[10].left = mb->totalCoeff[12] || mb->totalCoeff[9] ? 2 : 0;
    1236. 

  1236.             bS[11].left = mb->totalCoeff[13] || mb->totalCoeff[12] ? 2 : 0;
    1237. 

  1237.             bS[13].left = mb->totalCoeff[11] || mb->totalCoeff[10] ? 2 : 0;
    1238. 

  1238.             bS[14].left = mb->totalCoeff[14] || mb->totalCoeff[11] ? 2 : 0;
    1239. 

  1239.             bS[15].left = mb->totalCoeff[15] || mb->totalCoeff[14] ? 2 : 0;
    1240. 

  1240.         }
    1241. 

  1241.         /* 16x8 inter mb -> ref addresses and motion vectors can be different
    1242. 

  1242.          * only for the middle horizontal edge, for the other top edges it is
    1243. 

  1243.          * enough to check whether the blocks contain coefficients or not. The
    1244. 

  1244.          * same applies to all internal left edges. */
    1245. 

  1245.         else if (mb->mbType == P_L0_L0_16x8)
    1246. 

  1246.         {
    1247. 

  1247.             bS[4].top = mb->totalCoeff[2] || mb->totalCoeff[0] ? 2 : 0;
    1248. 

  1248.             bS[5].top = mb->totalCoeff[3] || mb->totalCoeff[1] ? 2 : 0;
    1249. 

  1249.             bS[6].top = mb->totalCoeff[6] || mb->totalCoeff[4] ? 2 : 0;
    1250. 

  1250.             bS[7].top = mb->totalCoeff[7] || mb->totalCoeff[5] ? 2 : 0;
    1251. 

  1251.             bS[12].top = mb->totalCoeff[10] || mb->totalCoeff[8] ? 2 : 0;
    1252. 

  1252.             bS[13].top = mb->totalCoeff[11] || mb->totalCoeff[9] ? 2 : 0;
    1253. 

  1253.             bS[14].top = mb->totalCoeff[14] || mb->totalCoeff[12] ? 2 : 0;
    1254. 

  1254.             bS[15].top = mb->totalCoeff[15] || mb->totalCoeff[13] ? 2 : 0;
    1255. 

  1255.             bS[8].top = InnerBoundaryStrength(mb, 8, 2);
    1256. 

  1256.             bS[9].top = InnerBoundaryStrength(mb, 9, 3);
    1257. 

  1257.             bS[10].top = InnerBoundaryStrength(mb, 12, 6);
    1258. 

  1258.             bS[11].top = InnerBoundaryStrength(mb, 13, 7);
    1259. 

  1259. 

  1260.             bS[1].left = mb->totalCoeff[1] || mb->totalCoeff[0] ? 2 : 0;
    1261. 

  1261.             bS[2].left = mb->totalCoeff[4] || mb->totalCoeff[1] ? 2 : 0;
    1262. 

  1262.             bS[3].left = mb->totalCoeff[5] || mb->totalCoeff[4] ? 2 : 0;
    1263. 

  1263.             bS[5].left = mb->totalCoeff[3] || mb->totalCoeff[2] ? 2 : 0;
    1264. 

  1264.             bS[6].left = mb->totalCoeff[6] || mb->totalCoeff[3] ? 2 : 0;
    1265. 

  1265.             bS[7].left = mb->totalCoeff[7] || mb->totalCoeff[6] ? 2 : 0;
    1266. 

  1266.             bS[9].left = mb->totalCoeff[9] || mb->totalCoeff[8] ? 2 : 0;
    1267. 

  1267.             bS[10].left = mb->totalCoeff[12] || mb->totalCoeff[9] ? 2 : 0;
    1268. 

  1268.             bS[11].left = mb->totalCoeff[13] || mb->totalCoeff[12] ? 2 : 0;
    1269. 

  1269.             bS[13].left = mb->totalCoeff[11] || mb->totalCoeff[10] ? 2 : 0;
    1270. 

  1270.             bS[14].left = mb->totalCoeff[14] || mb->totalCoeff[11] ? 2 : 0;
    1271. 

  1271.             bS[15].left = mb->totalCoeff[15] || mb->totalCoeff[14] ? 2 : 0;
    1272. 

  1272.         }
    1273. 

  1273.         /* 8x16 inter mb -> ref addresses and motion vectors can be different
    1274. 

  1274.          * only for the middle vertical edge, for the other left edges it is
    1275. 

  1275.          * enough to check whether the blocks contain coefficients or not. The
    1276. 

  1276.          * same applies to all internal top edges. */
    1277. 

  1277.         else if (mb->mbType == P_L0_L0_8x16)
    1278. 

  1278.         {
    1279. 

  1279.             bS[4].top = mb->totalCoeff[2] || mb->totalCoeff[0] ? 2 : 0;
    1280. 

  1280.             bS[5].top = mb->totalCoeff[3] || mb->totalCoeff[1] ? 2 : 0;
    1281. 

  1281.             bS[6].top = mb->totalCoeff[6] || mb->totalCoeff[4] ? 2 : 0;
    1282. 

  1282.             bS[7].top = mb->totalCoeff[7] || mb->totalCoeff[5] ? 2 : 0;
    1283. 

  1283.             bS[8].top = mb->totalCoeff[8] || mb->totalCoeff[2] ? 2 : 0;
    1284. 

  1284.             bS[9].top = mb->totalCoeff[9] || mb->totalCoeff[3] ? 2 : 0;
    1285. 

  1285.             bS[10].top = mb->totalCoeff[12] || mb->totalCoeff[6] ? 2 : 0;
    1286. 

  1286.             bS[11].top = mb->totalCoeff[13] || mb->totalCoeff[7] ? 2 : 0;
    1287. 

  1287.             bS[12].top = mb->totalCoeff[10] || mb->totalCoeff[8] ? 2 : 0;
    1288. 

  1288.             bS[13].top = mb->totalCoeff[11] || mb->totalCoeff[9] ? 2 : 0;
    1289. 

  1289.             bS[14].top = mb->totalCoeff[14] || mb->totalCoeff[12] ? 2 : 0;
    1290. 

  1290.             bS[15].top = mb->totalCoeff[15] || mb->totalCoeff[13] ? 2 : 0;
    1291. 

  1291. 

  1292.             bS[1].left = mb->totalCoeff[1] || mb->totalCoeff[0] ? 2 : 0;
    1293. 

  1293.             bS[3].left = mb->totalCoeff[5] || mb->totalCoeff[4] ? 2 : 0;
    1294. 

  1294.             bS[5].left = mb->totalCoeff[3] || mb->totalCoeff[2] ? 2 : 0;
    1295. 

  1295.             bS[7].left = mb->totalCoeff[7] || mb->totalCoeff[6] ? 2 : 0;
    1296. 

  1296.             bS[9].left = mb->totalCoeff[9] || mb->totalCoeff[8] ? 2 : 0;
    1297. 

  1297.             bS[11].left = mb->totalCoeff[13] || mb->totalCoeff[12] ? 2 : 0;
    1298. 

  1298.             bS[13].left = mb->totalCoeff[11] || mb->totalCoeff[10] ? 2 : 0;
    1299. 

  1299.             bS[15].left = mb->totalCoeff[15] || mb->totalCoeff[14] ? 2 : 0;
    1300. 

  1300.             bS[2].left = InnerBoundaryStrength(mb, 4, 1);
    1301. 

  1301.             bS[6].left = InnerBoundaryStrength(mb, 6, 3);
    1302. 

  1302.             bS[10].left = InnerBoundaryStrength(mb, 12, 9);
    1303. 

  1303.             bS[14].left = InnerBoundaryStrength(mb, 14, 11);
    1304. 

  1304.         }
    1305. 

  1305.         else
    1306. 

  1306.         {
    1307. 

  1307.             bS[4].top =
    1308. 

  1308.                 InnerBoundaryStrength(mb, mb4x4Index[4], mb4x4Index[0]);
    1309. 

  1309.             bS[5].top =
    1310. 

  1310.                 InnerBoundaryStrength(mb, mb4x4Index[5], mb4x4Index[1]);
    1311. 

  1311.             bS[6].top =
    1312. 

  1312.                 InnerBoundaryStrength(mb, mb4x4Index[6], mb4x4Index[2]);
    1313. 

  1313.             bS[7].top =
    1314. 

  1314.                 InnerBoundaryStrength(mb, mb4x4Index[7], mb4x4Index[3]);
    1315. 

  1315.             bS[8].top =
    1316. 

  1316.                 InnerBoundaryStrength(mb, mb4x4Index[8], mb4x4Index[4]);
    1317. 

  1317.             bS[9].top =
    1318. 

  1318.                 InnerBoundaryStrength(mb, mb4x4Index[9], mb4x4Index[5]);
    1319. 

  1319.             bS[10].top =
    1320. 

  1320.                 InnerBoundaryStrength(mb, mb4x4Index[10], mb4x4Index[6]);
    1321. 

  1321.             bS[11].top =
    1322. 

  1322.                 InnerBoundaryStrength(mb, mb4x4Index[11], mb4x4Index[7]);
    1323. 

  1323.             bS[12].top =
    1324. 

  1324.                 InnerBoundaryStrength(mb, mb4x4Index[12], mb4x4Index[8]);
    1325. 

  1325.             bS[13].top =
    1326. 

  1326.                 InnerBoundaryStrength(mb, mb4x4Index[13], mb4x4Index[9]);
    1327. 

  1327.             bS[14].top =
    1328. 

  1328.                 InnerBoundaryStrength(mb, mb4x4Index[14], mb4x4Index[10]);
    1329. 

  1329.             bS[15].top =
    1330. 

  1330.                 InnerBoundaryStrength(mb, mb4x4Index[15], mb4x4Index[11]);
    1331. 

  1331. 

  1332.             bS[1].left =
    1333. 

  1333.                 InnerBoundaryStrength(mb, mb4x4Index[1], mb4x4Index[0]);
    1334. 

  1334.             bS[2].left =
    1335. 

  1335.                 InnerBoundaryStrength(mb, mb4x4Index[2], mb4x4Index[1]);
    1336. 

  1336.             bS[3].left =
    1337. 

  1337.                 InnerBoundaryStrength(mb, mb4x4Index[3], mb4x4Index[2]);
    1338. 

  1338.             bS[5].left =
    1339. 

  1339.                 InnerBoundaryStrength(mb, mb4x4Index[5], mb4x4Index[4]);
    1340. 

  1340.             bS[6].left =
    1341. 

  1341.                 InnerBoundaryStrength(mb, mb4x4Index[6], mb4x4Index[5]);
    1342. 

  1342.             bS[7].left =
    1343. 

  1343.                 InnerBoundaryStrength(mb, mb4x4Index[7], mb4x4Index[6]);
    1344. 

  1344.             bS[9].left =
    1345. 

  1345.                 InnerBoundaryStrength(mb, mb4x4Index[9], mb4x4Index[8]);
    1346. 

  1346.             bS[10].left =
    1347. 

  1347.                 InnerBoundaryStrength(mb, mb4x4Index[10], mb4x4Index[9]);
    1348. 

  1348.             bS[11].left =
    1349. 

  1349.                 InnerBoundaryStrength(mb, mb4x4Index[11], mb4x4Index[10]);
    1350. 

  1350.             bS[13].left =
    1351. 

  1351.                 InnerBoundaryStrength(mb, mb4x4Index[13], mb4x4Index[12]);
    1352. 

  1352.             bS[14].left =
    1353. 

  1353.                 InnerBoundaryStrength(mb, mb4x4Index[14], mb4x4Index[13]);
    1354. 

  1354.             bS[15].left =
    1355. 

  1355.                 InnerBoundaryStrength(mb, mb4x4Index[15], mb4x4Index[14]);
    1356. 

  1356.         }
    1357. 

  1357.         if (!nonZeroBs &&
    1358. 

  1358.             (bS[4].top || bS[5].top || bS[6].top || bS[7].top ||
    1359. 

  1359.              bS[8].top || bS[9].top || bS[10].top || bS[11].top ||
    1360. 

  1360.              bS[12].top || bS[13].top || bS[14].top || bS[15].top ||
    1361. 

  1361.              bS[1].left || bS[2].left || bS[3].left ||
    1362. 

  1362.              bS[5].left || bS[6].left || bS[7].left ||
    1363. 

  1363.              bS[9].left || bS[10].left || bS[11].left ||
    1364. 

  1364.              bS[13].left || bS[14].left || bS[15].left))
    1365. 

  1365.             nonZeroBs = HANTRO_TRUE;
    1366. 

  1366.     }
    1367. 

  1367. 

  1368.     return(nonZeroBs);
    1369. 

  1369. 

  1370. }
    1371. 

  1371. 

  1372. /*------------------------------------------------------------------------------
    1373. 

    1374. 

  1374.     Function: GetLumaEdgeThresholds
    1375. 

    1376. 

  1376.         Functional description:
    1377. 

  1377.             Compute alpha, beta and tc0 thresholds for inner, left and top
    1378. 

  1378.             luma edges of a macroblock.
    1379. 

    1380. 

  1380. ------------------------------------------------------------------------------*/
    1381. 

  1381. void GetLumaEdgeThresholds(
    1382. 

  1382.   edgeThreshold_t *thresholds,
    1383. 

  1383.   mbStorage_t *mb,
    1384. 

  1384.   u32 filteringFlags)
    1385. 

  1385. {
    1386. 

  1386. 

  1387. /* Variables */
    1388. 

  1388. 

  1389.     u32 indexA, indexB;
    1390. 

  1390.     u32 qpAv, qp, qpTmp;
    1391. 

  1391. 

  1392. /* Code */
    1393. 

  1393. 

  1394.     ASSERT(thresholds);
    1395. 

  1395.     ASSERT(mb);
    1396. 

  1396. 

  1397.     qp = mb->qpY;
    1398. 

  1398. 

  1399.     indexA = (u32)CLIP3(0, 51, (i32)qp + mb->filterOffsetA);
    1400. 

  1400.     indexB = (u32)CLIP3(0, 51, (i32)qp + mb->filterOffsetB);
    1401. 

  1401. 

  1402.     thresholds[INNER].alpha = alphas[indexA];
    1403. 

  1403.     thresholds[INNER].beta = betas[indexB];
    1404. 

  1404.     thresholds[INNER].tc0 = tc0[indexA];
    1405. 

  1405. 

  1406.     if (filteringFlags & FILTER_TOP_EDGE)
    1407. 

  1407.     {
    1408. 

  1408.         qpTmp = mb->mbB->qpY;
    1409. 

  1409.         if (qpTmp != qp)
    1410. 

  1410.         {
    1411. 

  1411.             qpAv = (qp + qpTmp + 1) >> 1;
    1412. 

  1412. 

  1413.             indexA = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetA);
    1414. 

  1414.             indexB = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetB);
    1415. 

  1415. 

  1416.             thresholds[TOP].alpha = alphas[indexA];
    1417. 

  1417.             thresholds[TOP].beta = betas[indexB];
    1418. 

  1418.             thresholds[TOP].tc0 = tc0[indexA];
    1419. 

  1419.         }
    1420. 

  1420.         else
    1421. 

  1421.         {
    1422. 

  1422.             thresholds[TOP].alpha = thresholds[INNER].alpha;
    1423. 

  1423.             thresholds[TOP].beta = thresholds[INNER].beta;
    1424. 

  1424.             thresholds[TOP].tc0 = thresholds[INNER].tc0;
    1425. 

  1425.         }
    1426. 

  1426.     }
    1427. 

  1427.     if (filteringFlags & FILTER_LEFT_EDGE)
    1428. 

  1428.     {
    1429. 

  1429.         qpTmp = mb->mbA->qpY;
    1430. 

  1430.         if (qpTmp != qp)
    1431. 

  1431.         {
    1432. 

  1432.             qpAv = (qp + qpTmp + 1) >> 1;
    1433. 

  1433. 

  1434.             indexA = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetA);
    1435. 

  1435.             indexB = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetB);
    1436. 

  1436. 

  1437.             thresholds[LEFT].alpha = alphas[indexA];
    1438. 

  1438.             thresholds[LEFT].beta = betas[indexB];
    1439. 

  1439.             thresholds[LEFT].tc0 = tc0[indexA];
    1440. 

  1440.         }
    1441. 

  1441.         else
    1442. 

  1442.         {
    1443. 

  1443.             thresholds[LEFT].alpha = thresholds[INNER].alpha;
    1444. 

  1444.             thresholds[LEFT].beta = thresholds[INNER].beta;
    1445. 

  1445.             thresholds[LEFT].tc0 = thresholds[INNER].tc0;
    1446. 

  1446.         }
    1447. 

  1447.     }
    1448. 

  1448. 

  1449. }
    1450. 

  1450. 

  1451. /*------------------------------------------------------------------------------
    1452. 

    1453. 

  1453.     Function: GetChromaEdgeThresholds
    1454. 

    1455. 

  1455.         Functional description:
    1456. 

  1456.             Compute alpha, beta and tc0 thresholds for inner, left and top
    1457. 

  1457.             chroma edges of a macroblock.
    1458. 

    1459. 

  1459. ------------------------------------------------------------------------------*/
    1460. 

  1460. void GetChromaEdgeThresholds(
    1461. 

  1461.   edgeThreshold_t *thresholds,
    1462. 

  1462.   mbStorage_t *mb,
    1463. 

  1463.   u32 filteringFlags,
    1464. 

  1464.   i32 chromaQpIndexOffset)
    1465. 

  1465. {
    1466. 

  1466. 

  1467. /* Variables */
    1468. 

  1468. 

  1469.     u32 indexA, indexB;
    1470. 

  1470.     u32 qpAv, qp, qpTmp;
    1471. 

  1471. 

  1472. /* Code */
    1473. 

  1473. 

  1474.     ASSERT(thresholds);
    1475. 

  1475.     ASSERT(mb);
    1476. 

  1476. 

  1477.     qp = mb->qpY;
    1478. 

  1478.     qp = h264bsdQpC[CLIP3(0, 51, (i32)qp + chromaQpIndexOffset)];
    1479. 

  1479. 

  1480.     indexA = (u32)CLIP3(0, 51, (i32)qp + mb->filterOffsetA);
    1481. 

  1481.     indexB = (u32)CLIP3(0, 51, (i32)qp + mb->filterOffsetB);
    1482. 

  1482. 

  1483.     thresholds[INNER].alpha = alphas[indexA];
    1484. 

  1484.     thresholds[INNER].beta = betas[indexB];
    1485. 

  1485.     thresholds[INNER].tc0 = tc0[indexA];
    1486. 

  1486. 

  1487.     if (filteringFlags & FILTER_TOP_EDGE)
    1488. 

  1488.     {
    1489. 

  1489.         qpTmp = mb->mbB->qpY;
    1490. 

  1490.         if (qpTmp != mb->qpY)
    1491. 

  1491.         {
    1492. 

  1492.             qpTmp = h264bsdQpC[CLIP3(0, 51, (i32)qpTmp + chromaQpIndexOffset)];
    1493. 

  1493.             qpAv = (qp + qpTmp + 1) >> 1;
    1494. 

  1494. 

  1495.             indexA = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetA);
    1496. 

  1496.             indexB = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetB);
    1497. 

  1497. 

  1498.             thresholds[TOP].alpha = alphas[indexA];
    1499. 

  1499.             thresholds[TOP].beta = betas[indexB];
    1500. 

  1500.             thresholds[TOP].tc0 = tc0[indexA];
    1501. 

  1501.         }
    1502. 

  1502.         else
    1503. 

  1503.         {
    1504. 

  1504.             thresholds[TOP].alpha = thresholds[INNER].alpha;
    1505. 

  1505.             thresholds[TOP].beta = thresholds[INNER].beta;
    1506. 

  1506.             thresholds[TOP].tc0 = thresholds[INNER].tc0;
    1507. 

  1507.         }
    1508. 

  1508.     }
    1509. 

  1509.     if (filteringFlags & FILTER_LEFT_EDGE)
    1510. 

  1510.     {
    1511. 

  1511.         qpTmp = mb->mbA->qpY;
    1512. 

  1512.         if (qpTmp != mb->qpY)
    1513. 

  1513.         {
    1514. 

  1514.             qpTmp = h264bsdQpC[CLIP3(0, 51, (i32)qpTmp + chromaQpIndexOffset)];
    1515. 

  1515.             qpAv = (qp + qpTmp + 1) >> 1;
    1516. 

  1516. 

  1517.             indexA = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetA);
    1518. 

  1518.             indexB = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetB);
    1519. 

  1519. 

  1520.             thresholds[LEFT].alpha = alphas[indexA];
    1521. 

  1521.             thresholds[LEFT].beta = betas[indexB];
    1522. 

  1522.             thresholds[LEFT].tc0 = tc0[indexA];
    1523. 

  1523.         }
    1524. 

  1524.         else
    1525. 

  1525.         {
    1526. 

  1526.             thresholds[LEFT].alpha = thresholds[INNER].alpha;
    1527. 

  1527.             thresholds[LEFT].beta = thresholds[INNER].beta;
    1528. 

  1528.             thresholds[LEFT].tc0 = thresholds[INNER].tc0;
    1529. 

  1529.         }
    1530. 

  1530.     }
    1531. 

  1531. 

  1532. }
    1533. 

  1533. 

  1534. /*------------------------------------------------------------------------------
    1535. 

    1536. 

  1536.     Function: FilterLuma
    1537. 

    1538. 

  1538.         Functional description:
    1539. 

  1539.             Function to filter all luma edges of a macroblock
    1540. 

    1541. 

  1541. ------------------------------------------------------------------------------*/
    1542. 

  1542. void FilterLuma(
    1543. 

  1543.   u8 *data,
    1544. 

  1544.   bS_t *bS,
    1545. 

  1545.   edgeThreshold_t *thresholds,
    1546. 

  1546.   u32 width)
    1547. 

  1547. {
    1548. 

  1548. 

  1549. /* Variables */
    1550. 

  1550. 

  1551.     u32 vblock;
    1552. 

  1552.     bS_t *tmp;
    1553. 

  1553.     u8 *ptr;
    1554. 

  1554.     u32 offset;
    1555. 

  1555. 

  1556. /* Code */
    1557. 

  1557. 

  1558.     ASSERT(data);
    1559. 

  1559.     ASSERT(bS);
    1560. 

  1560.     ASSERT(thresholds);
    1561. 

  1561. 

  1562.     ptr = data;
    1563. 

  1563.     tmp = bS;
    1564. 

  1564. 

  1565.     offset  = TOP;
    1566. 

  1566. 

  1567.     /* loop block rows, perform filtering for all vertical edges of the block
    1568. 

  1568.      * row first, then filter each horizontal edge of the row */
    1569. 

  1569.     for (vblock = 4; vblock--;)
    1570. 

  1570.     {
    1571. 

  1571.         /* only perform filtering if bS is non-zero, first of the four
    1572. 

  1572.          * FilterVerLumaEdge handles the left edge of the macroblock, others
    1573. 

  1573.          * filter inner edges */
    1574. 

  1574.         if (tmp[0].left)
    1575. 

  1575.             FilterVerLumaEdge(ptr, tmp[0].left, thresholds + LEFT, width);
    1576. 

  1576.         if (tmp[1].left)
    1577. 

  1577.             FilterVerLumaEdge(ptr+4, tmp[1].left, thresholds + INNER, width);
    1578. 

  1578.         if (tmp[2].left)
    1579. 

  1579.             FilterVerLumaEdge(ptr+8, tmp[2].left, thresholds + INNER, width);
    1580. 

  1580.         if (tmp[3].left)
    1581. 

  1581.             FilterVerLumaEdge(ptr+12, tmp[3].left, thresholds + INNER, width);
    1582. 

  1582. 

  1583.         /* if bS is equal for all horizontal edges of the row -> perform
    1584. 

  1584.          * filtering with FilterHorLuma, otherwise use FilterHorLumaEdge for
    1585. 

  1585.          * each edge separately. offset variable indicates top macroblock edge
    1586. 

  1586.          * on the first loop round, inner edge for the other rounds */
    1587. 

  1587.         if (tmp[0].top == tmp[1].top && tmp[1].top == tmp[2].top &&
    1588. 

  1588.             tmp[2].top == tmp[3].top)
    1589. 

  1589.         {
    1590. 

  1590.             if(tmp[0].top)
    1591. 

  1591.                 FilterHorLuma(ptr, tmp[0].top, thresholds + offset, (i32)width);
    1592. 

  1592.         }
    1593. 

  1593.         else
    1594. 

  1594.         {
    1595. 

  1595.             if(tmp[0].top)
    1596. 

  1596.                 FilterHorLumaEdge(ptr, tmp[0].top, thresholds+offset,
    1597. 

  1597.                     (i32)width);
    1598. 

  1598.             if(tmp[1].top)
    1599. 

  1599.                 FilterHorLumaEdge(ptr+4, tmp[1].top, thresholds+offset,
    1600. 

  1600.                     (i32)width);
    1601. 

  1601.             if(tmp[2].top)
    1602. 

  1602.                 FilterHorLumaEdge(ptr+8, tmp[2].top, thresholds+offset,
    1603. 

  1603.                     (i32)width);
    1604. 

  1604.             if(tmp[3].top)
    1605. 

  1605.                 FilterHorLumaEdge(ptr+12, tmp[3].top, thresholds+offset,
    1606. 

  1606.                     (i32)width);
    1607. 

  1607.         }
    1608. 

  1608. 

  1609.         /* four pixel rows ahead, i.e. next row of 4x4-blocks */
    1610. 

  1610.         ptr += width*4;
    1611. 

  1611.         tmp += 4;
    1612. 

  1612.         offset = INNER;
    1613. 

  1613.     }
    1614. 

  1614. }
    1615. 

  1615. 

  1616. /*------------------------------------------------------------------------------
    1617. 

    1618. 

  1618.     Function: FilterChroma
    1619. 

    1620. 

  1620.         Functional description:
    1621. 

  1621.             Function to filter all chroma edges of a macroblock
    1622. 

    1623. 

  1623. ------------------------------------------------------------------------------*/
    1624. 

  1624. void FilterChroma(
    1625. 

  1625.   u8 *dataCb,
    1626. 

  1626.   u8 *dataCr,
    1627. 

  1627.   bS_t *bS,
    1628. 

  1628.   edgeThreshold_t *thresholds,
    1629. 

  1629.   u32 width)
    1630. 

  1630. {
    1631. 

  1631. 

  1632. /* Variables */
    1633. 

  1633. 

  1634.     u32 vblock;
    1635. 

  1635.     bS_t *tmp;
    1636. 

  1636.     u32 offset;
    1637. 

  1637. 

  1638. /* Code */
    1639. 

  1639. 

  1640.     ASSERT(dataCb);
    1641. 

  1641.     ASSERT(dataCr);
    1642. 

  1642.     ASSERT(bS);
    1643. 

  1643.     ASSERT(thresholds);
    1644. 

  1644. 

  1645.     tmp = bS;
    1646. 

  1646.     offset = TOP;
    1647. 

  1647. 

  1648.     /* loop block rows, perform filtering for all vertical edges of the block
    1649. 

  1649.      * row first, then filter each horizontal edge of the row */
    1650. 

  1650.     for (vblock = 0; vblock < 2; vblock++)
    1651. 

  1651.     {
    1652. 

  1652.         /* only perform filtering if bS is non-zero, first two of the four
    1653. 

  1653.          * FilterVerChromaEdge calls handle the left edge of the macroblock,
    1654. 

  1654.          * others filter the inner edge. Note that as chroma uses bS values
    1655. 

  1655.          * determined for luma edges, each bS is used only for 2 pixels of
    1656. 

  1656.          * a 4-pixel edge */
    1657. 

  1657.         if (tmp[0].left)
    1658. 

  1658.         {
    1659. 

  1659.             FilterVerChromaEdge(dataCb, tmp[0].left, thresholds + LEFT, width);
    1660. 

  1660.             FilterVerChromaEdge(dataCr, tmp[0].left, thresholds + LEFT, width);
    1661. 

  1661.         }
    1662. 

  1662.         if (tmp[4].left)
    1663. 

  1663.         {
    1664. 

  1664.             FilterVerChromaEdge(dataCb+2*width, tmp[4].left, thresholds + LEFT,
    1665. 

  1665.                 width);
    1666. 

  1666.             FilterVerChromaEdge(dataCr+2*width, tmp[4].left, thresholds + LEFT,
    1667. 

  1667.                 width);
    1668. 

  1668.         }
    1669. 

  1669.         if (tmp[2].left)
    1670. 

  1670.         {
    1671. 

  1671.             FilterVerChromaEdge(dataCb+4, tmp[2].left, thresholds + INNER,
    1672. 

  1672.                 width);
    1673. 

  1673.             FilterVerChromaEdge(dataCr+4, tmp[2].left, thresholds + INNER,
    1674. 

  1674.                 width);
    1675. 

  1675.         }
    1676. 

  1676.         if (tmp[6].left)
    1677. 

  1677.         {
    1678. 

  1678.             FilterVerChromaEdge(dataCb+2*width+4, tmp[6].left,
    1679. 

  1679.                 thresholds + INNER, width);
    1680. 

  1680.             FilterVerChromaEdge(dataCr+2*width+4, tmp[6].left,
    1681. 

  1681.                 thresholds + INNER, width);
    1682. 

  1682.         }
    1683. 

  1683. 

  1684.         /* if bS is equal for all horizontal edges of the row -> perform
    1685. 

  1685.          * filtering with FilterHorChroma, otherwise use FilterHorChromaEdge
    1686. 

  1686.          * for each edge separately. offset variable indicates top macroblock
    1687. 

  1687.          * edge on the first loop round, inner edge for the second */
    1688. 

  1688.         if (tmp[0].top == tmp[1].top && tmp[1].top == tmp[2].top &&
    1689. 

  1689.             tmp[2].top == tmp[3].top)
    1690. 

  1690.         {
    1691. 

  1691.             if(tmp[0].top)
    1692. 

  1692.             {
    1693. 

  1693.                 FilterHorChroma(dataCb, tmp[0].top, thresholds+offset,
    1694. 

  1694.                     (i32)width);
    1695. 

  1695.                 FilterHorChroma(dataCr, tmp[0].top, thresholds+offset,
    1696. 

  1696.                     (i32)width);
    1697. 

  1697.             }
    1698. 

  1698.         }
    1699. 

  1699.         else
    1700. 

  1700.         {
    1701. 

  1701.             if (tmp[0].top)
    1702. 

  1702.             {
    1703. 

  1703.                 FilterHorChromaEdge(dataCb, tmp[0].top, thresholds+offset,
    1704. 

  1704.                     (i32)width);
    1705. 

  1705.                 FilterHorChromaEdge(dataCr, tmp[0].top, thresholds+offset,
    1706. 

  1706.                     (i32)width);
    1707. 

  1707.             }
    1708. 

  1708.             if (tmp[1].top)
    1709. 

  1709.             {
    1710. 

  1710.                 FilterHorChromaEdge(dataCb+2, tmp[1].top, thresholds+offset,
    1711. 

  1711.                     (i32)width);
    1712. 

  1712.                 FilterHorChromaEdge(dataCr+2, tmp[1].top, thresholds+offset,
    1713. 

  1713.                     (i32)width);
    1714. 

  1714.             }
    1715. 

  1715.             if (tmp[2].top)
    1716. 

  1716.             {
    1717. 

  1717.                 FilterHorChromaEdge(dataCb+4, tmp[2].top, thresholds+offset,
    1718. 

  1718.                     (i32)width);
    1719. 

  1719.                 FilterHorChromaEdge(dataCr+4, tmp[2].top, thresholds+offset,
    1720. 

  1720.                     (i32)width);
    1721. 

  1721.             }
    1722. 

  1722.             if (tmp[3].top)
    1723. 

  1723.             {
    1724. 

  1724.                 FilterHorChromaEdge(dataCb+6, tmp[3].top, thresholds+offset,
    1725. 

  1725.                     (i32)width);
    1726. 

  1726.                 FilterHorChromaEdge(dataCr+6, tmp[3].top, thresholds+offset,
    1727. 

  1727.                     (i32)width);
    1728. 

  1728.             }
    1729. 

  1729.         }
    1730. 

  1730. 

  1731.         tmp += 8;
    1732. 

  1732.         dataCb += width*4;
    1733. 

  1733.         dataCr += width*4;
    1734. 

  1734.         offset = INNER;
    1735. 

  1735.     }
    1736. 

  1736. }
    1737. 

  1737. 

  1738. #else /* H264DEC_OMXDL */
    1739. 

  1739. 

  1740. /*------------------------------------------------------------------------------
    1741. 

    1742. 

  1742.     Function: h264bsdFilterPicture
    1743. 

    1744. 

  1744.         Functional description:
    1745. 

  1745.           Perform deblocking filtering for a picture. Filter does not copy
    1746. 

  1746.           the original picture anywhere but filtering is performed directly
    1747. 

  1747.           on the original image. Parameters controlling the filtering process
    1748. 

  1748.           are computed based on information in macroblock structures of the
    1749. 

  1749.           filtered macroblock, macroblock above and macroblock on the left of
    1750. 

  1750.           the filtered one.
    1751. 

    1752. 

  1752.         Inputs:
    1753. 

  1753.           image         pointer to image to be filtered
    1754. 

  1754.           mb            pointer to macroblock data structure of the top-left
    1755. 

  1755.                         macroblock of the picture
    1756. 

    1757. 

  1757.         Outputs:
    1758. 

  1758.           image         filtered image stored here
    1759. 

    1760. 

  1760.         Returns:
    1761. 

  1761.           none
    1762. 

    1763. 

  1763. ------------------------------------------------------------------------------*/
    1764. 

  1764. 

  1765. /*lint --e{550} Symbol not accessed */
    1766. 

  1766. void h264bsdFilterPicture(
    1767. 

  1767.   image_t *image,
    1768. 

  1768.   mbStorage_t *mb)
    1769. 

  1769. {
    1770. 

  1770. 

  1771. /* Variables */
    1772. 

  1772. 

  1773.     u32 flags;
    1774. 

  1774.     u32 picSizeInMbs, mbRow, mbCol;
    1775. 

  1775.     u32 picWidthInMbs;
    1776. 

  1776.     u8 *data;
    1777. 

  1777.     mbStorage_t *pMb;
    1778. 

  1778.     u8 bS[2][16];
    1779. 

  1779.     u8 thresholdLuma[2][16];
    1780. 

  1780.     u8 thresholdChroma[2][8];
    1781. 

  1781.     u8 alpha[2][2];
    1782. 

  1782.     u8 beta[2][2];
    1783. 

  1783.     OMXResult res;
    1784. 

  1784. 

  1785. /* Code */
    1786. 

  1786. 

  1787.     ASSERT(image);
    1788. 

  1788.     ASSERT(mb);
    1789. 

  1789.     ASSERT(image->data);
    1790. 

  1790.     ASSERT(image->width);
    1791. 

  1791.     ASSERT(image->height);
    1792. 

  1792. 

  1793.     picWidthInMbs = image->width;
    1794. 

  1794.     data = image->data;
    1795. 

  1795.     picSizeInMbs = picWidthInMbs * image->height;
    1796. 

  1796. 

  1797.     pMb = mb;
    1798. 

  1798. 

  1799.     for (mbRow = 0, mbCol = 0; mbRow < image->height; pMb++)
    1800. 

  1800.     {
    1801. 

  1801.         flags = GetMbFilteringFlags(pMb);
    1802. 

  1802. 

  1803.         if (flags)
    1804. 

  1804.         {
    1805. 

  1805.             /* GetBoundaryStrengths function returns non-zero value if any of
    1806. 

  1806.              * the bS values for the macroblock being processed was non-zero */
    1807. 

  1807.             if (GetBoundaryStrengths(pMb, bS, flags))
    1808. 

  1808.             {
    1809. 

  1809. 

  1810.                 /* Luma */
    1811. 

  1811.                 GetLumaEdgeThresholds(pMb,alpha,beta,thresholdLuma,bS,flags);
    1812. 

  1812.                 data = image->data + mbRow * picWidthInMbs * 256 + mbCol * 16;
    1813. 

  1813. 

  1814.                 res = omxVCM4P10_FilterDeblockingLuma_VerEdge_I( data,
    1815. 

  1815.                                                 (OMX_S32)(picWidthInMbs*16),
    1816. 

  1816.                                                 (const OMX_U8*)alpha,
    1817. 

  1817.                                                 (const OMX_U8*)beta,
    1818. 

  1818.                                                 (const OMX_U8*)thresholdLuma,
    1819. 

  1819.                                                 (const OMX_U8*)bS );
    1820. 

  1820. 

  1821.                 res = omxVCM4P10_FilterDeblockingLuma_HorEdge_I( data,
    1822. 

  1822.                                                 (OMX_S32)(picWidthInMbs*16),
    1823. 

  1823.                                                 (const OMX_U8*)alpha+2,
    1824. 

  1824.                                                 (const OMX_U8*)beta+2,
    1825. 

  1825.                                                 (const OMX_U8*)thresholdLuma+16,
    1826. 

  1826.                                                 (const OMX_U8*)bS+16 );
    1827. 

  1827.                 /* Cb */
    1828. 

  1828.                 GetChromaEdgeThresholds(pMb, alpha, beta, thresholdChroma,
    1829. 

  1829.                                         bS, flags, pMb->chromaQpIndexOffset);
    1830. 

  1830.                 data = image->data + picSizeInMbs * 256 +
    1831. 

  1831.                     mbRow * picWidthInMbs * 64 + mbCol * 8;
    1832. 

  1832. 

  1833.                 res = omxVCM4P10_FilterDeblockingChroma_VerEdge_I( data,
    1834. 

  1834.                                               (OMX_S32)(picWidthInMbs*8),
    1835. 

  1835.                                               (const OMX_U8*)alpha,
    1836. 

  1836.                                               (const OMX_U8*)beta,
    1837. 

  1837.                                               (const OMX_U8*)thresholdChroma,
    1838. 

  1838.                                               (const OMX_U8*)bS );
    1839. 

  1839.                 res = omxVCM4P10_FilterDeblockingChroma_HorEdge_I( data,
    1840. 

  1840.                                               (OMX_S32)(picWidthInMbs*8),
    1841. 

  1841.                                               (const OMX_U8*)alpha+2,
    1842. 

  1842.                                               (const OMX_U8*)beta+2,
    1843. 

  1843.                                               (const OMX_U8*)thresholdChroma+8,
    1844. 

  1844.                                               (const OMX_U8*)bS+16 );
    1845. 

  1845.                 /* Cr */
    1846. 

  1846.                 data += (picSizeInMbs * 64);
    1847. 

  1847.                 res = omxVCM4P10_FilterDeblockingChroma_VerEdge_I( data,
    1848. 

  1848.                                               (OMX_S32)(picWidthInMbs*8),
    1849. 

  1849.                                               (const OMX_U8*)alpha,
    1850. 

  1850.                                               (const OMX_U8*)beta,
    1851. 

  1851.                                               (const OMX_U8*)thresholdChroma,
    1852. 

  1852.                                               (const OMX_U8*)bS );
    1853. 

  1853.                 res = omxVCM4P10_FilterDeblockingChroma_HorEdge_I( data,
    1854. 

  1854.                                               (OMX_S32)(picWidthInMbs*8),
    1855. 

  1855.                                               (const OMX_U8*)alpha+2,
    1856. 

  1856.                                               (const OMX_U8*)beta+2,
    1857. 

  1857.                                               (const OMX_U8*)thresholdChroma+8,
    1858. 

  1858.                                               (const OMX_U8*)bS+16 );
    1859. 

  1859.             }
    1860. 

  1860.         }
    1861. 

  1861. 

  1862.         mbCol++;
    1863. 

  1863.         if (mbCol == picWidthInMbs)
    1864. 

  1864.         {
    1865. 

  1865.             mbCol = 0;
    1866. 

  1866.             mbRow++;
    1867. 

  1867.         }
    1868. 

  1868.     }
    1869. 

  1869. 

  1870. }
    1871. 

  1871. 

  1872. /*------------------------------------------------------------------------------
    1873. 

    1874. 

  1874.     Function: GetBoundaryStrengths
    1875. 

    1876. 

  1876.         Functional description:
    1877. 

  1877.             Function to calculate boundary strengths for all edges of a
    1878. 

  1878.             macroblock. Function returns HANTRO_TRUE if any of the bS values for
    1879. 

  1879.             the macroblock had non-zero value, HANTRO_FALSE otherwise.
    1880. 

    1881. 

  1881. ------------------------------------------------------------------------------*/
    1882. 

  1882. u32 GetBoundaryStrengths(mbStorage_t *mb, u8 (*bS)[16], u32 flags)
    1883. 

  1883. {
    1884. 

  1884. 

  1885. /* Variables */
    1886. 

  1886. 

  1887.     /* this flag is set HANTRO_TRUE as soon as any boundary strength value is
    1888. 

  1888.      * non-zero */
    1889. 

  1889.     u32 nonZeroBs = HANTRO_FALSE;
    1890. 

  1890.     u32 *pTmp;
    1891. 

  1891.     u32 tmp1, tmp2, isIntraMb;
    1892. 

  1892. 

  1893. /* Code */
    1894. 

  1894. 

  1895.     ASSERT(mb);
    1896. 

  1896.     ASSERT(bS);
    1897. 

  1897.     ASSERT(flags);
    1898. 

  1898. 

  1899.     isIntraMb = IS_INTRA_MB(*mb);
    1900. 

  1900. 

  1901.     /* top edges */
    1902. 

  1902.     pTmp = (u32*)&bS[1][0];
    1903. 

  1903.     if (flags & FILTER_TOP_EDGE)
    1904. 

  1904.     {
    1905. 

  1905.         if (isIntraMb || IS_INTRA_MB(*mb->mbB))
    1906. 

  1906.         {
    1907. 

  1907.             *pTmp = 0x04040404;
    1908. 

  1908.             nonZeroBs = HANTRO_TRUE;
    1909. 

  1909.         }
    1910. 

  1910.         else
    1911. 

  1911.         {
    1912. 

  1912.             *pTmp = EdgeBoundaryStrengthTop(mb, mb->mbB);
    1913. 

  1913.             if (*pTmp)
    1914. 

  1914.                 nonZeroBs = HANTRO_TRUE;
    1915. 

  1915.         }
    1916. 

  1916.     }
    1917. 

  1917.     else
    1918. 

  1918.     {
    1919. 

  1919.         *pTmp = 0;
    1920. 

  1920.     }
    1921. 

  1921. 

  1922.     /* left edges */
    1923. 

  1923.     pTmp = (u32*)&bS[0][0];
    1924. 

  1924.     if (flags & FILTER_LEFT_EDGE)
    1925. 

  1925.     {
    1926. 

  1926.         if (isIntraMb || IS_INTRA_MB(*mb->mbA))
    1927. 

  1927.         {
    1928. 

  1928.             /*bS[0][0] = bS[0][1] = bS[0][2] = bS[0][3] = 4;*/
    1929. 

  1929.             *pTmp = 0x04040404;
    1930. 

  1930.             nonZeroBs = HANTRO_TRUE;
    1931. 

  1931.         }
    1932. 

  1932.         else
    1933. 

  1933.         {
    1934. 

  1934.             *pTmp = EdgeBoundaryStrengthLeft(mb, mb->mbA);
    1935. 

  1935.             if (!nonZeroBs && *pTmp)
    1936. 

  1936.                 nonZeroBs = HANTRO_TRUE;
    1937. 

  1937.         }
    1938. 

  1938.     }
    1939. 

  1939.     else
    1940. 

  1940.     {
    1941. 

  1941.         *pTmp = 0;
    1942. 

  1942.     }
    1943. 

  1943. 

  1944.     /* inner edges */
    1945. 

  1945.     if (isIntraMb)
    1946. 

  1946.     {
    1947. 

  1947.         pTmp++;
    1948. 

  1948.         *pTmp++ = 0x03030303;
    1949. 

  1949.         *pTmp++ = 0x03030303;
    1950. 

  1950.         *pTmp++ = 0x03030303;
    1951. 

  1951.         pTmp++;
    1952. 

  1952.         *pTmp++ = 0x03030303;
    1953. 

  1953.         *pTmp++ = 0x03030303;
    1954. 

  1954.         *pTmp = 0x03030303;
    1955. 

  1955. 

  1956.         nonZeroBs = HANTRO_TRUE;
    1957. 

  1957.     }
    1958. 

  1958.     else
    1959. 

  1959.     {
    1960. 

  1960.         pTmp = (u32*)mb->totalCoeff;
    1961. 

  1961. 

  1962.         /* 16x16 inter mb -> ref addresses or motion vectors cannot differ,
    1963. 

  1963.          * only check if either of the blocks contain coefficients */
    1964. 

  1964.         if (h264bsdNumMbPart(mb->mbType) == 1)
    1965. 

  1965.         {
    1966. 

  1966.             tmp1 = *pTmp++;
    1967. 

  1967.             tmp2 = *pTmp++;
    1968. 

  1968.             bS[1][4]  = (tmp1 & 0x00FF00FF) ? 2 : 0; /* [2]  || [0] */
    1969. 

  1969.             bS[1][5]  = (tmp1 & 0xFF00FF00) ? 2 : 0; /* [3]  || [1] */
    1970. 

  1970.             bS[0][4]  = (tmp1 & 0x0000FFFF) ? 2 : 0; /* [1]  || [0] */
    1971. 

  1971.             bS[0][5]  = (tmp1 & 0xFFFF0000) ? 2 : 0; /* [3]  || [2] */
    1972. 

  1972. 

  1973.             tmp1 = *pTmp++;
    1974. 

  1974.             bS[1][6]  = (tmp2 & 0x00FF00FF) ? 2 : 0; /* [6]  || [4] */
    1975. 

  1975.             bS[1][7]  = (tmp2 & 0xFF00FF00) ? 2 : 0; /* [7]  || [5] */
    1976. 

  1976.             bS[0][12] = (tmp2 & 0x0000FFFF) ? 2 : 0; /* [5]  || [4] */
    1977. 

  1977.             bS[0][13] = (tmp2 & 0xFFFF0000) ? 2 : 0; /* [7]  || [6] */
    1978. 

  1978.             tmp2 = *pTmp;
    1979. 

  1979.             bS[1][12] = (tmp1 & 0x00FF00FF) ? 2 : 0; /* [10] || [8] */
    1980. 

  1980.             bS[1][13] = (tmp1 & 0xFF00FF00) ? 2 : 0; /* [11] || [9] */
    1981. 

  1981.             bS[0][6]  = (tmp1 & 0x0000FFFF) ? 2 : 0; /* [9]  || [8] */
    1982. 

  1982.             bS[0][7]  = (tmp1 & 0xFFFF0000) ? 2 : 0; /* [11] || [10] */
    1983. 

  1983. 

  1984.             bS[1][14] = (tmp2 & 0x00FF00FF) ? 2 : 0; /* [14] || [12] */
    1985. 

  1985.             bS[1][15] = (tmp2 & 0xFF00FF00) ? 2 : 0; /* [15] || [13] */
    1986. 

  1986.             bS[0][14] = (tmp2 & 0x0000FFFF) ? 2 : 0; /* [13] || [12] */
    1987. 

  1987.             bS[0][15] = (tmp2 & 0xFFFF0000) ? 2 : 0; /* [15] || [14] */
    1988. 

  1988. 

  1989.             {
    1990. 

  1990.             u32 tmp3, tmp4;
    1991. 

  1991. 

  1992.             tmp1 = mb->totalCoeff[8];
    1993. 

  1993.             tmp2 = mb->totalCoeff[2];
    1994. 

  1994.             tmp3 = mb->totalCoeff[9];
    1995. 

  1995.             tmp4 = mb->totalCoeff[3];
    1996. 

  1996. 

  1997.             bS[1][8] = tmp1 || tmp2 ? 2 : 0;
    1998. 

  1998.             tmp1 = mb->totalCoeff[12];
    1999. 

  1999.             tmp2 = mb->totalCoeff[6];
    2000. 

  2000.             bS[1][9] = tmp3 || tmp4 ? 2 : 0;
    2001. 

  2001.             tmp3 = mb->totalCoeff[13];
    2002. 

  2002.             tmp4 = mb->totalCoeff[7];
    2003. 

  2003.             bS[1][10] = tmp1 || tmp2 ? 2 : 0;
    2004. 

  2004.             tmp1 = mb->totalCoeff[4];
    2005. 

  2005.             tmp2 = mb->totalCoeff[1];
    2006. 

  2006.             bS[1][11] = tmp3 || tmp4 ? 2 : 0;
    2007. 

  2007.             tmp3 = mb->totalCoeff[6];
    2008. 

  2008.             tmp4 = mb->totalCoeff[3];
    2009. 

  2009.             bS[0][8] = tmp1 || tmp2 ? 2 : 0;
    2010. 

  2010.             tmp1 = mb->totalCoeff[12];
    2011. 

  2011.             tmp2 = mb->totalCoeff[9];
    2012. 

  2012.             bS[0][9] = tmp3 || tmp4 ? 2 : 0;
    2013. 

  2013.             tmp3 = mb->totalCoeff[14];
    2014. 

  2014.             tmp4 = mb->totalCoeff[11];
    2015. 

  2015.             bS[0][10] = tmp1 || tmp2 ? 2 : 0;
    2016. 

  2016.             bS[0][11] = tmp3 || tmp4 ? 2 : 0;
    2017. 

  2017.             }
    2018. 

  2018.         }
    2019. 

  2019. 

  2020.         /* 16x8 inter mb -> ref addresses and motion vectors can be different
    2021. 

  2021.          * only for the middle horizontal edge, for the other top edges it is
    2022. 

  2022.          * enough to check whether the blocks contain coefficients or not. The
    2023. 

  2023.          * same applies to all internal left edges. */
    2024. 

  2024.         else if (mb->mbType == P_L0_L0_16x8)
    2025. 

  2025.         {
    2026. 

  2026.             tmp1 = *pTmp++;
    2027. 

  2027.             tmp2 = *pTmp++;
    2028. 

  2028.             bS[1][4]  = (tmp1 & 0x00FF00FF) ? 2 : 0; /* [2]  || [0] */
    2029. 

  2029.             bS[1][5]  = (tmp1 & 0xFF00FF00) ? 2 : 0; /* [3]  || [1] */
    2030. 

  2030.             bS[0][4]  = (tmp1 & 0x0000FFFF) ? 2 : 0; /* [1]  || [0] */
    2031. 

  2031.             bS[0][5]  = (tmp1 & 0xFFFF0000) ? 2 : 0; /* [3]  || [2] */
    2032. 

  2032.             tmp1 = *pTmp++;
    2033. 

  2033.             bS[1][6]  = (tmp2 & 0x00FF00FF) ? 2 : 0; /* [6]  || [4] */
    2034. 

  2034.             bS[1][7]  = (tmp2 & 0xFF00FF00) ? 2 : 0; /* [7]  || [5] */
    2035. 

  2035.             bS[0][12] = (tmp2 & 0x0000FFFF) ? 2 : 0; /* [5]  || [4] */
    2036. 

  2036.             bS[0][13] = (tmp2 & 0xFFFF0000) ? 2 : 0; /* [7]  || [6] */
    2037. 

  2037.             tmp2 = *pTmp;
    2038. 

  2038.             bS[1][12] = (tmp1 & 0x00FF00FF) ? 2 : 0; /* [10] || [8] */
    2039. 

  2039.             bS[1][13] = (tmp1 & 0xFF00FF00) ? 2 : 0; /* [11] || [9] */
    2040. 

  2040.             bS[0][6]  = (tmp1 & 0x0000FFFF) ? 2 : 0; /* [9]  || [8] */
    2041. 

  2041.             bS[0][7]  = (tmp1 & 0xFFFF0000) ? 2 : 0; /* [11] || [10] */
    2042. 

  2042. 

  2043.             bS[1][14] = (tmp2 & 0x00FF00FF) ? 2 : 0; /* [14] || [12] */
    2044. 

  2044.             bS[1][15] = (tmp2 & 0xFF00FF00) ? 2 : 0; /* [15] || [13] */
    2045. 

  2045.             bS[0][14] = (tmp2 & 0x0000FFFF) ? 2 : 0; /* [13] || [12] */
    2046. 

  2046.             bS[0][15] = (tmp2 & 0xFFFF0000) ? 2 : 0; /* [15] || [14] */
    2047. 

  2047. 

  2048.             bS[1][8] = (u8)InnerBoundaryStrength(mb, 8, 2);
    2049. 

  2049.             bS[1][9] = (u8)InnerBoundaryStrength(mb, 9, 3);
    2050. 

  2050.             bS[1][10] = (u8)InnerBoundaryStrength(mb, 12, 6);
    2051. 

  2051.             bS[1][11] = (u8)InnerBoundaryStrength(mb, 13, 7);
    2052. 

  2052. 

  2053.             {
    2054. 

  2054.             u32 tmp3, tmp4;
    2055. 

  2055. 

  2056.             tmp1 = mb->totalCoeff[4];
    2057. 

  2057.             tmp2 = mb->totalCoeff[1];
    2058. 

  2058.             tmp3 = mb->totalCoeff[6];
    2059. 

  2059.             tmp4 = mb->totalCoeff[3];
    2060. 

  2060.             bS[0][8] = tmp1 || tmp2 ? 2 : 0;
    2061. 

  2061.             tmp1 = mb->totalCoeff[12];
    2062. 

  2062.             tmp2 = mb->totalCoeff[9];
    2063. 

  2063.             bS[0][9] = tmp3 || tmp4 ? 2 : 0;
    2064. 

  2064.             tmp3 = mb->totalCoeff[14];
    2065. 

  2065.             tmp4 = mb->totalCoeff[11];
    2066. 

  2066.             bS[0][10] = tmp1 || tmp2 ? 2 : 0;
    2067. 

  2067.             bS[0][11] = tmp3 || tmp4 ? 2 : 0;
    2068. 

  2068.             }
    2069. 

  2069.         }
    2070. 

  2070.         /* 8x16 inter mb -> ref addresses and motion vectors can be different
    2071. 

  2071.          * only for the middle vertical edge, for the other left edges it is
    2072. 

  2072.          * enough to check whether the blocks contain coefficients or not. The
    2073. 

  2073.          * same applies to all internal top edges. */
    2074. 

  2074.         else if (mb->mbType == P_L0_L0_8x16)
    2075. 

  2075.         {
    2076. 

  2076.             tmp1 = *pTmp++;
    2077. 

  2077.             tmp2 = *pTmp++;
    2078. 

  2078.             bS[1][4]  = (tmp1 & 0x00FF00FF) ? 2 : 0; /* [2]  || [0] */
    2079. 

  2079.             bS[1][5]  = (tmp1 & 0xFF00FF00) ? 2 : 0; /* [3]  || [1] */
    2080. 

  2080.             bS[0][4]  = (tmp1 & 0x0000FFFF) ? 2 : 0; /* [1]  || [0] */
    2081. 

  2081.             bS[0][5]  = (tmp1 & 0xFFFF0000) ? 2 : 0; /* [3]  || [2] */
    2082. 

  2082.             tmp1 = *pTmp++;
    2083. 

  2083.             bS[1][6]  = (tmp2 & 0x00FF00FF) ? 2 : 0; /* [6]  || [4] */
    2084. 

  2084.             bS[1][7]  = (tmp2 & 0xFF00FF00) ? 2 : 0; /* [7]  || [5] */
    2085. 

  2085.             bS[0][12] = (tmp2 & 0x0000FFFF) ? 2 : 0; /* [5]  || [4] */
    2086. 

  2086.             bS[0][13] = (tmp2 & 0xFFFF0000) ? 2 : 0; /* [7]  || [6] */
    2087. 

  2087.             tmp2 = *pTmp;
    2088. 

  2088.             bS[1][12] = (tmp1 & 0x00FF00FF) ? 2 : 0; /* [10] || [8] */
    2089. 

  2089.             bS[1][13] = (tmp1 & 0xFF00FF00) ? 2 : 0; /* [11] || [9] */
    2090. 

  2090.             bS[0][6]  = (tmp1 & 0x0000FFFF) ? 2 : 0; /* [9]  || [8] */
    2091. 

  2091.             bS[0][7]  = (tmp1 & 0xFFFF0000) ? 2 : 0; /* [11] || [10] */
    2092. 

  2092. 

  2093.             bS[1][14] = (tmp2 & 0x00FF00FF) ? 2 : 0; /* [14] || [12] */
    2094. 

  2094.             bS[1][15] = (tmp2 & 0xFF00FF00) ? 2 : 0; /* [15] || [13] */
    2095. 

  2095.             bS[0][14] = (tmp2 & 0x0000FFFF) ? 2 : 0; /* [13] || [12] */
    2096. 

  2096.             bS[0][15] = (tmp2 & 0xFFFF0000) ? 2 : 0; /* [15] || [14] */
    2097. 

  2097. 

  2098.             bS[0][8] = (u8)InnerBoundaryStrength(mb, 4, 1);
    2099. 

  2099.             bS[0][9] = (u8)InnerBoundaryStrength(mb, 6, 3);
    2100. 

  2100.             bS[0][10] = (u8)InnerBoundaryStrength(mb, 12, 9);
    2101. 

  2101.             bS[0][11] = (u8)InnerBoundaryStrength(mb, 14, 11);
    2102. 

  2102. 

  2103.             {
    2104. 

  2104.             u32 tmp3, tmp4;
    2105. 

  2105. 

  2106.             tmp1 = mb->totalCoeff[8];
    2107. 

  2107.             tmp2 = mb->totalCoeff[2];
    2108. 

  2108.             tmp3 = mb->totalCoeff[9];
    2109. 

  2109.             tmp4 = mb->totalCoeff[3];
    2110. 

  2110.             bS[1][8] = tmp1 || tmp2 ? 2 : 0;
    2111. 

  2111.             tmp1 = mb->totalCoeff[12];
    2112. 

  2112.             tmp2 = mb->totalCoeff[6];
    2113. 

  2113.             bS[1][9] = tmp3 || tmp4 ? 2 : 0;
    2114. 

  2114.             tmp3 = mb->totalCoeff[13];
    2115. 

  2115.             tmp4 = mb->totalCoeff[7];
    2116. 

  2116.             bS[1][10] = tmp1 || tmp2 ? 2 : 0;
    2117. 

  2117.             bS[1][11] = tmp3 || tmp4 ? 2 : 0;
    2118. 

  2118.             }
    2119. 

  2119.         }
    2120. 

  2120.         else
    2121. 

  2121.         {
    2122. 

  2122.             tmp1 = *pTmp++;
    2123. 

  2123.             bS[1][4] = (tmp1 & 0x00FF00FF) ? 2 : (u8)InnerBoundaryStrength2(mb, 2, 0);
    2124. 

  2124.             bS[1][5] = (tmp1 & 0xFF00FF00) ? 2 : (u8)InnerBoundaryStrength2(mb, 3, 1);
    2125. 

  2125.             bS[0][4] = (tmp1 & 0x0000FFFF) ? 2 : (u8)InnerBoundaryStrength2(mb, 1, 0);
    2126. 

  2126.             bS[0][5] = (tmp1 & 0xFFFF0000) ? 2 : (u8)InnerBoundaryStrength2(mb, 3, 2);
    2127. 

  2127.             tmp1 = *pTmp++;
    2128. 

  2128.             bS[1][6]  = (tmp1 & 0x00FF00FF) ? 2 : (u8)InnerBoundaryStrength2(mb, 6, 4);
    2129. 

  2129.             bS[1][7]  = (tmp1 & 0xFF00FF00) ? 2 : (u8)InnerBoundaryStrength2(mb, 7, 5);
    2130. 

  2130.             bS[0][12] = (tmp1 & 0x0000FFFF) ? 2 : (u8)InnerBoundaryStrength2(mb, 5, 4);
    2131. 

  2131.             bS[0][13] = (tmp1 & 0xFFFF0000) ? 2 : (u8)InnerBoundaryStrength2(mb, 7, 6);
    2132. 

  2132.             tmp1 = *pTmp++;
    2133. 

  2133.             bS[1][12] = (tmp1 & 0x00FF00FF) ? 2 : (u8)InnerBoundaryStrength2(mb, 10, 8);
    2134. 

  2134.             bS[1][13] = (tmp1 & 0xFF00FF00) ? 2 : (u8)InnerBoundaryStrength2(mb, 11, 9);
    2135. 

  2135.             bS[0][6]  = (tmp1 & 0x0000FFFF) ? 2 : (u8)InnerBoundaryStrength2(mb, 9, 8);
    2136. 

  2136.             bS[0][7]  = (tmp1 & 0xFFFF0000) ? 2 : (u8)InnerBoundaryStrength2(mb, 11, 10);
    2137. 

  2137.             tmp1 = *pTmp;
    2138. 

  2138.             bS[1][14] = (tmp1 & 0x00FF00FF) ? 2 : (u8)InnerBoundaryStrength2(mb, 14, 12);
    2139. 

  2139.             bS[1][15] = (tmp1 & 0xFF00FF00) ? 2 : (u8)InnerBoundaryStrength2(mb, 15, 13);
    2140. 

  2140.             bS[0][14] = (tmp1 & 0x0000FFFF) ? 2 : (u8)InnerBoundaryStrength2(mb, 13, 12);
    2141. 

  2141.             bS[0][15] = (tmp1 & 0xFFFF0000) ? 2 : (u8)InnerBoundaryStrength2(mb, 15, 14);
    2142. 

  2142. 

  2143.             bS[1][8] = (u8)InnerBoundaryStrength(mb, 8, 2);
    2144. 

  2144.             bS[1][9] = (u8)InnerBoundaryStrength(mb, 9, 3);
    2145. 

  2145.             bS[1][10] = (u8)InnerBoundaryStrength(mb, 12, 6);
    2146. 

  2146.             bS[1][11] = (u8)InnerBoundaryStrength(mb, 13, 7);
    2147. 

  2147. 

  2148.             bS[0][8] = (u8)InnerBoundaryStrength(mb, 4, 1);
    2149. 

  2149.             bS[0][9] = (u8)InnerBoundaryStrength(mb, 6, 3);
    2150. 

  2150.             bS[0][10] = (u8)InnerBoundaryStrength(mb, 12, 9);
    2151. 

  2151.             bS[0][11] = (u8)InnerBoundaryStrength(mb, 14, 11);
    2152. 

  2152.         }
    2153. 

  2153.         pTmp = (u32*)&bS[0][0];
    2154. 

  2154.         if (!nonZeroBs && (pTmp[1] || pTmp[2] || pTmp[3] ||
    2155. 

  2155.                            pTmp[5] || pTmp[6] || pTmp[7]) )
    2156. 

  2156.         {
    2157. 

  2157.             nonZeroBs = HANTRO_TRUE;
    2158. 

  2158.         }
    2159. 

  2159.     }
    2160. 

  2160. 

  2161.     return(nonZeroBs);
    2162. 

  2162. 

  2163. }
    2164. 

  2164. 

  2165. /*------------------------------------------------------------------------------
    2166. 

    2167. 

  2167.     Function: GetLumaEdgeThresholds
    2168. 

    2169. 

  2169.         Functional description:
    2170. 

  2170.             Compute alpha, beta and tc0 thresholds for inner, left and top
    2171. 

  2171.             luma edges of a macroblock.
    2172. 

    2173. 

  2173. ------------------------------------------------------------------------------*/
    2174. 

  2174. void GetLumaEdgeThresholds(
    2175. 

  2175.     mbStorage_t *mb,
    2176. 

  2176.     u8 (*alpha)[2],
    2177. 

  2177.     u8 (*beta)[2],
    2178. 

  2178.     u8 (*threshold)[16],
    2179. 

  2179.     u8 (*bs)[16],
    2180. 

  2180.     u32 filteringFlags )
    2181. 

  2181. {
    2182. 

  2182. 

  2183. /* Variables */
    2184. 

  2184. 

  2185.     u32 indexA, indexB;
    2186. 

  2186.     u32 qpAv, qp, qpTmp;
    2187. 

  2187.     u32 i;
    2188. 

  2188. 

  2189. /* Code */
    2190. 

  2190. 

  2191.     ASSERT(threshold);
    2192. 

  2192.     ASSERT(bs);
    2193. 

  2193.     ASSERT(beta);
    2194. 

  2194.     ASSERT(alpha);
    2195. 

  2195.     ASSERT(mb);
    2196. 

  2196. 

  2197.     qp = mb->qpY;
    2198. 

  2198. 

  2199.     indexA = (u32)CLIP3(0, 51, (i32)qp + mb->filterOffsetA);
    2200. 

  2200.     indexB = (u32)CLIP3(0, 51, (i32)qp + mb->filterOffsetB);
    2201. 

  2201. 

  2202.     /* Internal edge values */
    2203. 

  2203.     alpha[0][1] = alphas[indexA];
    2204. 

  2204.     alpha[1][1] = alphas[indexA];
    2205. 

  2205.     alpha[1][0] = alphas[indexA];
    2206. 

  2206.     alpha[0][0] = alphas[indexA];
    2207. 

  2207.     beta[0][1] = betas[indexB];
    2208. 

  2208.     beta[1][1] = betas[indexB];
    2209. 

  2209.     beta[1][0] = betas[indexB];
    2210. 

  2210.     beta[0][0] = betas[indexB];
    2211. 

  2211. 

  2212.     /* vertical scan order */
    2213. 

  2213.     for (i = 0; i < 2; i++)
    2214. 

  2214.     {
    2215. 

  2215.         u32 t1, t2;
    2216. 

  2216. 

  2217.         t1 = bs[i][0];
    2218. 

  2218.         t2 = bs[i][1];
    2219. 

  2219.         threshold[i][0]  = (t1) ? tc0[indexA][t1] : 0;
    2220. 

  2220.         t1 = bs[i][2];
    2221. 

  2221.         threshold[i][1]  = (t2) ? tc0[indexA][t2] : 0;
    2222. 

  2222.         t2 = bs[i][3];
    2223. 

  2223.         threshold[i][2]  = (t1) ? tc0[indexA][t1] : 0;
    2224. 

  2224.         t1 = bs[i][4];
    2225. 

  2225.         threshold[i][3]  = (t2) ? tc0[indexA][t2] : 0;
    2226. 

  2226.         t2 = bs[i][5];
    2227. 

  2227.         threshold[i][4]  = (t1) ? tc0[indexA][t1] : 0;
    2228. 

  2228.         t1 = bs[i][6];
    2229. 

  2229.         threshold[i][5]  = (t2) ? tc0[indexA][t2] : 0;
    2230. 

  2230.         t2 = bs[i][7];
    2231. 

  2231.         threshold[i][6]  = (t1) ? tc0[indexA][t1] : 0;
    2232. 

  2232.         t1 = bs[i][8];
    2233. 

  2233.         threshold[i][7]  = (t2) ? tc0[indexA][t2] : 0;
    2234. 

  2234.         t2 = bs[i][9];
    2235. 

  2235.         threshold[i][8]  = (t1) ? tc0[indexA][t1] : 0;
    2236. 

  2236.         t1 = bs[i][10];
    2237. 

  2237.         threshold[i][9]  = (t2) ? tc0[indexA][t2] : 0;
    2238. 

  2238.         t2 = bs[i][11];
    2239. 

  2239.         threshold[i][10] = (t1) ? tc0[indexA][t1] : 0;
    2240. 

  2240.         t1 = bs[i][12];
    2241. 

  2241.         threshold[i][11] = (t2) ? tc0[indexA][t2] : 0;
    2242. 

  2242.         t2 = bs[i][13];
    2243. 

  2243.         threshold[i][12] = (t1) ? tc0[indexA][t1] : 0;
    2244. 

  2244.         t1 = bs[i][14];
    2245. 

  2245.         threshold[i][13] = (t2) ? tc0[indexA][t2] : 0;
    2246. 

  2246.         t2 = bs[i][15];
    2247. 

  2247.         threshold[i][14] = (t1) ? tc0[indexA][t1] : 0;
    2248. 

  2248.         threshold[i][15] = (t2) ? tc0[indexA][t2] : 0;
    2249. 

  2249.     }
    2250. 

  2250. 

  2251.     if (filteringFlags & FILTER_TOP_EDGE)
    2252. 

  2252.     {
    2253. 

  2253.         qpTmp = mb->mbB->qpY;
    2254. 

  2254.         if (qpTmp != qp)
    2255. 

  2255.         {
    2256. 

  2256.             u32 t1, t2, t3, t4;
    2257. 

  2257.             qpAv = (qp + qpTmp + 1) >> 1;
    2258. 

  2258. 

  2259.             indexA = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetA);
    2260. 

  2260.             indexB = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetB);
    2261. 

  2261. 

  2262.             alpha[1][0] = alphas[indexA];
    2263. 

  2263.             beta[1][0] = betas[indexB];
    2264. 

  2264.             t1 = bs[1][0];
    2265. 

  2265.             t2 = bs[1][1];
    2266. 

  2266.             t3 = bs[1][2];
    2267. 

  2267.             t4 = bs[1][3];
    2268. 

  2268.             threshold[1][0] = (t1 && (t1 < 4)) ? tc0[indexA][t1] : 0;
    2269. 

  2269.             threshold[1][1] = (t2 && (t2 < 4)) ? tc0[indexA][t2] : 0;
    2270. 

  2270.             threshold[1][2] = (t3 && (t3 < 4)) ? tc0[indexA][t3] : 0;
    2271. 

  2271.             threshold[1][3] = (t4 && (t4 < 4)) ? tc0[indexA][t4] : 0;
    2272. 

  2272.         }
    2273. 

  2273.     }
    2274. 

  2274.     if (filteringFlags & FILTER_LEFT_EDGE)
    2275. 

  2275.     {
    2276. 

  2276.         qpTmp = mb->mbA->qpY;
    2277. 

  2277.         if (qpTmp != qp)
    2278. 

  2278.         {
    2279. 

  2279.             qpAv = (qp + qpTmp + 1) >> 1;
    2280. 

  2280. 

  2281.             indexA = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetA);
    2282. 

  2282.             indexB = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetB);
    2283. 

  2283. 

  2284.             alpha[0][0] = alphas[indexA];
    2285. 

  2285.             beta[0][0] = betas[indexB];
    2286. 

  2286.             threshold[0][0] = (bs[0][0] && (bs[0][0] < 4)) ? tc0[indexA][bs[0][0]] : 0;
    2287. 

  2287.             threshold[0][1] = (bs[0][1] && (bs[0][1] < 4)) ? tc0[indexA][bs[0][1]] : 0;
    2288. 

  2288.             threshold[0][2] = (bs[0][2] && (bs[0][2] < 4)) ? tc0[indexA][bs[0][2]] : 0;
    2289. 

  2289.             threshold[0][3] = (bs[0][3] && (bs[0][3] < 4)) ? tc0[indexA][bs[0][3]] : 0;
    2290. 

  2290.         }
    2291. 

  2291.     }
    2292. 

  2292. 

  2293. }
    2294. 

  2294. 

  2295. /*------------------------------------------------------------------------------
    2296. 

    2297. 

  2297.     Function: GetChromaEdgeThresholds
    2298. 

    2299. 

  2299.         Functional description:
    2300. 

  2300.             Compute alpha, beta and tc0 thresholds for inner, left and top
    2301. 

  2301.             chroma edges of a macroblock.
    2302. 

    2303. 

  2303. ------------------------------------------------------------------------------*/
    2304. 

  2304. void GetChromaEdgeThresholds(
    2305. 

  2305.     mbStorage_t *mb,
    2306. 

  2306.     u8 (*alpha)[2],
    2307. 

  2307.     u8 (*beta)[2],
    2308. 

  2308.     u8 (*threshold)[8],
    2309. 

  2309.     u8 (*bs)[16],
    2310. 

  2310.     u32 filteringFlags,
    2311. 

  2311.     i32 chromaQpIndexOffset)
    2312. 

  2312. {
    2313. 

  2313. 

  2314. /* Variables */
    2315. 

  2315. 

  2316.     u32 indexA, indexB;
    2317. 

  2317.     u32 qpAv, qp, qpTmp;
    2318. 

  2318.     u32 i;
    2319. 

  2319. 

  2320. /* Code */
    2321. 

  2321. 

  2322.     ASSERT(threshold);
    2323. 

  2323.     ASSERT(bs);
    2324. 

  2324.     ASSERT(beta);
    2325. 

  2325.     ASSERT(alpha);
    2326. 

  2326.     ASSERT(mb);
    2327. 

  2327.     ASSERT(mb);
    2328. 

  2328. 

  2329.     qp = mb->qpY;
    2330. 

  2330.     qp = h264bsdQpC[CLIP3(0, 51, (i32)qp + chromaQpIndexOffset)];
    2331. 

  2331. 

  2332.     indexA = (u32)CLIP3(0, 51, (i32)qp + mb->filterOffsetA);
    2333. 

  2333.     indexB = (u32)CLIP3(0, 51, (i32)qp + mb->filterOffsetB);
    2334. 

  2334. 

  2335.     alpha[0][1] = alphas[indexA];
    2336. 

  2336.     alpha[1][1] = alphas[indexA];
    2337. 

  2337.     alpha[1][0] = alphas[indexA];
    2338. 

  2338.     alpha[0][0] = alphas[indexA];
    2339. 

  2339.     beta[0][1] = betas[indexB];
    2340. 

  2340.     beta[1][1] = betas[indexB];
    2341. 

  2341.     beta[1][0] = betas[indexB];
    2342. 

  2342.     beta[0][0] = betas[indexB];
    2343. 

  2343. 

  2344.     for (i = 0; i < 2; i++)
    2345. 

  2345.     {
    2346. 

  2346.         u32 t1, t2;
    2347. 

  2347. 

  2348.         t1 = bs[i][0];
    2349. 

  2349.         t2 = bs[i][1];
    2350. 

  2350.         threshold[i][0]  = (t1) ? tc0[indexA][t1] : 0;
    2351. 

  2351.         t1 = bs[i][2];
    2352. 

  2352.         threshold[i][1]  = (t2) ? tc0[indexA][t2] : 0;
    2353. 

  2353.         t2 = bs[i][3];
    2354. 

  2354.         threshold[i][2]  = (t1) ? tc0[indexA][t1] : 0;
    2355. 

  2355.         t1 = bs[i][8];
    2356. 

  2356.         threshold[i][3]  = (t2) ? tc0[indexA][t2] : 0;
    2357. 

  2357.         t2 = bs[i][9];
    2358. 

  2358.         threshold[i][4]  = (t1) ? tc0[indexA][t1] : 0;
    2359. 

  2359.         t1 = bs[i][10];
    2360. 

  2360.         threshold[i][5]  = (t2) ? tc0[indexA][t2] : 0;
    2361. 

  2361.         t2 = bs[i][11];
    2362. 

  2362.         threshold[i][6]  = (t1) ? tc0[indexA][t1] : 0;
    2363. 

  2363.         threshold[i][7]  = (t2) ? tc0[indexA][t2] : 0;
    2364. 

  2364.     }
    2365. 

  2365. 

  2366.     if (filteringFlags & FILTER_TOP_EDGE)
    2367. 

  2367.     {
    2368. 

  2368.         qpTmp = mb->mbB->qpY;
    2369. 

  2369.         if (qpTmp != mb->qpY)
    2370. 

  2370.         {
    2371. 

  2371.             u32 t1, t2, t3, t4;
    2372. 

  2372.             qpTmp = h264bsdQpC[CLIP3(0, 51, (i32)qpTmp + chromaQpIndexOffset)];
    2373. 

  2373.             qpAv = (qp + qpTmp + 1) >> 1;
    2374. 

  2374. 

  2375.             indexA = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetA);
    2376. 

  2376.             indexB = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetB);
    2377. 

  2377. 

  2378.             alpha[1][0] = alphas[indexA];
    2379. 

  2379.             beta[1][0] = betas[indexB];
    2380. 

  2380. 

  2381.             t1 = bs[1][0];
    2382. 

  2382.             t2 = bs[1][1];
    2383. 

  2383.             t3 = bs[1][2];
    2384. 

  2384.             t4 = bs[1][3];
    2385. 

  2385.             threshold[1][0] = (t1) ? tc0[indexA][t1] : 0;
    2386. 

  2386.             threshold[1][1] = (t2) ? tc0[indexA][t2] : 0;
    2387. 

  2387.             threshold[1][2] = (t3) ? tc0[indexA][t3] : 0;
    2388. 

  2388.             threshold[1][3] = (t4) ? tc0[indexA][t4] : 0;
    2389. 

  2389.         }
    2390. 

  2390.     }
    2391. 

  2391.     if (filteringFlags & FILTER_LEFT_EDGE)
    2392. 

  2392.     {
    2393. 

  2393.         qpTmp = mb->mbA->qpY;
    2394. 

  2394.         if (qpTmp != mb->qpY)
    2395. 

  2395.         {
    2396. 

  2396. 

  2397.             qpTmp = h264bsdQpC[CLIP3(0, 51, (i32)qpTmp + chromaQpIndexOffset)];
    2398. 

  2398.             qpAv = (qp + qpTmp + 1) >> 1;
    2399. 

  2399. 

  2400.             indexA = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetA);
    2401. 

  2401.             indexB = (u32)CLIP3(0, 51, (i32)qpAv + mb->filterOffsetB);
    2402. 

  2402. 

  2403.             alpha[0][0] = alphas[indexA];
    2404. 

  2404.             beta[0][0] = betas[indexB];
    2405. 

  2405.             threshold[0][0] = (bs[0][0]) ? tc0[indexA][bs[0][0]] : 0;
    2406. 

  2406.             threshold[0][1] = (bs[0][1]) ? tc0[indexA][bs[0][1]] : 0;
    2407. 

  2407.             threshold[0][2] = (bs[0][2]) ? tc0[indexA][bs[0][2]] : 0;
    2408. 

  2408.             threshold[0][3] = (bs[0][3]) ? tc0[indexA][bs[0][3]] : 0;
    2409. 

  2409.         }
    2410. 

  2410.     }
    2411. 

  2411. 

  2412. }
    2413. 

  2413. 

  2414. #endif /* H264DEC_OMXDL */
    2415. 

  2415. 

  2416. /*lint +e701 +e702 */
    2417. 

  2417. 

  2418.