Cinelerra: hvirtual/quicktime/encore50/mot

00001 
00002 /**************************************************************************
00003  *                                                                        *
00004  * This code is developed by Adam Li.  This software is an                *
00005  * implementation of a part of one or more MPEG-4 Video tools as          *
00006  * specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
00007  * software module in hardware or software products are advised that its  *
00008  * use may infringe existing patents or copyrights, and any such use      *
00009  * would be at such party's own risk.  The original developer of this     *
00010  * software module and his/her company, and subsequent editors and their  *
00011  * companies (including Project Mayo), will have no liability for use of  *
00012  * this software or modifications or derivatives thereof.                 *
00013  *                                                                        *
00014  * Project Mayo gives users of the Codec a license to this software       *
00015  * module or modifications thereof for use in hardware or software        *
00016  * products claiming conformance to the MPEG-4 Video Standard as          *
00017  * described in the Open DivX license.                                    *
00018  *                                                                        *
00019  * The complete Open DivX license can be found at                         *
00020  * http://www.projectmayo.com/opendivx/license.php .                      *
00021  *                                                                        *
00022  **************************************************************************/
00023 
00024 /**************************************************************************
00025  *
00026  *  mot_util.c
00027  *
00028  *  Copyright (C) 2001  Project Mayo
00029  *
00030  *  Adam Li
00031  *
00032  *  DivX Advance Research Center <darc@projectmayo.com>
00033  *
00034  **************************************************************************/
00035 
00036 /* This file contains some utility functions to for motion estimation and */
00037 /* compensation.                                                          */
00038 /* Some codes of this project come from MoMuSys MPEG-4 implementation.    */
00039 /* Please see seperate acknowledgement file for a list of contributors.   */
00040 
00041 #include "mom_structs.h"
00042 #include "vm_common_defs.h"
00043 
00044 #include "mot_util.h"
00045 
00046 /* ------------------------------------------------------------------------- */
00047 
00048 /* Macro to compute the MB absolute error difference of the inside the shape */
00049 
00050 //static Int P_diff;
00051 #define DIFF1(v1,v2,idx) (P_diff = (v1[idx]-v2[idx]), ABS(P_diff))
00052 
00053 /***********************************************************CommentBegin******
00054  *
00055  * -- InterpolateImage -- Interpolates a complete  (SInt)image
00056  *
00057  * Purpose :
00058  *      Interpolates a complete  (SInt) image for easier half pel prediction
00059  *
00060  ***********************************************************CommentEnd********/
00061 
00062 Void
00063 InterpolateImage(
00064 Image   *input_image,                                                     /* <-- image to interpolate (SInt) */
00065 Image   *output_image,                                                    /* --> interpolated image (SInt)  */
00066 Int     rounding_control
00067 )
00068 {
00069         SInt   *ii, *oo;
00070         UInt    i, j;
00071         UInt   width, height;
00072 
00073         width = input_image->x;
00074         height = input_image->y;
00075         ii = (SInt*)GetImageData(output_image);
00076         oo = (SInt*)GetImageData(input_image);
00077 
00078         /* main image */
00079         for (j = 0; j < height-1; j++)
00080         {
00081                 for (i = 0; i  < width-1; i++)
00082                 {
00083                         *(ii + (i<<1)) = *(oo + i);
00084                         *(ii + (i<<1)+1) = (*(oo + i) + *(oo + i + 1) + 1- rounding_control)>>1;
00085                         *(ii + (i<<1)+(width<<1)) = (*(oo + i) + *(oo + i + width) + 1-
00086                                 rounding_control)>>1;
00087                         *(ii + (i<<1)+1+(width<<1)) = (*(oo+i) + *(oo+i+1) +
00088                                 *(oo+i+width) + *(oo+i+1+width) + 2-
00089                                 rounding_control)>>2;
00090                 }
00091                 /* last pels on each line */
00092                 *(ii+ (width<<1) - 2) = *(oo + width - 1);
00093                 *(ii+ (width<<1) - 1) = *(oo + width - 1);
00094                 *(ii+ (width<<1)+ (width<<1)-2) = (*(oo+width-1)+*(oo+width+width-1)+1-
00095                         rounding_control)>>1;
00096                 *(ii+ (width<<1)+ (width<<1)-1) = (*(oo+width-1)+*(oo+width+width-1)+1-
00097                         rounding_control)>>1;
00098                 ii += (width<<2);
00099                 oo += width;
00100         }
00101 
00102         /* last lines */
00103         for (i = 0; i < width-1; i++)
00104         {
00105                 *(ii+ (i<<1)) = *(oo + i);
00106                 *(ii+ (i<<1)+1) = (*(oo + i) + *(oo + i + 1) + 1- rounding_control)>>1;
00107                 *(ii+ (width<<1)+ (i<<1)) = *(oo + i);
00108                 *(ii+ (width<<1)+ (i<<1)+1) = (*(oo + i) + *(oo + i + 1) + 1-
00109                         rounding_control)>>1;
00110         }
00111 
00112         /* bottom right corner pels */
00113         *(ii + (width<<1) - 2) = *(oo + width -1);
00114         *(ii + (width<<1) - 1) = *(oo + width -1);
00115         *(ii + (width<<2) - 2) = *(oo + width -1);
00116         *(ii + (width<<2) - 1) = *(oo + width -1);
00117 
00118         return;
00119 }
00120 
00121 
00122 /***********************************************************CommentBegin******
00123  *
00124  * -- GetMotionImages --
00125  *
00126  * Purpose :
00127  *      Translate the MVs data from the resulting separated four
00128  *      (Float) Images (16x16/8x8, X,Y) of the motion estimation process
00129  *      into two Images, which contain the 16x16 and 8x8 MVs
00130  *      values acording to the modes (MBM_INTRA, MBM_INTER16,
00131  *      MBM_INTER8). It also
00132  *      makes a copy of imode16 (SInt-Image of modes).
00133  *
00134  * Return values :
00135  *      1 on success, -1 on error
00136  *
00137  ***********************************************************CommentEnd********/
00138 
00139 Int
00140 GetMotionImages(
00141 Image   *imv16_w,                                                                 /* <-- 16x16 horiz. MV Float-Image (MxN) (cuad.)   */
00142 Image   *imv16_h,                                                                 /* <-- 16x16 verti. MV Float-Image   (MxN) (cuad.) */
00143 Image   *imv8_w,                                                                  /* <-- 8x8  horizontal MV Float-Image  (MxN)       */
00144 Image   *imv8_h,                                                                  /* <-- 8x8  vertical MV Float-Image    (MxN)       */
00145 Image   *imode16,                                                                 /* <-- SInt-Image of modes            (M/2xN/2)    */
00146 Image   **mv_x,                                                                   /* --> horizontal MV Float-Image      (MxN)        */
00147 Image   **mv_y,                                                                   /* --> vertical   MV Float-Image      (MxN)        */
00148 Image   **mode                                                                    /* --> SInt-Image of modes           (M/2xN/2)     */
00149 )
00150 {
00151 
00152         Int     i, j;
00153         Int     width, height, base;
00154         Float   val_x, val_y;
00155         Float   *data_x, *data_y,
00156                         *mv16_w, *mv16_h,
00157                         *mv8_w,  *mv8_h;
00158         SInt    *mode16, *data_mode;
00159         SInt    modo;
00160 
00161         width = imode16->x; height = imode16->y;
00162 
00163         (*mode)=AllocImage(width,height,SHORT_TYPE);
00164         (*mv_x)=AllocImage(width*2,height*2,FLOAT_TYPE);
00165         (*mv_y)=AllocImage(width*2,height*2,FLOAT_TYPE);
00166         data_x = (Float*)GetImageData((*mv_x));
00167         data_y = (Float*)GetImageData((*mv_y));
00168         data_mode = (SInt*)GetImageData((*mode));
00169         mode16=(SInt*)GetImageData(imode16);
00170         mv16_w=(Float*)GetImageData(imv16_w);
00171         mv16_h=(Float*)GetImageData(imv16_h);
00172         mv8_w=(Float*)GetImageData(imv8_w);
00173         mv8_h=(Float*)GetImageData(imv8_h);
00174 
00175         for(j=0;j<height;j++)
00176         {
00177                 for(i=0;i< width;i++)
00178                 {
00179                         modo=data_mode[j*width+i]=mode16[j*width+i];
00180                         if ( modo==MBM_INTRA)                             /*INTRA*/
00181                         {
00182                                 base=2*j*2*width+2*i;
00183                                 data_x[base]=0.0;  data_x[base+1]=0.0;
00184                                 data_y[base]=0.0;  data_y[base+1]=0.0;
00185                                 base+=width*2;
00186                                 data_x[base]=0.0;  data_x[base+1]=0.0;
00187                                 data_y[base]=0.0;  data_y[base+1]=0.0;
00188                         }
00189                         else if(modo==MBM_INTER16)                        /*INTER 16*/
00190                         {
00191                                 base=2*j*2*width+2*i;
00192                                 val_x=mv16_w[base];val_y=mv16_h[base];
00193 
00194                                 data_x[base]=val_x; data_x[base+1]=val_x;
00195                                 data_y[base]=val_y; data_y[base+1]=val_y;
00196                                 base+=width*2;
00197                                 data_x[base]=val_x; data_x[base+1]=val_x;
00198                                 data_y[base]=val_y; data_y[base+1]=val_y;
00199                         }
00200                         else if (modo==MBM_INTER8)                        /*INTER4*8*/
00201                         {
00202                                 base=2*j*2*width+2*i;
00203 
00204                                 data_x[base]   = mv8_w[base];
00205                                 data_y[base]   = mv8_h[base];
00206                                 data_x[base+1] = mv8_w[base+1];
00207                                 data_y[base+1] = mv8_h[base+1];
00208                                 base+=width*2;
00209                                 data_x[base]   = mv8_w[base];
00210                                 data_y[base]   = mv8_h[base];
00211                                 data_x[base+1] = mv8_w[base+1];
00212                                 data_y[base+1] = mv8_h[base+1];
00213                         }
00214                 }                                                                                 /* end for*/
00215         }                                                                                         /* end for*/
00216 
00217         return(1);
00218 }
00219 
00220 
00221 /***********************************************************CommentBegin******
00222  *
00223  * -- ChooseMode -- chooses coding mode INTRA/INTER dependig on the SAD values
00224  *
00225  * Purpose :
00226  *      chooses coding mode INTRA/INTER dependig on the SAD values
00227  *
00228  * Return values :
00229  *      1 for INTER, 0 for INTRA
00230  *
00231  ***********************************************************CommentEnd********/
00232 
00233 Int
00234 ChooseMode(
00235 SInt   *curr,                                                                     /* <-- current Y values (not extended)          */
00236 Int    x_pos,                                                                     /* <-- upper-left MB corner hor. coor.          */
00237 Int    y_pos,                                                                     /* <-- upper-left MB corner ver. coor.          */
00238 Int    min_SAD,                                                                   /* <-- min SAD (from integer pel search)        */
00239 UInt   width                                                                      /* <-- current Y picture width                  */
00240 )
00241 {
00242         Int   i, j;
00243         Int   MB_mean = 0, A = 0;
00244         Int   y_off;
00245 
00246         for (j = 0; j < MB_SIZE; j++)
00247         {
00248                 y_off = (y_pos + j) * width;
00249                 for (i = 0; i < MB_SIZE; i++)
00250                 {
00251                         MB_mean += *(curr + x_pos + i + y_off);
00252                 }
00253         }
00254 
00255         MB_mean /= 256;
00256 
00257         for (j = 0; j < MB_SIZE; j++)
00258         {
00259                 y_off = (y_pos + j) * width;
00260                 for (i = 0; i < MB_SIZE; i++)
00261                 {
00262                                 A += abs( *(curr + x_pos + i + y_off) - MB_mean );
00263                 }
00264         }
00265 
00266         if (A < (min_SAD - 2*256))
00267                 return 0;
00268         else
00269                 return 1;
00270 }
00271 
00272 
00273 /***********************************************************CommentBegin******
00274  *
00275  * -- SAD_Macroblock -- obtains the SAD for a Macroblock
00276  *
00277  * Purpose :
00278  *      obtains the SAD for a Macroblock
00279  *
00280  * Return values :
00281  *      sad of the MB
00282  *
00283  ***********************************************************CommentEnd********/
00284 
00285 Int
00286 SAD_Macroblock(
00287 SInt   *ii,                                                                               /* <-- Pointer to the upper-left pel of first MB */
00288 SInt   *act_block,                                                                /* <-- Id, second MB (width=16)                  */
00289 UInt   h_length,                                                                  /* <-- Width of first area                       */
00290 Int    Min_FRAME                                                                  /* <-- Minimum prediction error so far           */
00291 )
00292 {
00293 /*      Int    i;
00294         Int    sad = 0;
00295         SInt   *kk;
00296         register Int P_diff;
00297 
00298         kk = act_block;
00299         i = 16;
00300         while (i--)
00301         {
00302                 sad += (DIFF1(ii,kk,0)+DIFF1(ii,kk,1)
00303                         +DIFF1(ii,kk,2)+DIFF1(ii,kk,3)
00304                         +DIFF1(ii,kk,4)+DIFF1(ii,kk,5)
00305                         +DIFF1(ii,kk,6)+DIFF1(ii,kk,7)
00306                         +DIFF1(ii,kk,8)+DIFF1(ii,kk,9)
00307                         +DIFF1(ii,kk,10)+DIFF1(ii,kk,11)
00308                         +DIFF1(ii,kk,12)+DIFF1(ii,kk,13)
00309                         +DIFF1(ii,kk,14)+DIFF1(ii,kk,15)
00310                         );
00311 
00312                 ii += h_length;
00313                 kk += 16;
00314                 if (sad > Min_FRAME)
00315                         return MV_MAX_ERROR;
00316         }
00317 
00318         return sad;
00319 */
00320         int i, j;
00321         int sad = 0;
00322         SInt *p1 = ii, *p2 = act_block;
00323 
00324         i = 16;
00325         while (i--) {
00326                 j = 16;
00327                 while (j --)
00328                         sad += abs((int)*(p1++) - (int)*(p2++));
00329                 if (sad > Min_FRAME)
00330                         return MV_MAX_ERROR;
00331                 p1 += h_length - 16;
00332         }
00333 
00334         return sad;
00335 }
00336 
00337 
00338 /***********************************************************CommentBegin******
00339  *
00340  * -- SAD_Block -- obtains the SAD for a Block
00341  *
00342  * Purpose :
00343  *      obtains the SAD for a Block
00344  *
00345  * Return values :
00346  *      sad of the Block
00347  *
00348  ***********************************************************CommentEnd********/
00349 
00350 Int
00351 SAD_Block(
00352 SInt   *ii,                                                                               /* <-- First area                      */
00353 SInt   *act_block,                                                                /* <-- Id. second MB (width=16)        */
00354 UInt   h_length,                                                                  /* <-- Width of first area             */
00355 Int    min_sofar                                                                  /* <-- Minimum prediction error so far */
00356 )
00357 {
00358 /*      Int    i;
00359         Int    sad = 0;
00360         SInt   *kk;
00361         register Int P_diff;
00362 
00363         kk = act_block;
00364         i = 8;
00365         while (i--)
00366         {
00367                 sad += (DIFF1(ii,kk,0)+DIFF1(ii,kk,1)
00368                         +DIFF1(ii,kk,2)+DIFF1(ii,kk,3)
00369                         +DIFF1(ii,kk,4)+DIFF1(ii,kk,5)
00370                         +DIFF1(ii,kk,6)+DIFF1(ii,kk,7)
00371                         );
00372 
00373                 ii += h_length;
00374                 kk += 16;
00375                 if (sad > min_sofar)
00376                         return INT_MAX;
00377         }
00378 
00379         return sad;
00380 */
00381         int i, j;
00382         int sad = 0;
00383         SInt *p1 = ii, *p2 = act_block;
00384 
00385         i = 8;
00386         while (i--) {
00387                 j = 8;
00388                 while (j --)
00389                         sad += abs((int)*(p1++) - (int)*(p2++));
00390                 if (sad > min_sofar)
00391                         return INT_MAX;
00392                 p1 += h_length - 8;
00393                 p2 += 16 - 8;
00394         }
00395 
00396         return sad;
00397 }
00398 
00399 
00400 
00401 /***********************************************************CommentBegin******
00402  *
00403  * -- LoadArea -- fills array with a image-data
00404  *
00405  * Purpose :
00406  *      fills array with a image-data
00407  *
00408  * Return values :
00409  *      Pointer to the filled array
00410  *
00411  ***********************************************************CommentEnd********/
00412 
00413 Void
00414 LoadArea(
00415 SInt    *im,                                                                      /* <-- pointer to image         */
00416 Int             x,                                                                                /* <-- horizontal pos           */
00417 Int             y,                                                                                /* <-- vertical  pos            */
00418 Int             x_size,                                                                   /* <-- width of array           */
00419 Int             y_size,                                                                   /* <-- height of array          */
00420 Int             lx,                                                                               /* <-- width of the image data  */
00421 SInt    *block                                                                    /* <-> pointer to the array     */
00422 )
00423 {
00424         SInt   *in;
00425         SInt   *out;
00426         Int    i = x_size;
00427         Int    j = y_size;
00428 
00429         in = im + (y*lx) + x;
00430         out = block;
00431 
00432         while (j--)
00433         {
00434                 while (i--)
00435                         *out++ = *in++;
00436                 i = x_size;
00437                 in += lx - x_size;
00438         }
00439 
00440         return;
00441 }
00442 
00443 
00444 /***********************************************************CommentBegin******
00445  *
00446  * -- SetArea -- fills a image-data with an array
00447  *
00448  * Purpose :
00449  *      fills a image-data with an array
00450  *
00451  ***********************************************************CommentEnd********/
00452 
00453 Void
00454 SetArea(
00455 SInt   *block,                                                                    /* <-- pointer to array         */
00456 Int    x,                                                                                 /* <-- horizontal pos in image  */
00457 Int    y,                                                                                 /* <-- vertical  pos in image   */
00458 Int    x_size,                                                                    /* <-- width of array           */
00459 Int    y_size,                                                                    /* <-- height of array          */
00460 Int    lx,                                                                                /* <-- width of the image data  */
00461 SInt   *im                                                                                /* --> pointer to image         */
00462 )
00463 {
00464         SInt   *in;
00465         SInt   *out;
00466         Int    i = x_size;
00467         Int    j = y_size;
00468 
00469         in  = block;
00470         out = im + (y*lx) + x;
00471 
00472         while (j--)
00473         {
00474                 while (i--)
00475                         *out++ = *in++;
00476                 i = x_size;
00477                 out += lx - x_size;
00478         }
00479 }
00480 
00481
hvirtual/quicktime/encore50/mot_util.c
