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

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

Symbian

开发平台：

Visual C++

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