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

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

Symbian

开发平台：

C/C++

mcomp.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. /*-----------------------------------------------------------------------------
  37.  *  MCOMP.C
  38.  *
  39.  *  DESCRIPTION
  40.  *      mcomp.c - Motion compensation for H.263 codec
  41.  *          Performs motion compensation for a macroblock with half-pixel accuracy
  42.  *          Supports Unrestricted Motion Vector mode, i.e., motion vectors are allowed
  43.  *          to point outside picture boundaries; uses edge pixels when needed.
  44.  *          Supports Advanced Prediction mode, i.e., four motion vectors per macroblock
  45.  *          and overlapped motion compensation for luminance.
  46.  *
  47.  *          In Advanced Prediction mode, the prediction is formed in two steps.
  48.  *          First, MotionComp263 is called to generate non-overlapped motion compensation.
  49.  *          Then, OverlapMC is called to perform the overlapping on the luminance.
  50.  *          OverlapMC requires mv's from left, top, and right neighbors.  Therefore,
  51.  *          the encoder needs to decide on the coding mode for the next mb (i.e., to the
  52.  *          right) before overlap can be done.
  53.  *
  54.  *          In PB-frame mode, the B-frame prediction is generated by PredBframe.  It uses
  55.  *          previous P-frame and the corresponding macroblock from the next P-frame.
  56.  *          Hence, the next P-frame macroblock needs to be reconstructed before calling 
  57.  *          PredBframe.
  58.  *
  59.  *          This module also contains the motion compensation routine for 
  60.  *          H.261 (MotionComp), which performs integer motion compensation.
  61.  *          MotionComp was extracted from file PREDSEL.C and modified.
  62.  *
  63.  *  CALLING SEQUENCE
  64.  *      MotionComp263(  MACROBLOCK_DESCR * mb,  // Describes block to be motion-compensated
  65.  *                      PICTURE * prev_pic,     // Describes previous picture used to form MC
  66.  *                      PICTURE * pic)          // Output picture where MC block is placed
  67.  *      OverlapMC( MACROBLOCK_DESCR * mb,   // Describes block to be motion-compensated
  68.  *                      PICTURE * prevPic,  // Describes previous picture used to form MC
  69.  *                      PICTURE * pic,      // Output picture where MC block is placed
  70.  *                      int     mbWidth,    // Macroblocks per row
  71.  *                      int     mbOffset,   // Row offset; (mb-mbOffset) is neighbor on top
  72.  *                      int     overlap[4]  // Returns YES or NO to indicate whether overlap
  73.  *                      )                   // was done in each 8x8 subblock
  74.  *      PredBframe( MACROBLOCK_DESCR * mb,  // Macroblock to be predicted
  75.  *                      PICTURE * prevPic,      // Prev. picture (forward pred)
  76.  *                      PICTURE * nextPic,      // Next P-picture (backward pred)
  77.  *                      PICTURE * Bpic          // Output picture where pred is placed
  78.  *                      )
  79.  *
  80.  *          The routines do not return a value.
  81.  *
  82.  *          Assumptions:
  83.  *          1. "pic", "prev_pic", "nextPic", and "Bpic" have same line offset and size
  84.  *          2. Chroma components Cb and Cr have same line offset and size
  85.  *          3. All arrays are quad-aligned, i.e., start address is multiple of 4.
  86.  *          4. Motion vectors are represented with one fractional bit
  87.  *
  88.  *
  89.  *      MotionComp(     MACROBLOCK_DESCR * mb,  // Describes block to be motion-compensated
  90.  *                      PICTURE * prev_pic,     // Describes previous picture used to form MC
  91.  *                      PICTURE * pic )         // Output picture where MC block is placed
  92.  *
  93.  *          The routine returns H261_ERROR if motion vectors point outside picture, otherwise OK.
  94.  *
  95.  *          Assumptions:
  96.  *          1-3. As above
  97.  *          4. Motion vectors are represented by integers.
  98.  *
  99.  *
  100.  -----------------------------------------------------------------------------*/ 
  102. //#include <stdio.h>
  103. //#include <stdlib.h>
  104. #ifdef _MACINTOSH
  105. #include <stdlib.h> // for exit()
  106. #endif
  107. #include "dllindex.h"
  108. #include "h261defs.h"
  109. #include "h261func.h"
  112. #ifdef COMPILE_MMX
  113. #include "mmxcpuid.h"
  114. #endif
  116. //#define VVPROFILER
  117. #ifdef VVPROFILER
  118. #include "hvdebtim.h"
  119. extern struct CVvDebugTimer * pVvProf[];
  120. extern unsigned long pVvProfCount[];
  121. #endif
  123. // Declarations of local functions
  124. static int chromaMVComp( int mvLuma );
  125. static int chromaMvComp4V( S8 mvLuma[4] );
  126. void mc( int hSize, int vSize, 
  127.                     PIXEL in[], PIXEL out[], int hdim,
  128.                     int mvX, int mvY    // Motion vector
  129.                     );
  130. void mcMMX( int hSize, int vSize, 
  131.                     PIXEL in[], PIXEL out[], int hdim,
  132.                     int mvX, int mvY    // Motion vector
  133.                     );
  134. static void limitMC( int hSize, int vSize, 
  135.                     PIXEL const *in, PIXEL *out, int hdim,
  136.                     int mvX, int mvY,   // Motion vector
  137.                     int minX, int maxX, int minY, int maxY // Limits for hor/vert indices
  138.                     );
  139. static int mvDiff( int mvX, int mvY,    // motion vector
  140.                 MACROBLOCK_DESCR const *borderMB,   // adjacent macroblock
  141.                 int subBlk, // adjacent subblock (needed if borderMB has 4 motion vectors)
  142.                 int PBframe,    // If PBframe: do overlap also with INTRA neighbor
  143.                 int border[2]   // return motion vector components for adjacent block
  144.                 );
  145. static void doOverlapMC( int subBlk,    // Indicates subblock to process (UL, UR, LL, LR)
  146.                     MACROBLOCK_DESCR *mb,   // Used to determine (x,y) coordinates for block
  147.                     PICTURE *prevPic,   // Previous picture; used to create overlapping MC
  148.                     PICTURE *pic, // Contains non-overlapped MC on entry; returns overlapped MC
  149.                     int borderMv[4][2], // Motion vectors for adjacent blocks (L,Top,R,Bottom)
  150.                     int left,           // If YES, overlap using LEFT mv
  151.                     int top,            // If YES, overlap using TOP mv
  152.                     int right,          // If YES, overlap using RIGHT mv
  153.                     int bottom          // If YES, overlap using BOTTOM mv
  154.                     );
  155. static void weigh8x4( PIXEL dest[], PIXEL const *p, int hdim, int vert, int left, int right );
  156. static void weighLeft_Vert( PIXEL *dest, PIXEL const *p, int hdim );
  157. static void weighNoLeft_Vert( PIXEL *dest, PIXEL const *p, int hdim );
  158. static void weighLeft( PIXEL *dest, PIXEL const *p, int hdim );
  159. static void weighRight_Vert( PIXEL *dest, PIXEL const *p, int hdim );
  160. static void weighNoRight_Vert( PIXEL *dest, PIXEL const *p, int hdim );
  161. static void weighRight( PIXEL *dest, PIXEL const *p, int hdim );
  162. static void mc16pelsNoInterpol( PIXEL *in, PIXEL out[], int hdim, int vSize );
  163. static void mc8pelsNoInterpol( PIXEL *in, PIXEL out[], int hdim, int vSize );
  164. static void mc4pelsNoInterpol( PIXEL *in, PIXEL out[], int hdim, int vSize );
  165. static void mc16pelsHorInterpol( PIXEL const *in, PIXEL out[], int hdim, int vSize );
  166. static void mc8pelsHorInterpol( PIXEL const *in, PIXEL out[], int hdim, int vSize );
  167. static void mc4pelsHorInterpol( PIXEL const *in, PIXEL out[], int hdim, int vSize );
  168. static void mc16pelsVertInterpol( PIXEL const *in, PIXEL out[], int hdim, int vSize );
  169. static void mc8pelsVertInterpol( PIXEL const *in, PIXEL out[], int hdim, int vSize );
  170. static void mc4pelsVertInterpol( PIXEL const *in, PIXEL out[], int hdim, int vSize );
  171. static void mc16pels2DInterpol( PIXEL const *in, PIXEL out[], int hdim, int vSize );
  172. static void mc8pels2DInterpol( PIXEL const *in, PIXEL out[], int hdim, int vSize );
  173. static void mc4pels2DInterpol( PIXEL const *in, PIXEL out[], int hdim, int vSize );
  174. static void saveBackwardPred( MACROBLOCK_DESCR * mb,    // Describes block to be saved
  175.                               PICTURE * pic // Picture with pixels to be saved
  176.                               );
  177. static void averageForBack( MACROBLOCK_DESCR * mb,  // Describes block to be averaged
  178.                             PICTURE * pic   // Input: contains forward prediction
  179.                                             // Output: contains B-frame prediction
  180.                             );
  181. static void copyBlock( S32 source[], int hSize, int vSize, int sourceOffset,
  182.                        S32 dest[], int destOffset );
  183. void averageBlock( PIXEL forPred[], int hSize, int vSize, int forOffset,
  184.                           PIXEL backPred[], int backOffset );
  185. void averageBlockMMX( PIXEL forPred[], int hSize, int vSize, int forOffset,
  186.                           PIXEL backPred[], int backOffset );
  189. // MotionComp - perform integer-pixel motion compensation for H.261
  190. extern int  MotionComp( MACROBLOCK_DESCR *mb, PICTURE *prev_pic, PICTURE *pic )
  191. {
  192.     int     row, col, status, i, cx, cy, pic_offset, prev_offset;
  193.     union {     // Copy words to speed up routine
  194.         PIXEL   * pix;
  195.         S32    * word;
  196.     } pixel, prev;
  197.     PIXEL   * source, * dest;
  199.     status = OK;
  200.     if (mb->mv_x == 0  &&  mb->mv_y == 0) {   // Copy macroblock
  201.         col = 16 * mb->x;
  202.         row = 16 * mb->y;
  203.         pic_offset = col + row * pic->y.hoffset;
  204.         pixel.pix = pic->y.ptr + pic_offset;
  205.         prev.pix = prev_pic->y.ptr + pic_offset;
  206.         for (i = 0; i < 16; i++) {
  207.             *(pixel.word) = *(prev.word);
  208.             *(pixel.word + 1) = *(prev.word + 1);
  209.             *(pixel.word + 2) = *(prev.word + 2);
  210.             *(pixel.word + 3) = *(prev.word + 3);
  211.             pixel.pix += pic->y.hoffset;
  212.             prev.pix += pic->y.hoffset;
  213.         }
  214.         if (pic->color) {
  215.             col = 8 * mb->x;
  216.             row = 8 * mb->y;
  217.             // Assuming same offset for Cr and Cb
  218.             pic_offset = col + row * pic->cb.hoffset;
  219.             pixel.pix = pic->cb.ptr + pic_offset;
  220.             prev.pix = prev_pic->cb.ptr + pic_offset;
  221.             for (i = 0; i < 8; i++) {
  222.                 *(pixel.word) = *(prev.word);
  223.                 *(pixel.word + 1) = *(prev.word + 1);
  224.                 pixel.pix += pic->cb.hoffset;
  225.                 prev.pix += pic->cb.hoffset;
  226.             }
  227.             pixel.pix = pic->cr.ptr + pic_offset;
  228.             prev.pix = prev_pic->cr.ptr + pic_offset;
  229.             for (i = 0; i < 8; i++) {
  230.                 *(pixel.word) = *(prev.word);
  231.                 *(pixel.word + 1) = *(prev.word + 1);
  232.                 pixel.pix += pic->cr.hoffset;
  233.                 prev.pix += pic->cr.hoffset;
  234.             }
  235.         }
  236.     } else {    // Non-zero motion vector
  237.         // Wrap motion vectors to allowed range
  238.         while (mb->mv_x < MV_MIN) {
  239.             mb->mv_x += MV_WRAP;
  240.         }
  241.         while (mb->mv_x > MV_MAX) {
  242.             mb->mv_x -= MV_WRAP;
  243.         }
  244.         while (mb->mv_y < MV_MIN) {
  245.             mb->mv_y += MV_WRAP;
  246.         }
  247.         while (mb->mv_y > MV_MAX) {
  248.             mb->mv_y -= MV_WRAP;
  249.         }
  250.         // Compute pointers
  251.         col = 16 * mb->x;
  252.         row = 16 * mb->y;
  253.         if (col == 0  &&  mb->mv_x < 0) {    // Pointing left of first col?
  254.             mb->mv_x = 0, status = H261_ERROR;
  255.         }
  256.         if (col == pic->y.nhor - 16  &&  mb->mv_x > 0) {  // Right of last col?
  257.             mb->mv_x = 0, status = H261_ERROR;
  258.         }
  259.         if (row == 0  &&  mb->mv_y < 0) {    // Pointing above first row?
  260.             mb->mv_y = 0, status = H261_ERROR;
  261.         }
  262.         if (row == pic->y.nvert - 16  &&  mb->mv_y > 0) {  // Below last row?
  263.             mb->mv_y = 0, status = H261_ERROR;
  264.         }
  265.         // Copy displaced macroblock
  266.         pic_offset = col + row * pic->y.hoffset;
  267.         prev_offset = col + mb->mv_x + (row + mb->mv_y) * pic->y.hoffset;
  268.         pixel.pix = pic->y.ptr + pic_offset;
  269.         prev.pix = prev_pic->y.ptr + prev_offset;
  270.         for (i = 0; i < 16; i++) {
  271.             source = prev.pix;
  272.             for (dest = pixel.pix; dest < pixel.pix + 16; dest++) {
  273.                 *dest = *(source++);
  274.             }
  275.             pixel.pix += pic->y.hoffset;
  276.             prev.pix += pic->y.hoffset;
  277.         }
  278.         if (pic->color) {
  279.             col = 8 * mb->x;
  280.             row = 8 * mb->y;
  281.             // Truncate motion vectors for chroma towards zero
  282.             if (mb->mv_x < 0) {
  283.                 cx = (mb->mv_x + 1) >> 1;
  284.             } else {
  285.                 cx = mb->mv_x >> 1;
  286.             }
  287.             if (mb->mv_y < 0) {
  288.                 cy = (mb->mv_y + 1) >> 1;
  289.             } else {
  290.                 cy = mb->mv_y >> 1;
  291.             }
  292.             // Assuming same offset for Cr and Cb
  293.             pic_offset = col + row * pic->cb.hoffset;
  294.             prev_offset = col + cx + (row + cy) * pic->cb.hoffset;
  295.             pixel.pix = pic->cb.ptr + pic_offset;
  296.             prev.pix = prev_pic->cb.ptr + prev_offset;
  297.             for (i = 0; i < 8; i++) {
  298.                 source = prev.pix;
  299.                 for (dest = pixel.pix; dest < pixel.pix + 8; dest++) {
  300.                     *dest = *(source++);
  301.                 }
  302.                 pixel.pix += pic->cb.hoffset;
  303.                 prev.pix += pic->cb.hoffset;
  304.             }
  305.             pixel.pix = pic->cr.ptr + pic_offset;
  306.             prev.pix = prev_pic->cr.ptr + prev_offset;
  307.             for (i = 0; i < 8; i++) {
  308.                 source = prev.pix;
  309.                 for (dest = pixel.pix; dest < pixel.pix + 8; dest++) {
  310.                     *dest = *(source++);
  311.                 }
  312.                 pixel.pix += pic->cr.hoffset;
  313.                 prev.pix += pic->cr.hoffset;
  314.             }
  315.         }
  316.     }
  317.     return (status);
  318. }
  322. // MotionComp263 - perform half-pixel motion compensation for H.263
  323. extern void MotionComp263( MACROBLOCK_DESCR * mb, // Describes block to be motion-compensated
  324.                             PICTURE * prevPic,  // Describes previous picture used to form MC
  325.                             PICTURE * pic       // Output picture where MC block is placed
  326.                             )
  327. {
  328.     int     row, col, cX, cY, picOffset, hdim, nhor, nvert;
  329.     PIXEL   * source, * dest;
  330. void (*pMC) ( int hSize, int vSize, PIXEL *in, PIXEL *out, int hdim, int mvX, int mvY);
  331. #if defined(COMPILE_MMX)
  332. if(cpuid_is_mmx_motion_on()) {
  333. //do mmx if compiler switch AND initialized AND detected
  334. pMC = mcMMX;
  335. } else 
  336. #endif
  337. {
  338. pMC = mc;
  339. }
  341.     // Compute luma pointers
  342.     col = 16 * mb->x;
  343.     row = 16 * mb->y;
  344.     hdim = pic->y.hoffset;
  345.     nhor = pic->y.nhor, nvert = pic->y.nvert;
  346.     picOffset = col + row * hdim;
  347.     dest = pic->y.ptr + picOffset;          // Point to output luma
  348.     source = prevPic->y.ptr + picOffset;    // Point to input luma (without motion comp)
  349.     // Do motion compensation for luma
  350.     if (mb->mtype == MTYPE263_INTER4V) {    // 4 motion vectors
  351.         // Upper left block
  352.         if (PointingOutside( col, col+7, row, row+7, mb->blkMvX[UPPER_LEFT_BLK], 
  353.                             mb->blkMvY[UPPER_LEFT_BLK], nhor, nvert )  ==  NO) {
  354.             pMC( 8, 8, source, dest, hdim, 
  355.                         mb->blkMvX[UPPER_LEFT_BLK], mb->blkMvY[UPPER_LEFT_BLK] );
  356.         } else {
  357.             limitMC( 8, 8, source, dest, hdim,
  358.                         mb->blkMvX[UPPER_LEFT_BLK], mb->blkMvY[UPPER_LEFT_BLK],
  359.                         -col, nhor - 1 - col, -row, nvert - 1 - row );
  360.         }
  361.         // Upper right block
  362.         if (PointingOutside( col+8, col+15, row, row+7, mb->blkMvX[UPPER_RIGHT_BLK], 
  363.                             mb->blkMvY[UPPER_RIGHT_BLK], nhor, nvert )  ==  NO) {
  364.             pMC( 8, 8, source + 8, dest + 8, hdim,
  365.                         mb->blkMvX[UPPER_RIGHT_BLK], mb->blkMvY[UPPER_RIGHT_BLK] );
  366.         } else {
  367.             limitMC( 8, 8, source + 8, dest + 8, hdim,
  368.                         mb->blkMvX[UPPER_RIGHT_BLK], mb->blkMvY[UPPER_RIGHT_BLK],
  369.                         -col - 8, nhor - 1 - col - 8, -row, nvert - 1 - row );
  370.         }
  371.         // Lower left block
  372.         source += 8 * hdim;   // Advance 8 lines
  373.         dest += 8 * hdim;
  374.         if (PointingOutside( col, col+7, row+8, row+15, mb->blkMvX[LOWER_LEFT_BLK], 
  375.                             mb->blkMvY[LOWER_LEFT_BLK], nhor, nvert )  ==  NO) {
  376.             pMC( 8, 8, source, dest, hdim,
  377.                         mb->blkMvX[LOWER_LEFT_BLK], mb->blkMvY[LOWER_LEFT_BLK] );
  378.         } else {
  379.             limitMC( 8, 8, source, dest, hdim,
  380.                         mb->blkMvX[LOWER_LEFT_BLK], mb->blkMvY[LOWER_LEFT_BLK],
  381.                         -col, nhor - 1 - col, -row - 8, nvert - 1 - row - 8 );
  382.         }
  383.         // Lower right block
  384.         if (PointingOutside( col+8, col+15, row+8, row+15, mb->blkMvX[LOWER_RIGHT_BLK],
  385.                             mb->blkMvY[LOWER_RIGHT_BLK], nhor, nvert )  ==  NO) {
  386.             pMC( 8, 8, source + 8, dest + 8, hdim,
  387.                         mb->blkMvX[LOWER_RIGHT_BLK], mb->blkMvY[LOWER_RIGHT_BLK] );
  388.         } else {
  389.             limitMC( 8, 8, source + 8, dest + 8, hdim,
  390.                         mb->blkMvX[LOWER_RIGHT_BLK], mb->blkMvY[LOWER_RIGHT_BLK],
  391.                         -col - 8, nhor - 1 - col - 8, -row - 8, nvert - 1 - row - 8 );
  392.         }
  393.         // Compute chroma mv
  394.         cX = chromaMvComp4V( mb->blkMvX );
  395.         cY = chromaMvComp4V( mb->blkMvY );
  396.     
  397.     } else {    // One motion vector
  398.         if (PointingOutside( col, col+15, row, row+15, mb->mv_x, mb->mv_y,
  399.                                 nhor, nvert )  ==  NO) {
  400.             pMC( 16, 16, source, dest, hdim, mb->mv_x, mb->mv_y );
  401.         } else {    // Pointing outside
  402.             limitMC( 16, 16, source, dest, hdim, mb->mv_x, mb->mv_y,
  403.                         -col, nhor - 1 - col, -row, nvert - 1 - row );
  404.         }
  405.         // Compute chroma mv
  406.         cX = chromaMVComp( mb->mv_x );
  407.         cY = chromaMVComp( mb->mv_y );
  408.     }
  409.     
  410.     // Do motion compensation for chroma
  411.     if (pic->color) {
  412.         // Compute chroma pointers
  413.         col = 8 * mb->x;
  414.         row = 8 * mb->y;
  415.         hdim = pic->cb.hoffset;
  416.         nhor = pic->cb.nhor, nvert = pic->cb.nvert;
  417.         picOffset = col + row * hdim;
  418.         if (PointingOutside( col, col+7, row, row+7, cX, cY, nhor, nvert )  ==  NO) {
  419.             pMC( 8, 8, prevPic->cb.ptr + picOffset, pic->cb.ptr + picOffset, hdim, cX, cY );
  420.             pMC( 8, 8, prevPic->cr.ptr + picOffset, pic->cr.ptr + picOffset, hdim, cX, cY );
  421.         } else {
  422.             limitMC( 8, 8, prevPic->cb.ptr + picOffset, pic->cb.ptr + picOffset,
  423.                     hdim, cX, cY, -col, nhor - 1 - col, -row, nvert - 1 - row );
  424.             limitMC( 8, 8, prevPic->cr.ptr + picOffset, pic->cr.ptr + picOffset,
  425.                     hdim, cX, cY, -col, nhor - 1 - col, -row, nvert - 1 - row );
  426.         }
  427.     }
  428.     return;
  429. }
  432. // printBlk - for debugging
  433. /*static void printBlk( int hSize, int vSize, PIXEL *p, int hdim)
  434. {
  435.     int i,j;
  436.     
  437.     for (i = 0; i < vSize; ++i) {
  438.         for (j = 0; j < hSize; ++j) {
  439.             printf(" %3d", *(p + j));
  440.         }
  441.         printf("n");
  442.         p += hdim;
  443.     }
  444.     return;
  445. }*/
  448. // Enumerate array of motion vectors
  449. #define LEFT        (0)
  450. #define TOP         (1)
  451. #define RIGHT       (2)
  452. #define BOTTOM      (3)
  454. // Do overlapped motion comp. for luma
  455. extern void OverlapMC( MACROBLOCK_DESCR * mb,   // Describes block to be motion-compensated
  456.                         int     PBframe,    // Non-zero if PB frame
  457.                         PICTURE * prevPic,  // Describes previous picture used to form MC
  458.                         PICTURE * pic,      // Output picture where MC block is placed
  459.                         int     mbWidth,    // Macroblocks per row
  460.                         int     mbOffset,   // Row offset; (mb-mbOffset) is neighbor on top
  461.                         int     overlap[4]  // Returns YES or NO to indicate whether overlap
  462.                                             // was done in each 8x8 subblock
  463.                         )
  464. {
  465.     int left, top, right, bottom, mvX, mvY;
  466.     int borderMv[4][2]; // motion vectors for neighbors (left, top, right, bottom)
  467.     
  468.     if (mb->mtype == MTYPE263_INTER4V) {
  469.         // Upper left block
  470.         mvX = mb->blkMvX[UPPER_LEFT_BLK];
  471.         mvY = mb->blkMvY[UPPER_LEFT_BLK];
  472.         if (mb->x == 0)  left = NO;
  473.         else  left = mvDiff( mvX, mvY, mb-1, UPPER_RIGHT_BLK, PBframe, borderMv[LEFT] );
  474.         if (mb->y == 0)  top = NO;
  475.         else  top = mvDiff( mvX, mvY, mb-mbOffset, LOWER_LEFT_BLK, PBframe, borderMv[TOP] );
  476.         right = mvDiff( mvX, mvY, mb, UPPER_RIGHT_BLK, PBframe, borderMv[RIGHT] );
  477.         bottom = mvDiff( mvX, mvY, mb, LOWER_LEFT_BLK, PBframe, borderMv[BOTTOM] );
  478.         if (left == YES || right == YES || top == YES || bottom == YES) {
  479.             doOverlapMC( UPPER_LEFT_BLK, mb, prevPic, pic, borderMv, left,top,right,bottom);
  480.             overlap[UPPER_LEFT_BLK] = YES;
  481.         } else {
  482.             overlap[UPPER_LEFT_BLK] = NO;
  483.         }
  484.         // Upper right block
  485.         mvX = mb->blkMvX[UPPER_RIGHT_BLK];
  486.         mvY = mb->blkMvY[UPPER_RIGHT_BLK];
  487.         left = mvDiff( mvX, mvY, mb, UPPER_LEFT_BLK, PBframe, borderMv[LEFT] );
  488.         if (mb->y == 0)  top = NO;
  489.         else  top = mvDiff( mvX, mvY, mb-mbOffset, LOWER_RIGHT_BLK, PBframe, borderMv[TOP] );
  490.         if (mb->x == mbWidth-1)  right = NO;
  491.         else  right = mvDiff( mvX, mvY, mb+1, UPPER_LEFT_BLK, PBframe, borderMv[RIGHT] );
  492.         bottom = mvDiff( mvX, mvY, mb, LOWER_RIGHT_BLK, PBframe, borderMv[BOTTOM] );
  493.         if (left == YES || right == YES || top == YES || bottom == YES) {
  494.             doOverlapMC( UPPER_RIGHT_BLK, mb, prevPic, pic, borderMv, left,top,right,bottom);
  495.             overlap[UPPER_RIGHT_BLK] = YES;
  496.         } else {
  497.             overlap[UPPER_RIGHT_BLK] = NO;
  498.         }
  499.         // Lower left block
  500.         mvX = mb->blkMvX[LOWER_LEFT_BLK];
  501.         mvY = mb->blkMvY[LOWER_LEFT_BLK];
  502.         if (mb->x == 0)  left = NO;
  503.         else  left = mvDiff( mvX, mvY, mb-1, LOWER_RIGHT_BLK, PBframe, borderMv[LEFT] );
  504.         top = mvDiff( mvX, mvY, mb, UPPER_LEFT_BLK, PBframe, borderMv[TOP] );
  505.         right = mvDiff( mvX, mvY, mb, LOWER_RIGHT_BLK, PBframe, borderMv[RIGHT] );
  506.         if (left == YES || right == YES || top == YES) {
  507.             doOverlapMC( LOWER_LEFT_BLK, mb, prevPic, pic, borderMv, left,top,right,NO);
  508.             overlap[LOWER_LEFT_BLK] = YES;
  509.         } else {
  510.             overlap[LOWER_LEFT_BLK] = NO;
  511.         }
  512.         // Lower right block
  513.         mvX = mb->blkMvX[LOWER_RIGHT_BLK];
  514.         mvY = mb->blkMvY[LOWER_RIGHT_BLK];
  515.         left = mvDiff( mvX, mvY, mb, LOWER_LEFT_BLK, PBframe, borderMv[LEFT] );
  516.         top = mvDiff( mvX, mvY, mb, UPPER_RIGHT_BLK, PBframe, borderMv[TOP] );
  517.         if (mb->x == mbWidth-1)  right = NO;
  518.         else  right = mvDiff( mvX, mvY, mb+1, LOWER_LEFT_BLK, PBframe, borderMv[RIGHT] );
  519.         if (left == YES || right == YES || top == YES) {
  520.             doOverlapMC( LOWER_RIGHT_BLK, mb, prevPic, pic, borderMv, left,top,right,NO);
  521.             overlap[LOWER_RIGHT_BLK] = YES;
  522.         } else {
  523.             overlap[LOWER_RIGHT_BLK] = NO;
  524.         }
  525.         
  526.     } else {    // One motion vector for current macroblock; neighbors can be INTER4V
  527.         mvX = mb->mv_x;
  528.         mvY = mb->mv_y;
  529.         // Upper left block
  530.         if (mb->x == 0)  left = NO;
  531.         else  left = mvDiff( mvX, mvY, mb-1, UPPER_RIGHT_BLK, PBframe, borderMv[LEFT] );
  532.         if (mb->y == 0)  top = NO;
  533.         else  top = mvDiff( mvX, mvY, mb-mbOffset, LOWER_LEFT_BLK, PBframe, borderMv[TOP] );
  534.         if (left == YES || top == YES) {
  535.             doOverlapMC( UPPER_LEFT_BLK, mb, prevPic, pic, borderMv, left,top,NO,NO);
  536.             overlap[UPPER_LEFT_BLK] = YES;
  537.         } else {
  538.             overlap[UPPER_LEFT_BLK] = NO;
  539.         }
  540.         // Upper right block
  541.         if (mb->y == 0)  top = NO;
  542.         else  top = mvDiff( mvX, mvY, mb-mbOffset, LOWER_RIGHT_BLK, PBframe, borderMv[TOP] );
  543.         if (mb->x == mbWidth-1)  right = NO;
  544.         else  right = mvDiff( mvX, mvY, mb+1, UPPER_LEFT_BLK, PBframe, borderMv[RIGHT] );
  545.         if (right == YES || top == YES) {
  546.             doOverlapMC( UPPER_RIGHT_BLK, mb, prevPic, pic, borderMv, NO,top,right,NO);
  547.             overlap[UPPER_RIGHT_BLK] = YES;
  548.         } else {
  549.             overlap[UPPER_RIGHT_BLK] = NO;
  550.         }
  551.         // Lower left block
  552.         if (mb->x == 0)  left = NO;
  553.         else  left = mvDiff( mvX, mvY, mb-1, LOWER_RIGHT_BLK, PBframe, borderMv[LEFT] );
  554.         if (left == YES) {
  555.             doOverlapMC( LOWER_LEFT_BLK, mb, prevPic, pic, borderMv, left,NO,NO,NO);
  556.             overlap[LOWER_LEFT_BLK] = YES;
  557.         } else {
  558.             overlap[LOWER_LEFT_BLK] = NO;
  559.         }
  560.         // Lower right block
  561.         if (mb->x == mbWidth-1)  right = NO;
  562.         else  right = mvDiff( mvX, mvY, mb+1, LOWER_LEFT_BLK, PBframe, borderMv[RIGHT] );
  563.         if (right == YES) {
  564.             doOverlapMC( LOWER_RIGHT_BLK, mb, prevPic, pic, borderMv, NO,NO,right,NO);
  565.             overlap[LOWER_RIGHT_BLK] = YES;
  566.         } else {
  567.             overlap[LOWER_RIGHT_BLK] = NO;
  568.         }
  569.     }
  570.     return;
  571. }
  574. // PointingOutside - determine whether motion-comp routine needs to worry about 
  575. //  the borders of the previous picture (use edge pixels instead of non-existent
  576. //  pixels "outside" the border of the previous picture).
  577. //  Returns YES if the motion-compensated block needs pixels outside the previous
  578. //  picture; NO if picture boundary is not crossed.
  579. extern int PointingOutside( int col1, int col2, // First and last column of block
  580.                             int row1, int row2, // First and last row of block
  581.                             int mvX, int mvY,   // Motion vector; one fractional bit
  582.                             int nCols, int nRows    // Picture size
  583.                             )
  584. {
  585.     if (col1 + (mvX >> 1)  <  0)            // Check left border
  586.         return( YES );
  587.     if (col2 + ((mvX + 1) >> 1)  >=  nCols) // Check right border
  588.         return( YES );
  589.     if (row1 + (mvY >> 1)  <  0)            // Check top border
  590.         return( YES );
  591.     if (row2 + ((mvY + 1) >> 1)  >=  nRows) // Check bottom border
  592.         return( YES );
  593.     return( NO );
  594. }
  597. //  PredBframe - Form prediction for B-frame
  598. extern void PredBframe( MACROBLOCK_DESCR * mb,  // Macroblock to be predicted
  599.                         PICTURE * prevPic,      // Prev. picture (forward pred)
  600.                         PICTURE * nextPic,      // Next P-picture (backward pred)
  601.                         PICTURE * Bpic          // Output picture where pred is placed
  602.                         )
  603. {
  604.     int     i;
  605.     S8      saveMvX[4], saveMvY[4];
  607.     // Perform backward prediction
  608.     if (mb->mtype == MTYPE263_INTER4V) {
  609.         for (i = 0; i < 4; ++i) {
  610.             saveMvX[i] = mb->blkMvX[i];
  611.             mb->blkMvX[i] = mb->blkMvBx[i];
  612.             saveMvY[i] = mb->blkMvY[i];
  613.             mb->blkMvY[i] = mb->blkMvBy[i];
  614.         }
  615.     } else {
  616.         saveMvX[0] = mb->mv_x;
  617.         mb->mv_x = mb->blkMvBx[0];
  618.         saveMvY[0] = mb->mv_y;
  619.         mb->mv_y = mb->blkMvBy[0];
  620.     }
  621.     MotionComp263( mb, nextPic, Bpic );
  622.     // Save backward prediction in temporary area
  623.     saveBackwardPred( mb, Bpic );
  624.     // Perform forward prediction
  625.     if (mb->mtype == MTYPE263_INTER4V) {
  626.         for (i = 0; i < 4; ++i) {
  627.             mb->blkMvX[i] = mb->blkMvFx[i];
  628.             mb->blkMvY[i] = mb->blkMvFy[i];
  629.         }
  630.     } else {
  631.         mb->mv_x = mb->blkMvFx[0];
  632.         mb->mv_y = mb->blkMvFy[0];
  633.     }
  634.     MotionComp263( mb, prevPic, Bpic );
  635.     // Restore parameters
  636.     if (mb->mtype == MTYPE263_INTER4V) {
  637.         for (i = 0; i < 4; ++i) {
  638.             mb->blkMvX[i] = saveMvX[i];
  639.             mb->blkMvY[i] = saveMvY[i];
  640.         }
  641.     } else {
  642.         mb->mv_x = saveMvX[0];
  643.         mb->mv_y = saveMvY[0];
  644.     }
  645.     // Average forward and backward prediction
  646.     averageForBack( mb, Bpic );
  647. }
  650. //  PredBdist - Form prediction for subsampled error computation
  651. extern void PredBdist( MACROBLOCK_DESCR * mb,  // Macroblock to be predicted
  652.                         PICTURE * prevPic,      // Prev. picture (forward pred)
  653.                         PICTURE * nextPic,      // Next P-picture (backward pred)
  654.                         PICTURE * Bpic          // Output picture where pred is placed
  655.                         )
  656. {
  657.     int     i;
  658.     S8      saveMvX[4], saveMvY[4];
  660.     // Perform backward prediction
  661.     if (mb->mtype == MTYPE263_INTER4V) {
  662.         for (i = 0; i < 4; ++i) {
  663.             saveMvX[i] = mb->blkMvX[i];
  664.             mb->blkMvX[i] = mb->blkMvBx[i];
  665.             saveMvY[i] = mb->blkMvY[i];
  666.             mb->blkMvY[i] = mb->blkMvBy[i];
  667.         }
  668.     } else {
  669.         saveMvX[0] = mb->mv_x;
  670.         mb->mv_x = mb->blkMvBx[0];
  671.         saveMvY[0] = mb->mv_y;
  672.         mb->mv_y = mb->blkMvBy[0];
  673.     }
  674.     MotionComp263( mb, nextPic, Bpic );
  675.     // Save backward prediction in temporary area
  676.     saveBackwardPred( mb, Bpic );
  677.     // Perform forward prediction
  678.     if (mb->mtype == MTYPE263_INTER4V) {
  679.         for (i = 0; i < 4; ++i) {
  680.             mb->blkMvX[i] = mb->blkMvFx[i];
  681.             mb->blkMvY[i] = mb->blkMvFy[i];
  682.         }
  683.     } else {
  684.         mb->mv_x = mb->blkMvFx[0];
  685.         mb->mv_y = mb->blkMvFy[0];
  686.     }
  687.     MotionComp263( mb, prevPic, Bpic );
  688.     // Restore parameters
  689.     if (mb->mtype == MTYPE263_INTER4V) {
  690.         for (i = 0; i < 4; ++i) {
  691.             mb->blkMvX[i] = saveMvX[i];
  692.             mb->blkMvY[i] = saveMvY[i];
  693.         }
  694.     } else {
  695.         mb->mv_x = saveMvX[0];
  696.         mb->mv_y = saveMvY[0];
  697.     }
  698.     // Average forward and backward prediction
  699.     averageForBack( mb, Bpic );
  700. }
  703. // chromaMVComp - derive motion component for chroma from luma motion component
  704. static int chromaMVComp( int mvLuma )
  705. {
  706.     int mvChroma, fraction;
  707.     
  708.     mvChroma = 2 * (mvLuma >> 2);    // Truncate fractional part
  709.     fraction = mvLuma & 0x3;    // Two fractional bits
  710.     if (fraction != 0) {
  711.         ++mvChroma;     // Round towards half-pixel
  712.     }
  713.     return( mvChroma );
  714. }
  717. // chromaMvComp4V - derive motion component for chroma from 4 luma motion components
  718. static int chromaMvComp4V( S8 mvLuma[4] )
  719. {
  720.     int sum, mvChroma, fraction;
  721.     
  722.     sum = mvLuma[0] + mvLuma[1] + mvLuma[2] + mvLuma[3];
  723.     mvChroma = 2 * (sum >> 4);  // Truncate fractional part
  724.     fraction = sum & 0xf;       // Four fractional bits
  725.     if (fraction >= 14) {
  726.         mvChroma += 2;  // Round up to next integer value
  727.     } else if (fraction >= 3) {
  728.         ++mvChroma;     // Round towards half-pixel
  729.     } // else round down to integer pixel
  730.     return( mvChroma );
  731. }
  734. // mc - Perform motion compensation for a hSize x vSize block
  735. void mc( int hSize, int vSize, 
  736.                     PIXEL *in, PIXEL *out, int hdim,
  737.                     int mvX, int mvY    // Motion vector
  738.                     )
  739. {
  740.     int intX, intY, fracX, fracY;
  741.     
  742. #ifdef VVPROFILER
  743. S32 nVvProfNb = 2;
  744. if(!pVvProf[nVvProfNb]) pVvProf[nVvProfNb] = newCVvDebugTimer();//memory leak on destruction
  745. pVvProfCount[nVvProfNb]++;
  746. StartTime(pVvProf[nVvProfNb]);
  747. #endif
  750.     intX = mvX >> 1;    // Integer part of motion vector
  751.     intY = mvY >> 1;
  752.     fracX = mvX & 0x1;  // Fractional part of motion vector
  753.     fracY = mvY & 0x1;
  754.     in += intX + intY * hdim;
  755.     if (hSize != 16  &&  hSize != 8  &&  hSize != 4) {
  756.         H261ErrMsg("mc -- hSize not supported");
  757.         exit(0);
  758.     }
  759.     if (fracY == 0) {
  760.         if (fracX == 0) {
  761.             // No interpolation
  762.             if (hSize == 8) {
  763.                 mc8pelsNoInterpol( in, out, hdim, vSize );
  764.             } else if (hSize == 16) {
  765.                 mc16pelsNoInterpol( in, out, hdim, vSize );
  766.             } else {
  767.                 mc4pelsNoInterpol( in, out, hdim, vSize );
  768.             }
  769.         } else {
  770.             // Horizontal interpolation
  771.             if (hSize == 8) {
  772.                 mc8pelsHorInterpol( in, out, hdim, vSize );
  773.             } else if (hSize == 16) {
  774.                 mc16pelsHorInterpol( in, out, hdim, vSize );
  775.             } else {
  776.                 mc4pelsHorInterpol( in, out, hdim, vSize );
  777.             }
  778.         }
  779.     } else if (fracX == 0) {
  780.         // Vertical interpolation
  781.         if (hSize == 8) {
  782.             mc8pelsVertInterpol( in, out, hdim, vSize );
  783.         } else if (hSize == 16) {
  784.             mc16pelsVertInterpol( in, out, hdim, vSize );
  785.         } else {
  786.             mc4pelsVertInterpol( in, out, hdim, vSize );
  787.         }
  788.     } else {    // Bilinear interpolation
  789.         if (hSize == 8) {
  790.             mc8pels2DInterpol( in, out, hdim, vSize );
  791.         } else if (hSize == 16) {
  792.             mc16pels2DInterpol( in, out, hdim, vSize );
  793.         } else {
  794.             mc4pels2DInterpol( in, out, hdim, vSize );
  795.         }
  796.     }
  798. #ifdef VVPROFILER
  799. StopAndAccuTime(pVvProf[nVvProfNb]);
  800. #endif
  802.     return;
  803. }
  806. // Limit x to interval [low,high]
  807. #define LIMIT( low, x, high )    max( low, min( x, high ))
  809. // limitMC - Perform motion compensation; use edge pixels when referring to
  810. //  pixels outside picture
  811. static void limitMC( int hSize, int vSize, 
  812.                     PIXEL const *in, PIXEL *out, int hdim,
  813.                     int mvX, int mvY,   // Motion vector
  814.                     int minX, int maxX, int minY, int maxY // Limits for hor/vert indices
  815.                     )
  816. {
  817. #define MAX_HSIZE   (16)
  818.     int intX, intY, fracX, fracY, outsideTop, outsideBot, repeatTop, repeatBot, x, y;
  819.     static int  mapX[MAX_HSIZE + 1];
  820.     PIXEL *outSave, *outBegin;
  821.     union { // Copy words to speed up routine
  822.         PIXEL   *pix;
  823.         U32     *word;
  824.     } pIn, pOut;
  825.     
  826.     if (hSize & 0x3) {
  827.         H261ErrMsg("limitMC -- hSize must be multiple of 4");
  828.         exit(0);
  829.     }
  830.     if (hSize > MAX_HSIZE) {
  831.         H261ErrMsg("limitMC -- hSize too large");
  832.         exit(0);
  833.     }
  834.     intX = mvX >> 1;    // Integer part of motion vector
  835.     intY = mvY >> 1;
  836.     fracX = mvX & 0x1;  // Fractional part of motion vector
  837.     fracY = mvY & 0x1;
  838.     // Create horizontal mapping vector
  839.     for (x = 0; x <= hSize; ++x) {
  840.         mapX[x] = LIMIT( minX, x + intX, maxX );
  841.     }
  842.     //repeatTop = max( 0, minY - intY);                     // Lines on top that are outside
  843.     //repeatBot = max( 0, vSize - 1 + intY + fracY - maxY); // Lines at bottom that are outside
  844.     outsideTop = max( 0, minY - intY); // Lines on top that are outside
  845.     outsideBot = max( 0, vSize - 1 + intY + fracY - maxY);  // Lines at bottom that are outside
  846. // Don't produce more lines than the blocksize (used to be a nasty bug hidden here)
  847. repeatTop = min( outsideTop, vSize );
  848.     if (outsideBot < vSize) {
  849.         repeatBot = outsideBot;
  850.         in += (intY + outsideTop) * hdim; // Apply vert motion comp. (hor MC thru mapping)
  851.     } else {    // Whole block is "outside" bottom of picture
  852.         repeatBot = vSize;
  853.         in += (vSize - 1) * hdim;   // Point to last line of picture
  854.     }
  855. // Output pointers
  856.     outSave = out; // Upper left corner of output block
  857.     out += repeatTop * hdim; // "Repeated" lines will be filled in later
  858.     outBegin = out; // Save address for first valid output line
  859.     if (fracY == 0) {
  860. // Ensure that at least one output line gets written
  861. if (repeatTop == vSize) {
  862. --repeatTop;
  863. out -= hdim;
  864. outBegin = out;
  865. } else if (repeatBot == vSize) {
  866. --repeatBot;
  867. }
  868.         if (fracX == 0) {
  869.             // No interpolation
  870.             for (y = repeatTop; y < vSize - repeatBot; ++y) {
  871.                 for (x = 0; x < hSize; x += 4) {
  872.                     out[x+0] = in[ mapX[x+0] ];
  873.                     out[x+1] = in[ mapX[x+1] ];
  874.                     out[x+2] = in[ mapX[x+2] ];
  875.                     out[x+3] = in[ mapX[x+3] ];
  876.                 }
  877.                 in += hdim;
  878.                 out += hdim;
  879.             }
  880.         } else {
  881.             // Horizontal interpolation
  882.             for (y = repeatTop; y < vSize - repeatBot; ++y) {
  883.                 for (x = 0; x < hSize; x += 4) {
  884.                     out[x+0] = (in[mapX[x+0]] + in[mapX[x+1]] + 1) >> 1;
  885.                     out[x+1] = (in[mapX[x+1]] + in[mapX[x+2]] + 1) >> 1;
  886.                     out[x+2] = (in[mapX[x+2]] + in[mapX[x+3]] + 1) >> 1;
  887.                     out[x+3] = (in[mapX[x+3]] + in[mapX[x+4]] + 1) >> 1;
  888.                 }
  889.                 in += hdim;
  890.                 out += hdim;
  891.             }
  892.         }
  893.     } else if (fracX == 0) {
  894.         // Vertical interpolation
  895.         if (repeatTop > 0) {    // Produce line to repeat
  896.             outBegin = out - hdim;
  897.             for (x = 0; x < hSize; ++x) {
  898.                 outBegin[x] = in[ mapX[x] ];
  899.             }
  900.         }
  901.         for (y = repeatTop; y < vSize - repeatBot; ++y) {
  902.             for (x = 0; x < hSize; x += 4) {
  903.                 out[x+0] = (in[mapX[x+0]] + in[mapX[x+0] + hdim] + 1) >> 1;
  904.                 out[x+1] = (in[mapX[x+1]] + in[mapX[x+1] + hdim] + 1) >> 1;
  905.                 out[x+2] = (in[mapX[x+2]] + in[mapX[x+2] + hdim] + 1) >> 1;
  906.                 out[x+3] = (in[mapX[x+3]] + in[mapX[x+3] + hdim] + 1) >> 1;
  907.             }
  908.             in += hdim;
  909.             out += hdim;
  910.         }
  911.         if (repeatBot > 0) {    // Produce line to repeat
  912.             for (x = 0; x < hSize; ++x) {
  913.                 out[x] = in[ mapX[x] ];
  914.             }
  915.             out += hdim;
  916.         }
  917.     } else {    // Bilinear interpolation
  918.         if (repeatTop > 0) {    // Produce line to repeat
  919.             outBegin = out - hdim;
  920.             for (x = 0; x < hSize; ++x) {
  921.                 outBegin[x] = (in[mapX[x]] + in[mapX[x+1]] + 1) >> 1;
  922.             }
  923.         }
  924.         for (y = repeatTop; y < vSize - repeatBot; ++y) {
  925.             for (x = 0; x < hSize; x += 4) {
  926.                     out[x+0] = (in[mapX[x+0]] + in[mapX[x+0] + hdim]
  927.                                 + in[mapX[x+1]] + in[mapX[x+1] + hdim] + 2) >> 2;
  928.                     out[x+1] = (in[mapX[x+1]] + in[mapX[x+1] + hdim]
  929.                                 + in[mapX[x+2]] + in[mapX[x+2] + hdim] + 2) >> 2;
  930.                     out[x+2] = (in[mapX[x+2]] + in[mapX[x+2] + hdim]
  931.                                 + in[mapX[x+3]] + in[mapX[x+3] + hdim] + 2) >> 2;
  932.                     out[x+3] = (in[mapX[x+3]] + in[mapX[x+3] + hdim]
  933.                                 + in[mapX[x+4]] + in[mapX[x+4] + hdim] + 2) >> 2;
  934.             }
  935.             in += hdim;
  936.             out += hdim;
  937.         }
  938.         if (repeatBot > 0) {    // Produce line to repeat
  939.             for (x = 0; x < hSize; ++x) {
  940.                 out[x] = (in[mapX[x]] + in[mapX[x+1]] + 1) >> 1;
  941.             }
  942.             out += hdim;
  943.         }
  944.     }
  945.     if (fracY == 1) {
  946.         --repeatTop;    // Already did one line
  947.         --repeatBot;
  948.     }
  949.     // Repeat first line at top
  950.     pIn.pix = outBegin;
  951.     pOut.pix = outSave;
  952.     for (y = 0; y < repeatTop; ++y) {
  953.         for (x = 0; x < (hSize >> 2); ++x) {
  954.             *(pOut.word + x) = *(pIn.word + x);
  955.         }
  956.         pOut.pix += hdim;
  957.     }
  958.     // Repeat last line at the bottom
  959.     pIn.pix = out - hdim;
  960.     pOut.pix = out;
  961.     for (y = 0; y < repeatBot; ++y) {
  962.         for (x = 0; x < (hSize >> 2); ++x) {
  963.             *(pOut.word + x) = *(pIn.word + x);
  964.         }
  965.         pOut.pix += hdim;
  966.     }
  967.     return;
  968. }
  971. // mvDiff - Return YES if motion vector for adjacent block is different, otherwise NO
  972. //  Return NO if adjacent block is INTRA (unless PBframe)
  973. static int mvDiff( int mvX, int mvY,    // motion vector
  974.                 MACROBLOCK_DESCR const *borderMB,   // adjacent macroblock
  975.                 int subBlk, // adjacent subblock (needed if borderMB has 4 motion vectors)
  976.                 int PBframe,    // If PBframe: do overlap also with INTRA neighbor
  977.                 int border[2]   // return motion vector components for adjacent block
  978.                 )
  979. {
  980.     if (borderMB->mtype == MTYPE263_INTER4V) {
  981.         border[0] = borderMB->blkMvX[ subBlk ];
  982.         border[1] = borderMB->blkMvY[ subBlk ];
  983.     } else {
  984.         border[0] = borderMB->mv_x;
  985.         border[1] = borderMB->mv_y;
  986.         if (borderMB->mtype >= MTYPE263_INTRA  &&  PBframe == 0) {
  987.             return( NO );   // No overlap with INTRA neighbor (except in PBframe)
  988.         }
  989.     }
  990.     if (border[0] != mvX  ||  border[1] != mvY) {
  991.         return( YES );
  992.     }
  993.     return( NO );
  994. }
  996. // median3 - return median of 3 values
  997. static int  median3( int x[3] )
  998. {
  999.     int order[2];
  1000.     
  1001.     if (x[1] < x[0]) {
  1002.         order[0] = x[1];
  1003.         order[1] = x[0];
  1004.     } else {
  1005.         order[0] = x[0];
  1006.         order[1] = x[1];
  1007.     }
  1008.     if (x[2] < order[0]) {
  1009.         return( order[0] );
  1010.     } else if (x[2] < order[1]) {
  1011.         return( x[2] );
  1012.     }
  1013.     return( order[1] );
  1014. }
  1016. // MvPred - Compute mv predictor (mvX,mvY) for block "blk" of macroblock mb[0].
  1017. //  blk = UPPER_LEFT_BLK, UPPER_RIGHT_BLK, LOWER_LEFT_BLK, LOWER_RIGHT_BLK,
  1018. //          or WHOLE_MACROBLOCK.
  1019. //  If horPredOnly=YES: don't use previous row of macroblocks in prediction
  1020. extern void MvPred( MACROBLOCK_DESCR mb[],
  1021.                     int blk,        // specify block: UL, UR, LL, LR, or WHOLE 
  1022.                     int mbhor,      // offset from previous row of MBs
  1023.                     int horPredOnly, 
  1024.                     int *mvX, int *mvY )
  1025. {
  1026.     int x[3], y[3];
  1027.     
  1028.     switch (blk) {
  1029.     case UPPER_RIGHT_BLK:
  1030.         x[0] = mb[0].blkMvX[UPPER_LEFT_BLK];
  1031.         y[0] = mb[0].blkMvY[UPPER_LEFT_BLK];
  1032.         if (horPredOnly == YES) {   // Top border or sending GOB header to resync
  1033.             *mvX = x[0], *mvY = y[0];
  1034.         } else {
  1035.             if (mb[-mbhor].mtype == MTYPE263_INTER4V) {
  1036.                 x[1] = mb[-mbhor].blkMvX[LOWER_RIGHT_BLK];
  1037.                 y[1] = mb[-mbhor].blkMvY[LOWER_RIGHT_BLK];
  1038.             } else {
  1039.                 x[1] = mb[-mbhor].mv_x;
  1040.                 y[1] = mb[-mbhor].mv_y;
  1041.             }
  1042.             if (mb[0].x == mbhor - 1) { // Right border
  1043.                 x[2] = 0, y[2] = 0;
  1044.             } else if (mb[1-mbhor].mtype == MTYPE263_INTER4V) {
  1045.                 x[2] = mb[1-mbhor].blkMvX[LOWER_LEFT_BLK];
  1046.                 y[2] = mb[1-mbhor].blkMvY[LOWER_LEFT_BLK];
  1047.             } else {
  1048.                 x[2] = mb[1-mbhor].mv_x;
  1049.                 y[2] = mb[1-mbhor].mv_y;
  1050.             }
  1051.             *mvX = median3( x );
  1052.             *mvY = median3( y );
  1053.         }
  1054.         break;
  1055.         
  1056.     case LOWER_LEFT_BLK:
  1057.         if (mb[0].x == 0) {     // Left border
  1058.             x[0] = 0, y[0] = 0;
  1059.         } else if (mb[-1].mtype == MTYPE263_INTER4V) {
  1060.             x[0] = mb[-1].blkMvX[LOWER_RIGHT_BLK];
  1061.             y[0] = mb[-1].blkMvY[LOWER_RIGHT_BLK];
  1062.         } else {
  1063.             x[0] = mb[-1].mv_x;
  1064.             y[0] = mb[-1].mv_y;
  1065.         }
  1066.         x[1] = mb[0].blkMvX[UPPER_LEFT_BLK];
  1067.         y[1] = mb[0].blkMvY[UPPER_LEFT_BLK];
  1068.         x[2] = mb[0].blkMvX[UPPER_RIGHT_BLK];
  1069.         y[2] = mb[0].blkMvY[UPPER_RIGHT_BLK];
  1070.         *mvX = median3( x );
  1071.         *mvY = median3( y );
  1072.         break;
  1073.         
  1074.     case LOWER_RIGHT_BLK:
  1075.         x[0] = mb[0].blkMvX[LOWER_LEFT_BLK];
  1076.         y[0] = mb[0].blkMvY[LOWER_LEFT_BLK];
  1077.         x[1] = mb[0].blkMvX[UPPER_LEFT_BLK];
  1078.         y[1] = mb[0].blkMvY[UPPER_LEFT_BLK];
  1079.         x[2] = mb[0].blkMvX[UPPER_RIGHT_BLK];
  1080.         y[2] = mb[0].blkMvY[UPPER_RIGHT_BLK];
  1081.         *mvX = median3( x );
  1082.         *mvY = median3( y );
  1083.         break;
  1084.         
  1085.     case WHOLE_MACROBLOCK:
  1086.     case UPPER_LEFT_BLK:
  1087.     default:
  1088.         if (mb[0].x == 0) {     // Left border
  1089.             x[0] = 0, y[0] = 0;
  1090.         } else if (mb[-1].mtype == MTYPE263_INTER4V) {
  1091.             x[0] = mb[-1].blkMvX[UPPER_RIGHT_BLK];
  1092.             y[0] = mb[-1].blkMvY[UPPER_RIGHT_BLK];
  1093.         } else {
  1094.             x[0] = mb[-1].mv_x;
  1095.             y[0] = mb[-1].mv_y;
  1096.         }
  1097.         if (horPredOnly == YES) {   // Top border or sending GOB header to resync
  1098.             *mvX = x[0], *mvY = y[0];
  1099.         } else {
  1100.             if (mb[-mbhor].mtype == MTYPE263_INTER4V) {
  1101.                 x[1] = mb[-mbhor].blkMvX[LOWER_LEFT_BLK];
  1102.                 y[1] = mb[-mbhor].blkMvY[LOWER_LEFT_BLK];
  1103.             } else {
  1104.                 x[1] = mb[-mbhor].mv_x;
  1105.                 y[1] = mb[-mbhor].mv_y;
  1106.             }
  1107.             if (mb[0].x == mbhor - 1) { // Right border
  1108.                 x[2] = 0, y[2] = 0;
  1109.             } else if (mb[1-mbhor].mtype == MTYPE263_INTER4V) {
  1110.                 x[2] = mb[1-mbhor].blkMvX[LOWER_LEFT_BLK];
  1111.                 y[2] = mb[1-mbhor].blkMvY[LOWER_LEFT_BLK];
  1112.             } else {
  1113.                 x[2] = mb[1-mbhor].mv_x;
  1114.                 y[2] = mb[1-mbhor].mv_y;
  1115.             }
  1116.             *mvX = median3( x );
  1117.             *mvY = median3( y );
  1118.         }
  1119.         break;
  1120.     }
  1121.     return;
  1122. }
  1125. // doOverlapMC - Perform overlapped motion compensation on 8x8 block
  1126. static void doOverlapMC( int subBlk,    // Indicates subblock to process (UL, UR, LL, LR)
  1127.                     MACROBLOCK_DESCR *mb,   // Used to determine (x,y) coordinates for block
  1128.                     PICTURE *prevPic,   // Previous picture; used to create overlapping MC
  1129.                     PICTURE *pic, // Contains non-overlapped MC on entry; returns overlapped MC
  1130.                     int borderMv[4][2], // Motion vectors for adjacent blocks (L,Top,R,Bottom)
  1131.                     int left,           // If YES, overlap using LEFT mv
  1132.                     int top,            // If YES, overlap using TOP mv
  1133.                     int right,          // If YES, overlap using RIGHT mv
  1134.                     int bottom          // If YES, overlap using BOTTOM mv
  1135.                     )
  1136. {
  1137. #define LEFT_ADDR           (0)
  1138. #define RIGHT_ADDR          (LEFT_ADDR + 4)
  1139. #define TOP_OFFSET          (8)
  1140. #define TOP_ADDR            (LEFT_ADDR + TOP_OFFSET)
  1141. #define MAX_HDIM            (352)
  1142.     static PIXEL    p[8 * MAX_HDIM];    // MC predictions using neighboring vectors
  1143.         // Only using first 16 columns; line offset chosen to be same as for pictures
  1144.     int     row, col, picOffset, hdim, nhor, nvert, *mv;
  1145.     PIXEL   * source, * dest;
  1147. void (*pMC) ( int hSize, int vSize, PIXEL *in, PIXEL *out, int hdim, int mvX, int mvY);
  1148. #if defined(COMPILE_MMX)
  1149. if(cpuid_is_mmx_motion_on()) {
  1150. //do mmx if compiler switch AND initialized AND detected
  1151. pMC = mcMMX;
  1152. } else 
  1153. #endif
  1154. {
  1155. pMC = mc;
  1156. }
  1157.     // Compute luma pointers
  1158.     col = 16 * mb->x;
  1159.     row = 16 * mb->y;
  1160.     if (subBlk == UPPER_RIGHT_BLK  ||  subBlk == LOWER_RIGHT_BLK)  col += 8;
  1161.     if (subBlk == LOWER_LEFT_BLK  ||  subBlk == LOWER_RIGHT_BLK)  row += 8;
  1162.     hdim = pic->y.hoffset;
  1163.     nhor = pic->y.nhor, nvert = pic->y.nvert;
  1164.     picOffset = col + row * hdim;
  1165.     dest = pic->y.ptr + picOffset;          // Point to output luma (non-overlapped MC)
  1166.     source = prevPic->y.ptr + picOffset;    // Point to input luma (without motion comp)
  1167.     if (hdim > MAX_HDIM) {
  1168.         H261ErrMsg("doOverlapMC - Increase size of internal array");
  1169.         exit(0);
  1170.     }
  1171.     // Create motion compensated blocks using neighboring motion vectors
  1172.     if (left == YES) {  // Produce left 4 columns
  1173.         mv = borderMv[LEFT];
  1174.         if (PointingOutside( col, col+3, row, row+7, *mv, *(mv+1), nhor, nvert)  ==  NO) {
  1175.             pMC( 4,8, source, &p[LEFT_ADDR], hdim, *mv, *(mv+1) );
  1176.         } else {
  1177.             limitMC( 4,8, source, &p[LEFT_ADDR], hdim, *mv, *(mv+1),
  1178.                     -col, nhor - 1 - col, -row, nvert - 1 - row );
  1179.         }
  1180.     }
  1181.     if (right == YES) { // Produce right 4 columns
  1182.         mv = borderMv[RIGHT];
  1183.         if (PointingOutside( col+4, col+7, row, row+7, *mv, *(mv+1), nhor, nvert)  ==  NO) {
  1184.             pMC( 4,8, source + 4, &p[RIGHT_ADDR], hdim, *mv, *(mv+1) );
  1185.         } else {
  1186.             limitMC( 4,8, source + 4, &p[RIGHT_ADDR], hdim, *mv, *(mv+1),
  1187.                     -col - 4, nhor - 1 - col - 4, -row, nvert - 1 - row );
  1188.         }
  1189.     }
  1190.     if (top == YES) {   // Produce top 4 rows
  1191.         mv = borderMv[TOP];
  1192.         if (PointingOutside( col, col+7, row, row+3, *mv, *(mv+1), nhor, nvert)  ==  NO) {
  1193.             pMC( 8,4, source, &p[TOP_ADDR], hdim, *mv, *(mv+1) );
  1194.         } else {
  1195.             limitMC( 8,4, source, &p[TOP_ADDR], hdim, *mv, *(mv+1),
  1196.                     -col, nhor - 1 - col, -row, nvert - 1 - row );
  1197.         }
  1198.     }
  1199.     if (bottom == YES) {    // Produce bottom 4 rows
  1200.         mv = borderMv[BOTTOM];
  1201.         if (PointingOutside( col, col+7, row+4, row+7, *mv, *(mv+1), nhor, nvert)  ==  NO) {
  1202.             pMC( 8,4, source + 4*hdim, &p[TOP_ADDR + 4*hdim], hdim, *mv, *(mv+1) );
  1203.         } else {
  1204.             limitMC( 8,4, source + 4*hdim, &p[TOP_ADDR + 4*hdim], hdim, *mv, *(mv+1),
  1205.                     -col, nhor - 1 - col, -row - 4, nvert - 1 - row - 4 );
  1206.         }
  1207.     }
  1208.     // Produce weighted ("overlapped") MC prediction
  1209.     weigh8x4( dest, &p[LEFT_ADDR], hdim, top, left, right );    // Top 4 rows
  1210.     weigh8x4( dest + 7*hdim, &p[LEFT_ADDR + 7*hdim], -hdim, bottom, left, right );  // Bottom 4 rows
  1211.     return;
  1212. }
  1215. // weigh8x4
  1216. static void weigh8x4( PIXEL *dest, PIXEL const *p, int hdim, int vert, int left, int right )
  1217. {
  1218.     if (vert == YES) {  // Use top/bottom MV
  1219.         if (left == YES) {
  1220.             weighLeft_Vert( dest, &p[LEFT_ADDR], hdim );
  1221.         } else {
  1222.             weighNoLeft_Vert( dest, &p[LEFT_ADDR], hdim );
  1223.         }
  1224.         if (right == YES) {
  1225.             weighRight_Vert( dest + 4, &p[RIGHT_ADDR], hdim );
  1226.         } else {
  1227.             weighNoRight_Vert( dest + 4, &p[RIGHT_ADDR], hdim );
  1228.         }
  1229.     } else {
  1230.         if (left == YES) {
  1231.             weighLeft( dest, &p[LEFT_ADDR], hdim );
  1232.         }
  1233.         if (right == YES) {
  1234.             weighRight( dest + 4, &p[RIGHT_ADDR], hdim );
  1235.         }
  1236.     }
  1237.     return;
  1238. }
  1241. // weighLeft_Vert - Overlap three MC predictions for upper left 4x4 pixels
  1242. static void weighLeft_Vert( PIXEL *dest,    // Non-overlapped MC; overlapped by this routine
  1243.                             PIXEL const *p, // p: MC using left motion vector
  1244.                                             // &p[TOP_OFFSET]: MC using top/bottom MV
  1245.                             int hdim )      // Line offset
  1246. {
  1247.     // First row
  1248.     dest[0] = (2 * dest[0] +     p[0] +     p[TOP_OFFSET + 0] + 2) >> 2;
  1249.     dest[1] = (5 * dest[1] +     p[1] + 2 * p[TOP_OFFSET + 1] + 4) >> 3;
  1250.     dest[2] = (5 * dest[2] +     p[2] + 2 * p[TOP_OFFSET + 2] + 4) >> 3;
  1251.     dest[3] = (5 * dest[3] +     p[3] + 2 * p[TOP_OFFSET + 3] + 4) >> 3;
  1252.     // Second row
  1253.     dest += hdim, p += hdim;
  1254.     dest[0] = (5 * dest[0] + 2 * p[0] +     p[TOP_OFFSET + 0] + 4) >> 3;
  1255.     dest[1] = (5 * dest[1] + 2 * p[1] +     p[TOP_OFFSET + 1] + 4) >> 3;
  1256.     dest[2] = (5 * dest[2] +     p[2] + 2 * p[TOP_OFFSET + 2] + 4) >> 3;
  1257.     dest[3] = (5 * dest[3] +     p[3] + 2 * p[TOP_OFFSET + 3] + 4) >> 3;
  1258.     // Third row
  1259.     dest += hdim, p += hdim;
  1260.     dest[0] = (5 * dest[0] + 2 * p[0] +     p[TOP_OFFSET + 0] + 4) >> 3;
  1261.     dest[1] = (5 * dest[1] + 2 * p[1] +     p[TOP_OFFSET + 1] + 4) >> 3;
  1262.     dest[2] = (6 * dest[2] +     p[2] +     p[TOP_OFFSET + 2] + 4) >> 3;
  1263.     dest[3] = (6 * dest[3] +     p[3] +     p[TOP_OFFSET + 3] + 4) >> 3;
  1264.     // Fourth row (identical to third row)
  1265.     dest += hdim, p += hdim;
  1266.     dest[0] = (5 * dest[0] + 2 * p[0] +     p[TOP_OFFSET + 0] + 4) >> 3;
  1267.     dest[1] = (5 * dest[1] + 2 * p[1] +     p[TOP_OFFSET + 1] + 4) >> 3;
  1268.     dest[2] = (6 * dest[2] +     p[2] +     p[TOP_OFFSET + 2] + 4) >> 3;
  1269.     dest[3] = (6 * dest[3] +     p[3] +     p[TOP_OFFSET + 3] + 4) >> 3;
  1270.     return;
  1271. }
  1274. // weighNoLeft_Vert - Overlap with MV from vert. neighbor for upper left 4x4 pixels
  1275. static void weighNoLeft_Vert( PIXEL *dest, PIXEL const *p, int hdim )
  1276. {
  1277.     // First row
  1278.     dest[0] = (3 * dest[0] +  p[TOP_OFFSET + 0] + 2) >> 2;
  1279.     dest[1] = (3 * dest[1] +  p[TOP_OFFSET + 1] + 2) >> 2;
  1280.     dest[2] = (3 * dest[2] +  p[TOP_OFFSET + 2] + 2) >> 2;
  1281.     dest[3] = (3 * dest[3] +  p[TOP_OFFSET + 3] + 2) >> 2;
  1282.     // Second row
  1283.     dest += hdim, p += hdim;
  1284.     dest[0] = (7 * dest[0] +  p[TOP_OFFSET + 0] + 4) >> 3;
  1285.     dest[1] = (7 * dest[1] +  p[TOP_OFFSET + 1] + 4) >> 3;
  1286.     dest[2] = (3 * dest[2] +  p[TOP_OFFSET + 2] + 2) >> 2;
  1287.     dest[3] = (3 * dest[3] +  p[TOP_OFFSET + 3] + 2) >> 2;
  1288.     // Third row
  1289.     dest += hdim, p += hdim;
  1290.     dest[0] = (7 * dest[0] +  p[TOP_OFFSET + 0] + 4) >> 3;
  1291.     dest[1] = (7 * dest[1] +  p[TOP_OFFSET + 1] + 4) >> 3;
  1292.     dest[2] = (7 * dest[2] +  p[TOP_OFFSET + 2] + 4) >> 3;
  1293.     dest[3] = (7 * dest[3] +  p[TOP_OFFSET + 3] + 4) >> 3;
  1294.     // Fourth row (identical to third row)
  1295.     dest += hdim, p += hdim;
  1296.     dest[0] = (7 * dest[0] +  p[TOP_OFFSET + 0] + 4) >> 3;
  1297.     dest[1] = (7 * dest[1] +  p[TOP_OFFSET + 1] + 4) >> 3;
  1298.     dest[2] = (7 * dest[2] +  p[TOP_OFFSET + 2] + 4) >> 3;
  1299.     dest[3] = (7 * dest[3] +  p[TOP_OFFSET + 3] + 4) >> 3;
  1300.     return;
  1301. }
  1304. // weighLeft - Overlap with MV from left neighbor for upper left 4x4 pixels
  1305. static void weighLeft( PIXEL *dest, PIXEL const *p, int hdim )
  1306. {
  1307.     // First row
  1308.     dest[0] = (3 * dest[0] +  p[0] + 2) >> 2;
  1309.     dest[1] = (7 * dest[1] +  p[1] + 4) >> 3;
  1310.     dest[2] = (7 * dest[2] +  p[2] + 4) >> 3;
  1311.     dest[3] = (7 * dest[3] +  p[3] + 4) >> 3;
  1312.     // Second row
  1313.     dest += hdim, p += hdim;
  1314.     dest[0] = (3 * dest[0] +  p[0] + 2) >> 2;
  1315.     dest[1] = (3 * dest[1] +  p[1] + 2) >> 2;
  1316.     dest[2] = (7 * dest[2] +  p[2] + 4) >> 3;
  1317.     dest[3] = (7 * dest[3] +  p[3] + 4) >> 3;
  1318.     // Third row (identical to second row)
  1319.     dest += hdim, p += hdim;
  1320.     dest[0] = (3 * dest[0] +  p[0] + 2) >> 2;
  1321.     dest[1] = (3 * dest[1] +  p[1] + 2) >> 2;
  1322.     dest[2] = (7 * dest[2] +  p[2] + 4) >> 3;
  1323.     dest[3] = (7 * dest[3] +  p[3] + 4) >> 3;
  1324.     // Fourth row (identical to third row)
  1325.     dest += hdim, p += hdim;
  1326.     dest[0] = (3 * dest[0] +  p[0] + 2) >> 2;
  1327.     dest[1] = (3 * dest[1] +  p[1] + 2) >> 2;
  1328.     dest[2] = (7 * dest[2] +  p[2] + 4) >> 3;
  1329.     dest[3] = (7 * dest[3] +  p[3] + 4) >> 3;
  1330.     return;
  1331. }
  1334. // weighRight_Vert - Derived from weighLeft_Vert by reversing indices
  1335. //  This means that the assembler routine can be easily derived from the other
  1336. static void weighRight_Vert( PIXEL *dest,   // Non-overlapped MC; overlapped by this routine
  1337.                             PIXEL const *p, // p: MC using right motion vector
  1338.                                             // &p[TOP_OFFSET]: MC using top/bottom MV
  1339.                             int hdim )      // Line offset
  1340. {
  1341.     // First row
  1342.     dest[3] = (2 * dest[3] +     p[3] +     p[TOP_OFFSET + 3] + 2) >> 2;
  1343.     dest[2] = (5 * dest[2] +     p[2] + 2 * p[TOP_OFFSET + 2] + 4) >> 3;
  1344.     dest[1] = (5 * dest[1] +     p[1] + 2 * p[TOP_OFFSET + 1] + 4) >> 3;
  1345.     dest[0] = (5 * dest[0] +     p[0] + 2 * p[TOP_OFFSET + 0] + 4) >> 3;
  1346.     // Second row
  1347.     dest += hdim, p += hdim;
  1348.     dest[3] = (5 * dest[3] + 2 * p[3] +     p[TOP_OFFSET + 3] + 4) >> 3;
  1349.     dest[2] = (5 * dest[2] + 2 * p[2] +     p[TOP_OFFSET + 2] + 4) >> 3;
  1350.     dest[1] = (5 * dest[1] +     p[1] + 2 * p[TOP_OFFSET + 1] + 4) >> 3;
  1351.     dest[0] = (5 * dest[0] +     p[0] + 2 * p[TOP_OFFSET + 0] + 4) >> 3;
  1352.     // Third row
  1353.     dest += hdim, p += hdim;
  1354.     dest[3] = (5 * dest[3] + 2 * p[3] +     p[TOP_OFFSET + 3] + 4) >> 3;
  1355.     dest[2] = (5 * dest[2] + 2 * p[2] +     p[TOP_OFFSET + 2] + 4) >> 3;
  1356.     dest[1] = (6 * dest[1] +     p[1] +     p[TOP_OFFSET + 1] + 4) >> 3;
  1357.     dest[0] = (6 * dest[0] +     p[0] +     p[TOP_OFFSET + 0] + 4) >> 3;
  1358.     // Fourth row (identical to third row)
  1359.     dest += hdim, p += hdim;
  1360.     dest[3] = (5 * dest[3] + 2 * p[3] +     p[TOP_OFFSET + 3] + 4) >> 3;
  1361.     dest[2] = (5 * dest[2] + 2 * p[2] +     p[TOP_OFFSET + 2] + 4) >> 3;
  1362.     dest[1] = (6 * dest[1] +     p[1] +     p[TOP_OFFSET + 1] + 4) >> 3;
  1363.     dest[0] = (6 * dest[0] +     p[0] +     p[TOP_OFFSET + 0] + 4) >> 3;
  1364.     return;
  1365. }
  1368. // weighNoRight_Vert - Derived from weighNoLeft_Vert by reversing indices
  1369. //  This means that the assembler routine can be easily derived from the other
  1370. static void weighNoRight_Vert( PIXEL *dest, PIXEL const *p, int hdim )
  1371. {
  1372.     // First row
  1373.     dest[3] = (3 * dest[3] +  p[TOP_OFFSET + 3] + 2) >> 2;
  1374.     dest[2] = (3 * dest[2] +  p[TOP_OFFSET + 2] + 2) >> 2;
  1375.     dest[1] = (3 * dest[1] +  p[TOP_OFFSET + 1] + 2) >> 2;
  1376.     dest[0] = (3 * dest[0] +  p[TOP_OFFSET + 0] + 2) >> 2;
  1377.     // Second row
  1378.     dest += hdim, p += hdim;
  1379.     dest[3] = (7 * dest[3] +  p[TOP_OFFSET + 3] + 4) >> 3;
  1380.     dest[2] = (7 * dest[2] +  p[TOP_OFFSET + 2] + 4) >> 3;
  1381.     dest[1] = (3 * dest[1] +  p[TOP_OFFSET + 1] + 2) >> 2;
  1382.     dest[0] = (3 * dest[0] +  p[TOP_OFFSET + 0] + 2) >> 2;
  1383.     // Third row
  1384.     dest += hdim, p += hdim;
  1385.     dest[3] = (7 * dest[3] +  p[TOP_OFFSET + 3] + 4) >> 3;
  1386.     dest[2] = (7 * dest[2] +  p[TOP_OFFSET + 2] + 4) >> 3;
  1387.     dest[1] = (7 * dest[1] +  p[TOP_OFFSET + 1] + 4) >> 3;
  1388.     dest[0] = (7 * dest[0] +  p[TOP_OFFSET + 0] + 4) >> 3;
  1389.     // Fourth row (identical to third row)
  1390.     dest += hdim, p += hdim;
  1391.     dest[3] = (7 * dest[3] +  p[TOP_OFFSET + 3] + 4) >> 3;
  1392.     dest[2] = (7 * dest[2] +  p[TOP_OFFSET + 2] + 4) >> 3;
  1393.     dest[1] = (7 * dest[1] +  p[TOP_OFFSET + 1] + 4) >> 3;
  1394.     dest[0] = (7 * dest[0] +  p[TOP_OFFSET + 0] + 4) >> 3;
  1395.     return;
  1396. }
  1399. // weighRight - Derived from weighLeft by reversing indices
  1400. //  This means that the assembler routine can be easily derived from the other
  1401. static void weighRight( PIXEL *dest, PIXEL const *p, int hdim )
  1402. {
  1403.     // First row
  1404.     dest[3] = (3 * dest[3] +  p[3] + 2) >> 2;
  1405.     dest[2] = (7 * dest[2] +  p[2] + 4) >> 3;
  1406.     dest[1] = (7 * dest[1] +  p[1] + 4) >> 3;
  1407.     dest[0] = (7 * dest[0] +  p[0] + 4) >> 3;
  1408.     // Second row
  1409.     dest += hdim, p += hdim;
  1410.     dest[3] = (3 * dest[3] +  p[3] + 2) >> 2;
  1411.     dest[2] = (3 * dest[2] +  p[2] + 2) >> 2;
  1412.     dest[1] = (7 * dest[1] +  p[1] + 4) >> 3;
  1413.     dest[0] = (7 * dest[0] +  p[0] + 4) >> 3;
  1414.     // Third row (identical to second row)
  1415.     dest += hdim, p += hdim;
  1416.     dest[3] = (3 * dest[3] +  p[3] + 2) >> 2;
  1417.     dest[2] = (3 * dest[2] +  p[2] + 2) >> 2;
  1418.     dest[1] = (7 * dest[1] +  p[1] + 4) >> 3;
  1419.     dest[0] = (7 * dest[0] +  p[0] + 4) >> 3;
  1420.     // Fourth row (identical to third row)
  1421.     dest += hdim, p += hdim;
  1422.     dest[3] = (3 * dest[3] +  p[3] + 2) >> 2;
  1423.     dest[2] = (3 * dest[2] +  p[2] + 2) >> 2;
  1424.     dest[1] = (7 * dest[1] +  p[1] + 4) >> 3;
  1425.     dest[0] = (7 * dest[0] +  p[0] + 4) >> 3;
  1426.     return;
  1427. }
  1430. static void mc16pelsNoInterpol( PIXEL *in, PIXEL *out, int hdim, int vSize )
  1431. {
  1432. #ifndef FOR_UNIX
  1433.     union { // Copy words to speed up routine
  1434.         PIXEL   *pix;
  1435.         U32     *word;
  1436.     } pIn, pOut;
  1438.     pIn.pix = in;
  1439.     pOut.pix = out;
  1440.     while (vSize > 0) {
  1441.         *(pOut.word + 0) = *(pIn.word + 0);
  1442.         *(pOut.word + 1) = *(pIn.word + 1);
  1443.         *(pOut.word + 2) = *(pIn.word + 2);
  1444.         *(pOut.word + 3) = *(pIn.word + 3);
  1445.         pIn.pix += hdim;
  1446.         pOut.pix += hdim;
  1447.         --vSize;
  1448.     }
  1449.     return;
  1450. #else
  1451.     union { // PIXELs are not always word-aligned! Gotta copy bytes in UNIX
  1452.         PIXEL   *pix;
  1453.         BYTE    *byte;
  1454.     } pIn, pOut;
  1456.     BYTE    *pInbyte;
  1457.     BYTE    *pOutbyte;
  1458.     int     i;
  1460.     pIn.pix = in;
  1461.     pOut.pix = out;
  1462.     while (vSize > 0) {
  1463.         pInbyte = pIn.byte;
  1464.         pOutbyte = pOut.byte;
  1465.         for (i=0; i<16; i++)
  1466.   *(pOutbyte++) = *(pInbyte++);
  1468.         pIn.pix += hdim;
  1469.         pOut.pix += hdim;
  1470.         --vSize;
  1471.     }
  1472.     return;
  1473. #endif
  1474. }
  1477. static void mc8pelsNoInterpol( PIXEL *in, PIXEL *out, int hdim, int vSize )
  1478. {
  1479. #ifndef FOR_UNIX
  1480.     union { // Copy words to speed up routine
  1481.         PIXEL   *pix;
  1482.         U32     *word;
  1483.     } pIn, pOut;
  1485.     pIn.pix = in;
  1486.     pOut.pix = out;
  1487.     while (vSize > 0) {
  1488.         *(pOut.word + 0) = *(pIn.word + 0);
  1489.         *(pOut.word + 1) = *(pIn.word + 1);
  1490.         pIn.pix += hdim;
  1491.         pOut.pix += hdim;
  1492.         --vSize;
  1493.     }
  1494.     return;
  1495. #else
  1496.     union { // PIXELs are not always word-aligned! Gotta copy bytes in UNIX
  1497.         PIXEL   *pix;
  1498.         BYTE    *byte;
  1499.     } pIn, pOut;
  1501.     pIn.pix = in;
  1502.     pOut.pix = out;
  1503.     while (vSize > 0) {
  1504.         *(pOut.byte + 0) = *(pIn.byte + 0);
  1505.         *(pOut.byte + 1) = *(pIn.byte + 1);
  1506.         *(pOut.byte + 2) = *(pIn.byte + 2);
  1507.         *(pOut.byte + 3) = *(pIn.byte + 3);
  1508.         *(pOut.byte + 4) = *(pIn.byte + 4);
  1509.         *(pOut.byte + 5) = *(pIn.byte + 5);
  1510.         *(pOut.byte + 6) = *(pIn.byte + 6);
  1511.         *(pOut.byte + 7) = *(pIn.byte + 7);
  1512.         pIn.pix += hdim;
  1513.         pOut.pix += hdim;
  1514.         --vSize;
  1515.     }
  1516.     return;
  1517. #endif
  1518. }
  1521. static void mc4pelsNoInterpol( PIXEL *in, PIXEL *out, int hdim, int vSize )
  1522. {
  1523. #ifndef FOR_UNIX
  1524.     union { // Copy words to speed up routine
  1525.         PIXEL   *pix;
  1526.         U32     *word;
  1527.     } pIn, pOut;
  1529.     pIn.pix = in;
  1530.     pOut.pix = out;
  1531.     while (vSize > 0) {
  1532.         *(pOut.word + 0) = *(pIn.word + 0);
  1533.         pIn.pix += hdim;
  1534.         pOut.pix += hdim;
  1535.         --vSize;
  1536.     }
  1537.     return;
  1538. #else
  1539.     union { // PIXELs are not always word-aligned! Gotta copy bytes in UNIX
  1540.         PIXEL   *pix;
  1541.         BYTE    *byte;
  1542.     } pIn, pOut;
  1544.     pIn.pix = in;
  1545.     pOut.pix = out;
  1546.     while (vSize > 0) {
  1547.         *(pOut.byte + 0) = *(pIn.byte + 0);
  1548.         *(pOut.byte + 1) = *(pIn.byte + 1);
  1549.         *(pOut.byte + 2) = *(pIn.byte + 2);
  1550.         *(pOut.byte + 3) = *(pIn.byte + 3);
  1551.         pIn.pix += hdim;
  1552.         pOut.pix += hdim;
  1553.         --vSize;
  1554.     }
  1555.     return;
  1556. #endif
  1557. }
  1560. static void mc16pelsHorInterpol( PIXEL const *in, PIXEL *out, int hdim, int vSize )
  1561. {
  1562.     while (vSize > 0) {
  1563.         out[0] = (in[0] + in[1] + 1) >> 1;
  1564.         out[1] = (in[1] + in[2] + 1) >> 1;
  1565.         out[2] = (in[2] + in[3] + 1) >> 1;
  1566.         out[3] = (in[3] + in[4] + 1) >> 1;
  1567.         out[4] = (in[4] + in[5] + 1) >> 1;
  1568.         out[5] = (in[5] + in[6] + 1) >> 1;
  1569.         out[6] = (in[6] + in[7] + 1) >> 1;
  1570.         out[7] = (in[7] + in[8] + 1) >> 1;
  1571.         out[8] = (in[8] + in[9] + 1) >> 1;
  1572.         out[9] = (in[9] + in[10] + 1) >> 1;
  1573.         out[10] = (in[10] + in[11] + 1) >> 1;
  1574.         out[11] = (in[11] + in[12] + 1) >> 1;
  1575.         out[12] = (in[12] + in[13] + 1) >> 1;
  1576.         out[13] = (in[13] + in[14] + 1) >> 1;
  1577.         out[14] = (in[14] + in[15] + 1) >> 1;
  1578.         out[15] = (in[15] + in[16] + 1) >> 1;
  1579.         in += hdim;
  1580.         out += hdim;
  1581.         --vSize;
  1582.     }
  1583.     return;
  1584. }
  1587. static void mc8pelsHorInterpol( PIXEL const *in, PIXEL *out, int hdim, int vSize )
  1588. {
  1589.     while (vSize > 0) {
  1590.         out[0] = (in[0] + in[1] + 1) >> 1;
  1591.         out[1] = (in[1] + in[2] + 1) >> 1;
  1592.         out[2] = (in[2] + in[3] + 1) >> 1;
  1593.         out[3] = (in[3] + in[4] + 1) >> 1;
  1594.         out[4] = (in[4] + in[5] + 1) >> 1;
  1595.         out[5] = (in[5] + in[6] + 1) >> 1;
  1596.         out[6] = (in[6] + in[7] + 1) >> 1;
  1597.         out[7] = (in[7] + in[8] + 1) >> 1;
  1598.         in += hdim;
  1599.         out += hdim;
  1600.         --vSize;
  1601.     }
  1602.     return;
  1603. }
  1606. static void mc4pelsHorInterpol( PIXEL const *in, PIXEL *out, int hdim, int vSize )
  1607. {
  1608.     while (vSize > 0) {
  1609.         out[0] = (in[0] + in[1] + 1) >> 1;
  1610.         out[1] = (in[1] + in[2] + 1) >> 1;
  1611.         out[2] = (in[2] + in[3] + 1) >> 1;
  1612.         out[3] = (in[3] + in[4] + 1) >> 1;
  1613.         in += hdim;
  1614.         out += hdim;
  1615.         --vSize;
  1616.     }
  1617.     return;
  1618. }
  1621. static void mc16pelsVertInterpol( PIXEL const *in, PIXEL *out, int hdim, int vSize )
  1622. {
  1623.     while (vSize > 0) {
  1624.         out[0] = (in[0] + in[hdim+0] + 1) >> 1;
  1625.         out[1] = (in[1] + in[hdim+1] + 1) >> 1;
  1626.         out[2] = (in[2] + in[hdim+2] + 1) >> 1;
  1627.         out[3] = (in[3] + in[hdim+3] + 1) >> 1;
  1628.         out[4] = (in[4] + in[hdim+4] + 1) >> 1;
  1629.         out[5] = (in[5] + in[hdim+5] + 1) >> 1;
  1630.         out[6] = (in[6] + in[hdim+6] + 1) >> 1;
  1631.         out[7] = (in[7] + in[hdim+7] + 1) >> 1;
  1632.         out[8] = (in[8] + in[hdim+8] + 1) >> 1;
  1633.         out[9] = (in[9] + in[hdim+9] + 1) >> 1;
  1634.         out[10] = (in[10] + in[hdim+10] + 1) >> 1;
  1635.         out[11] = (in[11] + in[hdim+11] + 1) >> 1;
  1636.         out[12] = (in[12] + in[hdim+12] + 1) >> 1;
  1637.         out[13] = (in[13] + in[hdim+13] + 1) >> 1;
  1638.         out[14] = (in[14] + in[hdim+14] + 1) >> 1;
  1639.         out[15] = (in[15] + in[hdim+15] + 1) >> 1;
  1640.         in += hdim;
  1641.         out += hdim;
  1642.         --vSize;
  1643.     }
  1644.     return;
  1645. }
  1648. static void mc8pelsVertInterpol( PIXEL const *in, PIXEL *out, int hdim, int vSize )
  1649. {
  1650.     while (vSize > 0) {
  1651.         out[0] = (in[0] + in[hdim+0] + 1) >> 1;
  1652.         out[1] = (in[1] + in[hdim+1] + 1) >> 1;
  1653.         out[2] = (in[2] + in[hdim+2] + 1) >> 1;
  1654.         out[3] = (in[3] + in[hdim+3] + 1) >> 1;
  1655.         out[4] = (in[4] + in[hdim+4] + 1) >> 1;
  1656.         out[5] = (in[5] + in[hdim+5] + 1) >> 1;
  1657.         out[6] = (in[6] + in[hdim+6] + 1) >> 1;
  1658.         out[7] = (in[7] + in[hdim+7] + 1) >> 1;
  1659.         in += hdim;
  1660.         out += hdim;
  1661.         --vSize;
  1662.     }
  1663.     return;
  1664. }
  1667. static void mc4pelsVertInterpol( PIXEL const *in, PIXEL *out, int hdim, int vSize )
  1668. {
  1669.     while (vSize > 0) {
  1670.         out[0] = (in[0] + in[hdim+0] + 1) >> 1;
  1671.         out[1] = (in[1] + in[hdim+1] + 1) >> 1;
  1672.         out[2] = (in[2] + in[hdim+2] + 1) >> 1;
  1673.         out[3] = (in[3] + in[hdim+3] + 1) >> 1;
  1674.         in += hdim;
  1675.         out += hdim;
  1676.         --vSize;
  1677.     }
  1678.     return;
  1679. }
  1682. static void mc16pels2DInterpol( PIXEL const *in, PIXEL *out, int hdim, int vSize )
  1683. {
  1684.     while (vSize > 0) {
  1685.         out[0] = (in[0] + in[1] + in[hdim+0] + in[hdim+1] + 2) >> 2;
  1686.         out[1] = (in[1] + in[2] + in[hdim+1] + in[hdim+2] + 2) >> 2;
  1687.         out[2] = (in[2] + in[3] + in[hdim+2] + in[hdim+3] + 2) >> 2;
  1688.         out[3] = (in[3] + in[4] + in[hdim+3] + in[hdim+4] + 2) >> 2;
  1689.         out[4] = (in[4] + in[5] + in[hdim+4] + in[hdim+5] + 2) >> 2;
  1690.         out[5] = (in[5] + in[6] + in[hdim+5] + in[hdim+6] + 2) >> 2;
  1691.         out[6] = (in[6] + in[7] + in[hdim+6] + in[hdim+7] + 2) >> 2;
  1692.         out[7] = (in[7] + in[8] + in[hdim+7] + in[hdim+8] + 2) >> 2;
  1693.         out[8] = (in[8] + in[9] + in[hdim+8] + in[hdim+9] + 2) >> 2;
  1694.         out[9] = (in[9] + in[10] + in[hdim+9] + in[hdim+10] + 2) >> 2;
  1695.         out[10] = (in[10] + in[11] + in[hdim+10] + in[hdim+11] + 2) >> 2;
  1696.         out[11] = (in[11] + in[12] + in[hdim+11] + in[hdim+12] + 2) >> 2;
  1697.         out[12] = (in[12] + in[13] + in[hdim+12] + in[hdim+13] + 2) >> 2;
  1698.         out[13] = (in[13] + in[14] + in[hdim+13] + in[hdim+14] + 2) >> 2;
  1699.         out[14] = (in[14] + in[15] + in[hdim+14] + in[hdim+15] + 2) >> 2;
  1700.         out[15] = (in[15] + in[16] + in[hdim+15] + in[hdim+16] + 2) >> 2;
  1701.         in += hdim;
  1702.         out += hdim;
  1703.         --vSize;
  1704.     }
  1705.     return;
  1706. }
  1709. static void mc8pels2DInterpol( PIXEL const *in, PIXEL *out, int hdim, int vSize )
  1710. {
  1711.     while (vSize > 0) {
  1712.         out[0] = (in[0] + in[1] + in[hdim+0] + in[hdim+1] + 2) >> 2;
  1713.         out[1] = (in[1] + in[2] + in[hdim+1] + in[hdim+2] + 2) >> 2;
  1714.         out[2] = (in[2] + in[3] + in[hdim+2] + in[hdim+3] + 2) >> 2;
  1715.         out[3] = (in[3] + in[4] + in[hdim+3] + in[hdim+4] + 2) >> 2;
  1716.         out[4] = (in[4] + in[5] + in[hdim+4] + in[hdim+5] + 2) >> 2;
  1717.         out[5] = (in[5] + in[6] + in[hdim+5] + in[hdim+6] + 2) >> 2;
  1718.         out[6] = (in[6] + in[7] + in[hdim+6] + in[hdim+7] + 2) >> 2;
  1719.         out[7] = (in[7] + in[8] + in[hdim+7] + in[hdim+8] + 2) >> 2;
  1720.         in += hdim;
  1721.         out += hdim;
  1722.         --vSize;
  1723.     }
  1724.     return;
  1725. }
  1728. static void mc4pels2DInterpol( PIXEL const *in, PIXEL *out, int hdim, int vSize )
  1729. {
  1730.     while (vSize > 0) {
  1731.         out[0] = (in[0] + in[1] + in[hdim+0] + in[hdim+1] + 2) >> 2;
  1732.         out[1] = (in[1] + in[2] + in[hdim+1] + in[hdim+2] + 2) >> 2;
  1733.         out[2] = (in[2] + in[3] + in[hdim+2] + in[hdim+3] + 2) >> 2;
  1734.         out[3] = (in[3] + in[4] + in[hdim+3] + in[hdim+4] + 2) >> 2;
  1735.         in += hdim;
  1736.         out += hdim;
  1737.         --vSize;
  1738.     }
  1739.     return;
  1740. }
  1743. // Temporary arrays for backwards prediction (using next P-picture)
  1744. static  PIXEL   yBack[16*16], cbBack[8*8], crBack[8*8];
  1746. // saveBackwardPred - save macroblock to temporary area
  1747. static void saveBackwardPred( MACROBLOCK_DESCR * mb,    // Describes block to be saved
  1748.                               PICTURE * pic // Picture with pixels to be saved
  1749.                               )
  1750. {
  1751.     int     row, col, picOffset, hdim;
  1753.     // Compute luma pointer
  1754.     col = 16 * mb->x;
  1755.     row = 16 * mb->y;
  1756.     hdim = pic->y.hoffset;
  1757.     picOffset = col + row * hdim;
  1758.     // Copy luma block
  1759.     copyBlock( (S32 *)(pic->y.ptr + picOffset), 16>>2, 16, hdim>>2, (S32 *)yBack, 16>>2 );
  1760.     // Compute chroma pointer
  1761.     col = 8 * mb->x;
  1762.     row = 8 * mb->y;
  1763.     hdim = pic->cb.hoffset;
  1764.     picOffset = col + row * hdim;
  1765.     // Copy chroma blocks
  1766.     copyBlock( (S32 *)(pic->cb.ptr + picOffset), 8>>2, 8, hdim>>2, (S32 *)cbBack, 8>>2 );
  1767.     copyBlock( (S32 *)(pic->cr.ptr + picOffset), 8>>2, 8, hdim>>2, (S32 *)crBack, 8>>2 );
  1768. }
  1771. // averageForBack - Compute B-frame prediction from forward and backward predictions
  1772. static void averageForBack( MACROBLOCK_DESCR * mb,  // Describes block to be averaged
  1773.                             PICTURE * pic   // Input: contains forward prediction
  1774.                                             // Output: contains B-frame prediction
  1775.                             )
  1776. {
  1777.     int row, col, hdim, blk, firstCol, lastCol, firstRow, lastRow, cX, cY;
  1778. void (*pAverageBlockFunction)( PIXEL forPred[], int hSize, int vSize, int forOffset,
  1779.                           PIXEL backPred[], int backOffset );
  1780. #if defined(COMPILE_MMX)
  1781. if(cpuid_is_mmx_motion_on()) {
  1782. //do mmx if compiler switch AND initialized AND detected
  1783. pAverageBlockFunction = averageBlockMMX;
  1784. } else 
  1785. #endif
  1786. {
  1787. pAverageBlockFunction = averageBlock;
  1788. }
  1790.     // Process luma
  1791.     col = 16 * mb->x;
  1792.     row = 16 * mb->y;
  1793.     hdim = pic->y.hoffset;
  1794.     if (mb->mtype == MTYPE263_INTER4V) {
  1795.         for (blk = 0; blk < 4; ++blk) { // Treat each 8x8 block separately
  1796.             // Only use pixels in current MB for backwards prediction
  1797.             if (blk & 0x1) {
  1798.                 firstCol = 8, lastCol = 15; // Block 1 and 3
  1799.             } else {
  1800.                 firstCol = 0, lastCol = 7;  // Block 0 and 2
  1801.             }
  1802.             if (blk & 0x2) {
  1803.                 firstRow = 8, lastRow = 15; // Block 2 and 3
  1804.             } else {
  1805.                 firstRow = 0, lastRow = 7;  // Block 0 and 1
  1806.             }
  1807.             firstCol = max( firstCol,     (-mb->blkMvBx[blk] + 1) >> 1 );
  1808.             lastCol  = min( lastCol, 15 - ((mb->blkMvBx[blk] + 1) >> 1));
  1809.             firstRow = max( firstRow,     (-mb->blkMvBy[blk] + 1) >> 1 );
  1810.             lastRow  = min( lastRow, 15 - ((mb->blkMvBy[blk] + 1) >> 1));
  1811.             pAverageBlockFunction( pic->y.ptr + col + firstCol + (row + firstRow) * hdim,
  1812.                           lastCol - firstCol + 1,
  1813.                           lastRow - firstRow + 1, hdim,
  1814.                           yBack + firstCol + firstRow * 16, 16 );
  1815.         }
  1816.         // Determine motion vector for chroma block
  1817.         cX = chromaMvComp4V( mb->blkMvBx );
  1818.         cY = chromaMvComp4V( mb->blkMvBy );
  1819.     } else {
  1820.         // Only use pixels in current MB for backwards prediction
  1821.         firstCol = max( 0,       (-mb->blkMvBx[0] + 1) >> 1 );
  1822.         lastCol  = min( 15, 15 - ((mb->blkMvBx[0] + 1) >> 1));
  1823.         firstRow = max( 0,       (-mb->blkMvBy[0] + 1) >> 1 );
  1824.         lastRow  = min( 15, 15 - ((mb->blkMvBy[0] + 1) >> 1));
  1825. //#define MMX_AVERAGE_TEST01
  1826. #ifdef MMX_AVERAGE_TEST01
  1827. {
  1828. int crow, ccol;
  1829. PIXEL *forPred = pic->y.ptr + col + firstCol + (row + firstRow) * hdim;
  1830. int hSize = lastCol - firstCol + 1;
  1831. int vSize = lastRow - firstRow + 1;
  1832. int forOffset = hdim;
  1833. PIXEL *backPred = yBack + firstCol + firstRow * 16;
  1834. int backOffset = 16;
  1835. PIXEL forPred_org[16*352];
  1836. PIXEL backPred_org[16*16];
  1837. PIXEL forPred_temp[16*352];
  1838. PIXEL backPred_temp[16*16];
  1839. int countForOffset; 
  1840. int countBackOffset; 
  1841. int bError = 0;
  1843. countForOffset = 0; 
  1844. countBackOffset = 0; 
  1845. for (crow = 0; crow < vSize; ++crow) {
  1846. for (ccol = 0; ccol < hSize; ++ccol) {//from smaller multiple of 4
  1847. forPred_org[ccol + countForOffset] = forPred[ccol + countForOffset];
  1848. backPred_org[ccol + countBackOffset] = backPred[ccol + countBackOffset];
  1849. forPred_temp[ccol + countForOffset] = forPred[ccol + countForOffset];
  1850. backPred_temp[ccol + countBackOffset] = backPred[ccol + countBackOffset];
  1851. }
  1852. countForOffset  += forOffset;
  1853. countBackOffset += backOffset;
  1854. }
  1856. averageBlock( forPred_org,
  1857.   lastCol - firstCol + 1,
  1858.   lastRow - firstRow + 1, hdim,
  1859.   backPred_org, 16 );
  1860. #endif
  1861.         pAverageBlockFunction( pic->y.ptr + col + firstCol + (row + firstRow) * hdim,
  1862.                       lastCol - firstCol + 1,
  1863.                       lastRow - firstRow + 1, hdim,
  1864.                       yBack + firstCol + firstRow * 16, 16 );
  1866. #ifdef MMX_AVERAGE_TEST01
  1867.     countForOffset  =0;
  1868.     countBackOffset = 0;
  1869.     for (crow = 0; crow < vSize; ++crow) {
  1870.         for (ccol = 0; ccol < hSize; ++ccol) {//from smaller multiple of 4
  1871.             if( (forPred_org[ccol + countForOffset] != forPred[ccol + countForOffset])) {//((hSize==8) || (hSize==16)) &&
  1872. bError = 1;
  1873. }
  1874.         }
  1875.         countForOffset  += forOffset;
  1876.         countBackOffset += backOffset;
  1877.     }
  1878. if(bError!=0) {
  1879. countForOffset = 0; 
  1880. countBackOffset = 0; 
  1881. for (crow = 0; crow < vSize; ++crow) {
  1882. for (ccol = 0; ccol < hSize; ++ccol) {//from smaller multiple of 4
  1883. forPred_org[ccol + countForOffset] = forPred[ccol + countForOffset] = forPred_temp[ccol + countForOffset];
  1884. backPred_org[ccol + countBackOffset] = backPred[ccol + countBackOffset] = backPred_temp[ccol + countBackOffset];
  1885. }
  1886. countForOffset  += forOffset;
  1887. countBackOffset += backOffset;
  1888. }
  1890. averageBlock( forPred_org,
  1891.   lastCol - firstCol + 1,
  1892.   lastRow - firstRow + 1, hdim,
  1893.   backPred_org, 16 );
  1894. pAverageBlockFunction( pic->y.ptr + col + firstCol + (row + firstRow) * hdim,
  1895.   lastCol - firstCol + 1,
  1896.   lastRow - firstRow + 1, hdim,
  1897.   yBack + firstCol + firstRow * 16, 16 );
  1898. }
  1899. }
  1900. #endif
  1901.     
  1904.         // Determine motion vector for chroma block
  1905.         cX = chromaMVComp( mb->blkMvBx[0] );
  1906.         cY = chromaMVComp( mb->blkMvBy[0] );
  1907.     }
  1908.     // Process chroma
  1909.     col = 8 * mb->x;
  1910.     row = 8 * mb->y;
  1911.     hdim = pic->cb.hoffset;
  1912.     // Only use pixels in current MB for backwards prediction
  1913.     firstCol = max( 0,     (-cX + 1) >> 1 );
  1914.     lastCol  = min( 7, 7 - ((cX + 1) >> 1));
  1915.     firstRow = max( 0,     (-cY + 1) >> 1 );
  1916.     lastRow  = min( 7, 7 - ((cY + 1) >> 1));
  1918. //#define MMX_AVERAGE_TEST02
  1919. #ifdef MMX_AVERAGE_TEST02
  1920. {
  1921. int crow, ccol;
  1922. PIXEL *forPred = pic->cb.ptr + col + firstCol + (row + firstRow) * hdim;
  1923. int hSize = lastCol - firstCol + 1;
  1924. int vSize = lastRow - firstRow + 1;
  1925. int forOffset = hdim;
  1926. PIXEL *backPred = cbBack + firstCol + firstRow * 8;
  1927. int backOffset = 8;
  1928. PIXEL forPred_org[16*352];
  1929. PIXEL backPred_org[16*8];
  1930. int countForOffset = 0; 
  1931. int countBackOffset = 0; 
  1933.     for (crow = 0; crow < vSize; ++crow) {
  1934.         for (ccol = 0; ccol < hSize; ++ccol) {//from smaller multiple of 4
  1935.             forPred_org[ccol + countForOffset] = forPred[ccol + countForOffset];
  1936. backPred_org[ccol + countBackOffset] = backPred[ccol + countBackOffset];
  1937.         }
  1938.         countForOffset  += forOffset;
  1939.         countBackOffset += backOffset;
  1940.     }
  1942.     averageBlock( forPred_org,
  1943.                   lastCol - firstCol + 1,
  1944.                   lastRow - firstRow + 1, hdim,
  1945.                   backPred_org, 8 );
  1946. #endif
  1948.     pAverageBlockFunction( pic->cb.ptr + col + firstCol + (row + firstRow) * hdim,
  1949.                   lastCol - firstCol + 1,
  1950.                   lastRow - firstRow + 1, hdim,
  1951.                   cbBack + firstCol + firstRow * 8, 8 );
  1953. #ifdef MMX_AVERAGE_TEST02
  1954.     countForOffset  =0;
  1955.     countBackOffset = 0;
  1956.     for (crow = 0; crow < vSize; ++crow) {
  1957.         for (ccol = 0; ccol < hSize; ++ccol) {//from smaller multiple of 4
  1958.             if(((hSize==8) || (hSize==16)) && (forPred_org[ccol + countForOffset] != forPred[ccol + countForOffset])) {
  1959. averageBlock( forPred_org,
  1960.   lastCol - firstCol + 1,
  1961.   lastRow - firstRow + 1, hdim,
  1962.   backPred_org, 8 );
  1963. pAverageBlockFunction( pic->cb.ptr + col + firstCol + (row + firstRow) * hdim,
  1964.   lastCol - firstCol + 1,
  1965.   lastRow - firstRow + 1, hdim,
  1966.   cbBack + firstCol + firstRow * 8, 8 );
  1967. }
  1968.         }
  1969.         countForOffset  += forOffset;
  1970.         countBackOffset += backOffset;
  1971.     }
  1973. }
  1974. #endif
  1975.     
  1977. pAverageBlockFunction( pic->cr.ptr + col + firstCol + (row + firstRow) * hdim,
  1978.                   lastCol - firstCol + 1,
  1979.                   lastRow - firstRow + 1, hdim,
  1980.                   crBack + firstCol + firstRow * 8, 8 );
  1981. }
  1984. // copyBlock - copy 2-D array of 32-bit integers
  1985. static void copyBlock( S32 source[], int hSize, int vSize, int sourceOffset,
  1986.                        S32 dest[], int destOffset )
  1987. {
  1988.     int row, col;
  1990.     for (row = 0; row < vSize; ++row) {
  1991.         for (col = 0; col < hSize; ++col) {
  1992.             dest[col] = source[col];
  1993.         }
  1994.         source += sourceOffset;
  1995.         dest   += destOffset;
  1996.     }
  1997. }
  2000. // averageBlock - compute average of two hSize*vSize pixel arrays
  2001. void averageBlock( PIXEL forPred[], int hSize, int vSize, int forOffset,
  2002.                           PIXEL backPred[], int backOffset )
  2003. {
  2004.     int row, col;
  2005. #ifdef VVPROFILER
  2006. S32 nVvProfNb = 3;
  2007. if(!pVvProf[nVvProfNb]) pVvProf[nVvProfNb] = newCVvDebugTimer();//memory leak on destruction
  2008. pVvProfCount[nVvProfNb]++;
  2009. StartTime(pVvProf[nVvProfNb]);
  2010. #endif
  2012.     for (row = 0; row < vSize; ++row) {
  2013.         for (col = 0; col < hSize; ++col) {
  2014.             forPred[col] = (forPred[col] + backPred[col]) >> 1;
  2015.         }
  2016.         forPred  += forOffset;
  2017.         backPred += backOffset;
  2018.     }
  2020. #ifdef VVPROFILER
  2021. StopAndAccuTime(pVvProf[nVvProfNb]);
  2022. #endif
  2025. }