1 /*

     2 * Copyright (c) 2010 Ixonos Plc.

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - Initial contribution

    11 *

    12 * Contributors:

    13 * Ixonos Plc

    14 *

    15 * Description: 

    16 * Block copying functions.

    17 *

    18 */

    19 

    20 

    21 

    22 

    23 #include "h263dconfig.h"

    24 

    25 

    26 /*

    27  *

    28  * blcMemSetIncBuf

    29  *

    30  * Parameters:

    31  *    void HUGE *buf    destination buffer

    32  *    int ch            input value

    33  *    size_t count      the number of values to put into the buffer

    34  *

    35  * Function:

    36  *    This macro sets count bytes of buf into the low-order byte of ch

    37  *    and increases buf by count.

    38  *

    39  * Changes:

    40  *    buf

    41  *

    42  * Returns:

    43  *    Nothing.

    44  *

    45  * Error codes:

    46  *    None.

    47  *

    48  */

    49 

    50 #define blcMemSetIncBuf(buf, ch, count) \

    51    MEMSET(buf, ch, count); \

    52    buf += count

    53 

    54 

    55 /*

    56  *

    57  * blcCopyRowNBC           copy a row without border checking

    58  *

    59  * Parameters:

    60  *    u_char HUGE *srcMem  source row

    61  *    u_char HUGE *dstMem  destination row

    62  *

    63  *    int xlt0             ignored

    64  *    int xNormal          See blcCopyBlockBC.

    65  *    int xgtmax           ignored

    66  *

    67  * Function:

    68  *    This macro copies a row of pixels and assumes that

    69  *       - all pixels are within the image area

    70  *       - the pixels are in integer positions

    71  *

    72  *    dstMem is increased by xNormal

    73  *    srcMem is increased by xNormal - 1

    74  *

    75  * Changes:

    76  *    srcMem

    77  *    dstMem

    78  *

    79  * Returns:

    80  *    Nothing.

    81  *

    82  * Error codes:

    83  *    None.

    84  *

    85  */

    86 

    87 #define blcCopyRowNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, roundIncNotUsed) \

    88 { \

    89    MEMCPY(dstMem, srcMem, xNormal); \

    90    dstMem += xNormal; \

    91    srcMem += xNormal - 1; \

    92 }

    93 

    94 

    95 /*

    96  *

    97  * blcCopyRowBC            copy a row with border checking

    98  *

    99  * Parameters:

   100  *    u_char HUGE *srcMem  source row

   101  *    u_char HUGE *dstMem  destination row

   102  *

   103  *    int xlt0             See blcCopyBlockBC.

   104  *    int xNormal          See blcCopyBlockBC.

   105  *    int xgtmax           See blcCopyBlockBC.

   106  *

   107  * Function:

   108  *    This macro copies a row of pixels and assumes that

   109  *       - xlt0 pixels are in the left side of the image area and

   110  *       - xgtmax pixels are in the right side of the image area and

   111  *       - the pixels are in integer positions

   112  *

   113  *    dstMem is increased by xlt0 + xNormal + xgtmax

   114  *    srcMem is increased by xNormal - 1 if xNormal > 0

   115  *

   116  * Changes:

   117  *    srcMem

   118  *    dstMem

   119  *

   120  * Returns:

   121  *    Nothing.

   122  *

   123  * Error codes:

   124  *    None.

   125  *

   126  */

   127 

   128 #define blcCopyRowBC(srcMem, dstMem, xlt0, xNormal, xgtmax, roundIncNotUsed) \

   129 { \

   130    if (xlt0) MEMSET(dstMem, *srcMem, xlt0); \

   131    dstMem += xlt0; \

   132    if (xNormal) blcCopyRowNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, roundIncNotUsed); \

   133    if (xgtmax) MEMSET(dstMem, *srcMem, xgtmax); \

   134    dstMem += xgtmax; \

   135 }

   136 

   137 

   138 /*

   139  *

   140  * blcCopyRowSubXNBC

   141  *

   142  * Parameters:

   143  *    u_char HUGE *srcMem  source row

   144  *    u_char HUGE *dstMem  destination row

   145  *

   146  *    int xlt0             ignored

   147  *    int xNormal          See blcCopyBlockBC.

   148  *    int xgtmax           ignored

   149  *

   150  *    roundInc             See blcCopyBlockSub*.

   151  *

   152  * Function:

   153  *    This macro copies a row of pixels and assumes that

   154  *       - all pixels are within the image area

   155  *       - the pixels are in integer pixel position in vertical direction

   156  *       - the pixels are in half pixel position in horizontal direction

   157  *

   158  *    dstMem is increased by xNormal

   159  *    srcMem is increased by xNormal

   160  *

   161  * Changes:

   162  *    srcMem

   163  *    dstMem

   164  *    loopVar

   165  *

   166  * Returns:

   167  *    Nothing.

   168  *

   169  * Error codes:

   170  *    None.

   171  *

   172  */

   173 

   174 #define blcCopyRowSubXNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, roundInc) \

   175 for (loopVar = xNormal; loopVar; loopVar--, srcMem++) \

   176    *dstMem++ = (u_char) ((*srcMem + *(srcMem + 1) + roundInc) >> 1)

   177 

   178 

   179 /*

   180  *

   181  * blcCopyRowSubXBC

   182  *

   183  * Parameters:

   184  *    u_char HUGE *srcMem  source row

   185  *    u_char HUGE *dstMem  destination row

   186  *

   187  *    int xlt0             See blcCopyBlockBC.

   188  *    int xNormal          See blcCopyBlockBC.

   189  *    int xgtmax           See blcCopyBlockBC.

   190  *

   191  *    roundInc             See blcCopyBlockSub*.

   192  *

   193  * Function:

   194  *    This macro copies a row of pixels and assumes that

   195  *       - xlt0 pixels are in the left side of the image area and

   196  *       - xgtmax pixels are in the right side of the image area and

   197  *       - the pixels are in integer pixel position in vertical direction

   198  *       - the pixels are in half pixel position in horizontal direction

   199  *

   200  *    dstMem is increased by xlt0 + xNormal + xgtmax

   201  *    srcMem is increased by xlt0 + xNormal + xgtmax

   202  *

   203  * Changes:

   204  *    srcMem

   205  *    dstMem

   206  *    loopVar

   207  *

   208  * Returns:

   209  *    Nothing.

   210  *

   211  * Error codes:

   212  *    None.

   213  *

   214  */

   215 

   216 #define blcCopyRowSubXBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, roundInc) \

   217 { \

   218    if (xlt0) \

   219       blcMemSetIncBuf(dstMem, *srcMem, xlt0); \

   220    blcCopyRowSubXNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, roundInc); \

   221    if (xgtmax) blcMemSetIncBuf(dstMem, *srcMem, xgtmax); \

   222 }

   223 

   224 

   225 /*

   226  *

   227  * blcCopyRowSubYNBC

   228  *

   229  * Parameters:

   230  *    u_char HUGE *srcMem  source row

   231  *    u_char HUGE *dstMem  destination row

   232  *

   233  *    int xlt0             ignored

   234  *    int xNormal          See blcCopyBlockBC.

   235  *    int xgtmax           ignored

   236  *

   237  *    roundInc             See blcCopyBlockSub*.

   238  *

   239  * Function:

   240  *    This macro copies a row of pixels and assumes that

   241  *       - all pixels are within the image area

   242  *       - the pixels are in half pixel position in vertical direction

   243  *       - the pixels are in integer pixel position in horizontal direction

   244  *

   245  *    dstMem is increased by xNormal

   246  *    srcMem is increased by xNormal - 1 if xNormal > 0

   247  *

   248  * Changes:

   249  *    srcMem

   250  *    dstMem

   251  *    loopVar

   252  *

   253  * Returns:

   254  *    Nothing.

   255  *

   256  * Error codes:

   257  *    None.

   258  *

   259  */

   260 

   261 #define blcCopyRowSubYNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

   262    srcXSize, roundInc) \

   263 { \

   264    for (loopVar = xNormal; loopVar; loopVar--, srcMem++) \

   265       *dstMem++ = (u_char) ((*srcMem + *(srcMem + srcXSize) + roundInc) >> 1); \

   266    if (xNormal) srcMem--; \

   267 }

   268 

   269 

   270 /*

   271  *

   272  * blcCopyRowSubYBC

   273  *

   274  * Parameters:

   275  *    u_char HUGE *srcMem  source row

   276  *    u_char HUGE *dstMem  destination row

   277  *

   278  *    int xlt0             See blcCopyBlockBC.

   279  *    int xNormal          See blcCopyBlockBC.

   280  *    int xgtmax           See blcCopyBlockBC.

   281  *

   282  *    roundInc             See blcCopyBlockSub*.

   283  *

   284  * Function:

   285  *    This macro copies a row of pixels and assumes that

   286  *       - xlt0 pixels are in the left side of the image area and

   287  *       - xgtmax pixels are in the right side of the image area and

   288  *       - the pixels are in half pixel position in vertical direction

   289  *       - the pixels are in integer pixel position in horizontal direction

   290  *

   291  *    dstMem is increased by xlt0 + xNormal + xgtmax

   292  *    srcMem is increased by xNormal - 1 if xNormal > 0

   293  *

   294  * Changes:

   295  *    srcMem

   296  *    dstMem

   297  *    loopVar

   298  *

   299  * Returns:

   300  *    Nothing.

   301  *

   302  * Error codes:

   303  *    None.

   304  *

   305  */

   306 

   307 #define blcCopyRowSubYBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

   308    srcXSize, roundInc) \

   309 { \

   310    if (xlt0) { \

   311       *dstMem++ = (u_char) ((*srcMem + *(srcMem + srcXSize) + roundInc) >> 1); \

   312       if (xlt0 > 1) blcMemSetIncBuf(dstMem, *(dstMem - 1), xlt0 - 1); \

   313    } \

   314    blcCopyRowSubYNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

   315       srcXSize, roundInc); \

   316    if (xgtmax) { \

   317       if (xNormal) { \

   318          blcMemSetIncBuf(dstMem, *(dstMem - 1), xgtmax); \

   319       } \

   320       else { \

   321          *dstMem++ = (u_char) ((*srcMem + *(srcMem + srcXSize) + roundInc) >> 1); \

   322          if (xgtmax > 1) blcMemSetIncBuf(dstMem, *(dstMem - 1), xgtmax - 1); \

   323       } \

   324    } \

   325 }

   326 

   327 

   328 /*

   329  *

   330  * blcCopyRowSubXYNBC

   331  *

   332  * Parameters:

   333  *    u_char HUGE *srcMem  source row

   334  *    u_char HUGE *dstMem  destination row

   335  *

   336  *    int xlt0             ignored

   337  *    int xNormal          See blcCopyBlockBC.

   338  *    int xgtmax           ignored

   339  *

   340  *    roundInc             See blcCopyBlockSub*.

   341  *

   342  * Function:

   343  *    This macro copies a row of pixels and assumes that

   344  *       - all pixels are within the image area

   345  *       - the pixels are in half pixel position in vertical direction

   346  *       - the pixels are in half pixel position in horizontal direction

   347  *

   348  *    dstMem is increased by xNormal

   349  *    srcMem is increased by xNormal

   350  *

   351  * Changes:

   352  *    srcMem

   353  *    dstMem

   354  *    loopVar

   355  *

   356  * Returns:

   357  *    Nothing.

   358  *

   359  * Error codes:

   360  *    None.

   361  *

   362  */

   363 

   364 #define blcCopyRowSubXYNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

   365    srcXSize, roundInc) \

   366 for (loopVar = xNormal; loopVar; loopVar--, srcMem++) \

   367    *dstMem++ = (u_char) ((*srcMem + *(srcMem + 1) + *(srcMem + srcXSize) + \

   368       *(srcMem + srcXSize + 1) + roundInc) >> 2)

   369 

   370 

   371 /*

   372  *

   373  * blcCopyOutPicXPixelSubXYRoundInc1

   374  * blcCopyOutPicXPixelSubXYRoundInc2

   375  *

   376  * Parameters:

   377  *    u_char HUGE *srcMem  source row

   378  *    u_char HUGE *dstMem  destination row

   379  *    srcXSize             number of pixels (bytes) in source row

   380  *

   381  * Function:

   382  *    These macros copy one pixel which lies horizontally outside the picture

   383  *    area assuming that

   384  *       - the pixels are in half pixel position in vertical direction

   385  *       - the pixels are in half pixel position in horizontal direction

   386  *

   387  *    If roundInc is 2, the macro takes advantage of the fact that

   388  *       (A + B + C + D + roundInc) / 4 = (A + A + C + C + 2) / 4 = 

   389  *       (A + C + 1) / 2

   390  *    when using the notation of section 6.1.2 of the H.263 recommendation.

   391  *

   392  *    dstMem is increased by 1

   393  *

   394  * Changes:

   395  *    dstMem

   396  *

   397  * Returns:

   398  *    Nothing.

   399  *

   400  * Error codes:

   401  *    None.

   402  *

   403  */

   404 

   405 #define blcCopyOutPicXPixelSubXYRoundInc2(srcMem, dstMem, srcXSize) \

   406    *dstMem++ = (u_char) ((*srcMem + *(srcMem + srcXSize) + 1) >> 1)

   407 

   408 #define blcCopyOutPicXPixelSubXYRoundInc1(srcMem, dstMem, srcXSize) \

   409    *dstMem++ = (u_char) ((((*srcMem) << 1) + ((*(srcMem + srcXSize)) << 1) + 1) >> 2)

   410 

   411 

   412 /*

   413  *

   414  * blcCopyRowSubXYBC

   415  *

   416  * Parameters:

   417  *    u_char HUGE *srcMem  source row

   418  *    u_char HUGE *dstMem  destination row

   419  *

   420  *    int xlt0             ignored

   421  *    int xNormal          See blcCopyBlockBC.

   422  *    int xgtmax           ignored

   423  *

   424  *    roundInc             See blcCopyBlockSub*.

   425  *

   426  * Function:

   427  *    This macro copies a row of pixels and assumes that

   428  *       - xlt0 pixels are in the left side of the image area and

   429  *       - xgtmax pixels are in the right side of the image area and

   430  *       - the pixels are in half pixel position in vertical direction

   431  *       - the pixels are in half pixel position in horizontal direction

   432  *

   433  *    dstMem is increased by xNormal

   434  *    srcMem is increased by xNormal

   435  *

   436  * Changes:

   437  *    srcMem

   438  *    dstMem

   439  *    loopVar

   440  *

   441  * Returns:

   442  *    Nothing.

   443  *

   444  * Error codes:

   445  *    None.

   446  *

   447  */

   448 

   449 #define blcCopyRowSubXYBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

   450    srcXSize, roundInc) \

   451 { \

   452    if (xlt0) { \

   453       blcCopyOutPicXPixelSubXYRoundInc ## roundInc(srcMem, dstMem, srcXSize); \

   454       if (xlt0 > 1) blcMemSetIncBuf(dstMem, *(dstMem - 1), xlt0 - 1); \

   455    } \

   456    blcCopyRowSubXYNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

   457       srcXSize, roundInc); \

   458    if (xgtmax) { \

   459       blcCopyOutPicXPixelSubXYRoundInc ## roundInc(srcMem, dstMem, srcXSize); \

   460       if (xgtmax > 1) blcMemSetIncBuf(dstMem, *(dstMem - 1), xgtmax - 1); \

   461    } \

   462 }

   463 

   464 

   465 /*

   466  *

   467  * blcCopyOutPicRowSubXYRoundInc1

   468  * blcCopyOutPicRowSubXYRoundInc2

   469  *

   470  * Parameters:

   471  *    u_char HUGE *srcMem  source row

   472  *    u_char HUGE *dstMem  destination row

   473  *    srcXSize             number of pixels (bytes) in source row

   474  *

   475  * Function:

   476  *    These macros copy one row which lies vertically outside the picture

   477  *    area assuming that

   478  *       - the pixels are in half pixel position in vertical direction

   479  *       - the pixels are in half pixel position in horizontal direction

   480  *

   481  *    If roundInc is 2, the macro takes advantage of the fact that

   482  *       (A + B + C + D + roundInc) / 4 = (A + A + B + B + 2) / 4 = 

   483  *       (A + B + 1) / 2

   484  *    when using the notation of section 6.1.2 of the H.263 recommendation.

   485  *

   486  * Changes:

   487  *    srcMem

   488  *    dstMem

   489  *    loopVar

   490  *

   491  * Returns:

   492  *    Nothing.

   493  *

   494  * Error codes:

   495  *    None.

   496  *

   497  */

   498 

   499 #define blcCopyOutPicRowSubXYRoundInc2(borderCheck, srcMem, dstMem, \

   500    xlt0, xNormal, xgtmax, loopVar, srcXSize) \

   501    blcCopyRowSubX ## borderCheck(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, 1)

   502 

   503 #define blcCopyOutPicRowSubXYRoundInc1NBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, srcXSize) \

   504    for (loopVar = xNormal; loopVar; loopVar--, srcMem++) \

   505       *dstMem++ = (u_char) ((((*srcMem) << 1) + ((*(srcMem + 1)) << 1) + 1) >> 2)

   506 

   507 #define blcCopyOutPicRowSubXYRoundInc1BC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, srcXSize) \

   508 { \

   509    if (xlt0) {\

   510       blcMemSetIncBuf(dstMem, *(srcMem), xlt0); \

   511    } \

   512    blcCopyOutPicRowSubXYRoundInc1NBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, srcXSize); \

   513    if (xgtmax) { \

   514       blcMemSetIncBuf(dstMem, *(srcMem), xgtmax); \

   515    } \

   516 }

   517 

   518 #define blcCopyOutPicRowSubXYRoundInc1(borderCheck, srcMem, dstMem, \

   519    xlt0, xNormal, xgtmax, loopVar, srcXSize) \

   520    blcCopyOutPicRowSubXYRoundInc1 ## borderCheck(srcMem, dstMem, \

   521       xlt0, xNormal, xgtmax, loopVar, srcXSize)

   522 

   523 

   524 /*

   525  *

   526  * Integer pixel position (x and y picture boundary checks respectively):

   527  *    blcCopyBlockNoSubNBCBC

   528  *    blcCopyBlockNoSubBCNBC

   529  *    blcCopyBlockNoSubNBCNBC

   530  *    blcCopyBlockNoSubBCBC

   531  *

   532  * Half pixel position in horizontal direction:

   533  *    blcCopyBlockSubXNBC

   534  *    blcCopyBlockSubXBC

   535  *

   536  * Half pixel position in vertical direction:

   537  *    blcCopyBlockSubYNBC

   538  *    blcCopyBlockSubYBC

   539  *

   540  * Half pixel position in horizontal and vertical direction:

   541  *    blcCopyBlockSubXYNBC

   542  *    blcCopyBlockSubXYBC

   543  *

   544  * NBC means that all pixels are within the vertical range of the image area.

   545  * BC means that ylt0 pixels are above the image area and ygtmax pixels are

   546  * below the image area.

   547  *

   548  * Parameters:

   549  *    Note that some parameters are not included into every macro.

   550  *

   551  *    routineName          corresponding row copying macro name

   552  *

   553  *    u_char HUGE *srcMem  source block

   554  *    u_char HUGE *dstMem  destination block

   555  *

   556  *    int xlt0             See blcCopyBlockBC.

   557  *    int xNormal          See blcCopyBlockBC.

   558  *    int xgtmax           See blcCopyBlockBC.

   559  *

   560  *    int ylt0             See blcCopyBlockBC.

   561  *    int yNormal          See blcCopyBlockBC.

   562  *    int ygtmax           See blcCopyBlockBC.

   563  *

   564  *    loopVar1, loopVar2   loop variables

   565  *

   566  *    srcXSize             the horizontal size of the source image

   567  *    dstXSize             the horizontal size of the destination image

   568  *    blkXSize             the horizontal size of the block to be copied,

   569  *                         should be equal to xlt0 + xNormal + xgtmax

   570  *

   571  *    srcInc               increment to srcMem (after row copying)

   572  *                         to get the next row

   573  *    dstInc               increment to dstMem (after row copying)

   574  *                         to get the next row

   575  *

   576  *    roundInc             for subpixel functions only:

   577  *                         for interpolation in X or Y  directions:

   578  *                            roundInc = 1 - RCONTROL, i.e.

   579  *                            1 if RCONTROL == 0,

   580  *                            0 if RCONTROL == 1,

   581  *                         for interpolation in X and Y directions:

   582  *                            roundInc = 2 - RCONTROL, i.e.

   583  *                            2 if RCONTROL == 0,

   584  *                            1 if RCONTROL == 1

   585  *

   586  * Function:

   587  *    These macros copy a block of pixels.

   588  *

   589  * Changes:

   590  *    srcMem

   591  *    dstMem

   592  *    loopVar1

   593  *    loopVar2

   594  *

   595  * Returns:

   596  *    Nothing.

   597  *

   598  * Error codes:

   599  *    None.

   600  *

   601  */

   602 

   603 

   604 #define blcCopyBlockNoSubNBC(routineName, srcMem, dstMem, \

   605    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   606    loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc) \

   607 for (loopVar1 = yNormal; loopVar1; loopVar1--) { \

   608    routineName(srcMem, dstMem, xlt0, xNormal, xgtmax, 0); \

   609    srcMem += srcInc; \

   610    dstMem += dstInc; \

   611 }

   612 

   613 #define blcCopyBlockNoSubNBCBC(routineName, srcMem, dstMem, \

   614    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   615    loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc) \

   616 blcCopyBlockNoSubNBC(routineName, srcMem, dstMem, xlt0, xNormal, xgtmax, \

   617    ylt0, yNormal, ygtmax, loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, \

   618    srcInc, dstInc)

   619 

   620 #define blcCopyBlockNoSubBCNBC(routineName, srcMem, dstMem, \

   621    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   622    loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc) \

   623 { \

   624    if (ylt0) { \

   625       for (loopVar2 = ylt0; loopVar2; loopVar2--, dstMem += dstXSize) \

   626          MEMCPY(dstMem, srcMem, blkXSize); \

   627    } \

   628 \

   629    blcCopyBlockNoSubNBC(routineName, srcMem, dstMem, \

   630       xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   631       loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc); \

   632 \

   633    if (ygtmax) { \

   634       if (yNormal) srcMem -= srcXSize; \

   635       for (loopVar2 = ygtmax; loopVar2; loopVar2--, dstMem += dstXSize) \

   636          MEMCPY(dstMem, srcMem, blkXSize); \

   637    } \

   638 }

   639 

   640 #define blcCopyBlockNoSubNBCNBC(routineName, srcMem, dstMem, \

   641    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   642    loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc) \

   643 for (loopVar1 = yNormal; loopVar1; loopVar1--) { \

   644    MEMCPY(dstMem, srcMem, xNormal); \

   645    dstMem += dstXSize; \

   646    srcMem += srcXSize; \

   647 }

   648    

   649 #define blcCopyBlockNoSubBCBC(routineName, srcMem, dstMem, \

   650    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   651    loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc) \

   652 { \

   653    if (ylt0) { \

   654       routineName(srcMem, dstMem, xlt0, xNormal, xgtmax, 0); \

   655       dstMem += dstInc; \

   656       for (loopVar2 = ylt0 - 1; loopVar2; loopVar2--, dstMem += dstXSize) \

   657          MEMCPY(dstMem, dstMem - dstXSize, blkXSize); \

   658       if (xNormal) srcMem -= (xNormal - 1); \

   659    } \

   660 \

   661    blcCopyBlockNoSubNBC(routineName, srcMem, dstMem, \

   662       xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   663       loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc); \

   664 \

   665    if (ygtmax) { \

   666       if (yNormal) srcMem -= srcXSize; \

   667       routineName(srcMem, dstMem, xlt0, xNormal, xgtmax, 0); \

   668       dstMem += dstInc; \

   669       for (loopVar2 = ygtmax - 1; loopVar2; loopVar2--, dstMem += dstXSize) \

   670          MEMCPY(dstMem, dstMem - dstXSize, blkXSize); \

   671    } \

   672 }

   673 

   674 #define blcCopyBlockSubXNBC(routineName, srcMem, dstMem, \

   675    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   676    loopVar1, loopVar2, dstXSize, blkXSize, srcInc, dstInc, roundInc) \

   677 for (loopVar1 = yNormal; loopVar1; loopVar1--) { \

   678    routineName(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar2, roundInc); \

   679    srcMem += srcInc; \

   680    dstMem += dstInc; \

   681 }

   682 

   683 #define blcCopyBlockSubXBC(routineName, srcMem, dstMem, \

   684    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   685    loopVar1, loopVar2, dstXSize, blkXSize, srcInc, dstInc, roundInc) \

   686 { \

   687    if (ylt0) { \

   688       routineName(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar2, roundInc); \

   689       dstMem += dstInc; \

   690       for (loopVar2 = ylt0 - 1; loopVar2; loopVar2--, dstMem += dstXSize) \

   691          MEMCPY(dstMem, dstMem - dstXSize, blkXSize); \

   692       srcMem -= xNormal; \

   693    } \

   694 \

   695    blcCopyBlockSubXNBC(routineName, srcMem, dstMem, xlt0, xNormal, xgtmax, \

   696       ylt0, yNormal, ygtmax, loopVar1, loopVar2, dstXSize, blkXSize, \

   697       srcInc, dstInc, roundInc); \

   698 \

   699    if (ygtmax) { \

   700       if (!yNormal) { \

   701          routineName(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar2, roundInc); \

   702          dstMem += dstInc; \

   703       } \

   704       for (loopVar2 = ygtmax - !yNormal; loopVar2; loopVar2--, \

   705          dstMem += dstXSize) \

   706          MEMCPY(dstMem, dstMem - dstXSize, blkXSize); \

   707    } \

   708 }

   709 

   710 #define blcCopyBlockSubYNBC(routineName, yoffRoutine, srcMem, dstMem, \

   711    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   712    loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc, roundInc) \

   713 for (loopVar1 = yNormal; loopVar1; loopVar1--) { \

   714    routineName(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar2, srcXSize, roundInc); \

   715    srcMem += srcInc; \

   716    dstMem += dstInc; \

   717 } \

   718 

   719 #define blcCopyBlockSubYBC(normRoutine, yoffRoutine, srcMem, dstMem, \

   720    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   721    loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc, roundInc) \

   722 { \

   723    if (ylt0) { \

   724       yoffRoutine(srcMem, dstMem, xlt0, xNormal, xgtmax, roundInc); \

   725       dstMem += dstInc; \

   726       for (loopVar2 = ylt0 - 1; loopVar2; loopVar2--, dstMem += dstXSize) \

   727          MEMCPY(dstMem, dstMem - dstXSize, blkXSize); \

   728       if (xNormal) srcMem -= (xNormal - 1); \

   729    } \

   730 \

   731    blcCopyBlockSubYNBC(normRoutine, yoffRoutine, srcMem, dstMem, \

   732       xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   733       loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc, roundInc); \

   734 \

   735    if (ygtmax) { \

   736       yoffRoutine(srcMem, dstMem, xlt0, xNormal, xgtmax, roundInc); \

   737       dstMem += dstInc; \

   738       for (loopVar2 = ygtmax - 1; loopVar2; loopVar2--, dstMem += dstXSize) \

   739          MEMCPY(dstMem, dstMem - dstXSize, blkXSize); \

   740    } \

   741 }

   742 

   743 #define blcCopyBlockSubXYNBC(routineName, notUsed, srcMem, dstMem, \

   744    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   745    loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc, roundInc) \

   746 for (loopVar1 = yNormal; loopVar1; loopVar1--) { \

   747    routineName(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar2, \

   748       srcXSize, roundInc); \

   749    srcMem += srcInc; \

   750    dstMem += dstInc; \

   751 } \

   752 

   753 #define blcCopyBlockSubXYBC(normRoutine, xoffBorderCheck, srcMem, dstMem, \

   754    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   755    loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc, roundInc) \

   756 { \

   757    if (ylt0) { \

   758       blcCopyOutPicRowSubXYRoundInc ## roundInc(xoffBorderCheck, srcMem, dstMem, \

   759          xlt0, xNormal, xgtmax, loopVar2, srcXSize); \

   760       dstMem += dstInc; \

   761       for (loopVar2 = ylt0 - 1; loopVar2; loopVar2--, dstMem += dstXSize) \

   762          MEMCPY(dstMem, dstMem - dstXSize, blkXSize); \

   763       srcMem -= xNormal; \

   764    } \

   765 \

   766    blcCopyBlockSubXYNBC(normRoutine, yoffRoutine, srcMem, dstMem, \

   767       xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   768       loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc, roundInc); \

   769 \

   770    if (ygtmax) { \

   771       blcCopyOutPicRowSubXYRoundInc ## roundInc(xoffBorderCheck, srcMem, dstMem, \

   772          xlt0, xNormal, xgtmax, loopVar2, srcXSize); \

   773       dstMem += dstInc; \

   774       for (loopVar2 = ygtmax - 1; loopVar2; loopVar2--, dstMem += dstXSize) \

   775          MEMCPY(dstMem, dstMem - dstXSize, blkXSize); \

   776    } \

   777 }

   778 

   779 

   780 /*

   781  *

   782  * blcCopyBlockBCVar

   783  *

   784  * Parameters:

   785  *    xoffBorderCheck      NBC if all the pixels of the block are within

   786  *                         the horizontal range of the image area

   787  *                         BC otherwise

   788  *    yoffBorderCheck      NBC if all the pixels of the block are within

   789  *                         the vertical range of the image area

   790  *                         BC otherwise

   791  *

   792  *    u_char HUGE *srcMem  source block

   793  *    u_char HUGE *dstMem  destination block

   794  *

   795  *    int xlt0             See blcCopyBlockBC.

   796  *    int xNormal          See blcCopyBlockBC.

   797  *    int xgtmax           See blcCopyBlockBC.

   798  *    int ylt0             See blcCopyBlockBC.

   799  *    int yNormal          See blcCopyBlockBC.

   800  *    int ygtmax           See blcCopyBlockBC.

   801  *    int subpixelX        See blcCopyBlockBC.

   802  *    int subpixelY        See blcCopyBlockBC.

   803  *

   804  *    loopVar1, loopVar2   loop variables

   805  *

   806  *    srcXSize             the horizontal size of the source image

   807  *    dstXSize             the horizontal size of the destination image

   808  *

   809  *    blkXSize             the horizontal size of the block to be copied,

   810  *                         should be equal to xlt0 + xNormal + xgtmax

   811  *    blkYSize             the vertical size of the block to be copied,

   812  *                         should be equal to ylt0 + yNormal + ygtmax

   813  *

   814  *    dstInc               increment to dstMem (after row copying)

   815  *                         to get the next row

   816  *

   817  *    rcontrol             See blcCopyBlockBC.

   818  *

   819  * Function:

   820  *    This macro copies a block with appropriate image border crossing

   821  *    checkings.

   822  *

   823  * Changes:

   824  *    srcMem

   825  *    dstMem

   826  *    loopVar1

   827  *    loopVar2

   828  *

   829  * Returns:

   830  *    Nothing.

   831  *

   832  * Error codes:

   833  *    None.

   834  *

   835  */

   836 

   837 #define blcCopyBlockBCVar(xoffBorderCheck, yoffBorderCheck, srcMem, dstMem, \

   838    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY, \

   839    loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, \

   840    rcontrol) \

   841 { \

   842    if (subpixelX) { \

   843       if (subpixelY) { \

   844          int srcInc = srcXSize - xNormal; \

   845          if (rcontrol) { \

   846             blcCopyBlockSubXY ## yoffBorderCheck( \

   847                blcCopyRowSubXY ## xoffBorderCheck, \

   848                xoffBorderCheck, srcMem, \

   849                dstMem, xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   850                loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc, 1); \

   851          } \

   852          else { \

   853             blcCopyBlockSubXY ## yoffBorderCheck( \

   854                blcCopyRowSubXY ## xoffBorderCheck, \

   855                xoffBorderCheck, srcMem, \

   856                dstMem, xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   857                loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc, 2); \

   858          } \

   859       } \

   860       else /* !subPixelY */ { \

   861          int srcInc = srcXSize - xNormal; \

   862          if (rcontrol) { \

   863             blcCopyBlockSubX ## yoffBorderCheck( \

   864                blcCopyRowSubX ## xoffBorderCheck, srcMem, dstMem, \

   865                xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   866                loopVar1, loopVar2, dstXSize, blkXSize, srcInc, dstInc, 0) \

   867          } \

   868          else { \

   869             blcCopyBlockSubX ## yoffBorderCheck( \

   870                blcCopyRowSubX ## xoffBorderCheck, srcMem, dstMem, \

   871                xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   872                loopVar1, loopVar2, dstXSize, blkXSize, srcInc, dstInc, 1) \

   873          } \

   874       } \

   875    } \

   876 \

   877    else /* !subpixelX */ { \

   878       if (subpixelY) { \

   879          int srcInc = srcXSize - xNormal + ((xNormal) ? 1 : 0); \

   880          if (rcontrol) { \

   881             blcCopyBlockSubY ## yoffBorderCheck( \

   882                blcCopyRowSubY ## xoffBorderCheck, \

   883                blcCopyRow ## yoffBorderCheck, srcMem, dstMem, \

   884                xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   885                loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc, 0); \

   886          } \

   887          else { \

   888             blcCopyBlockSubY ## yoffBorderCheck( \

   889                blcCopyRowSubY ## xoffBorderCheck, \

   890                blcCopyRow ## yoffBorderCheck, srcMem, dstMem, \

   891                xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   892                loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc, 1); \

   893          } \

   894       } \

   895       else /* !subpixelY */ { \

   896          int srcInc = srcXSize - xNormal + ((xNormal) ? 1 : 0); \

   897          blcCopyBlockNoSub ## yoffBorderCheck ## xoffBorderCheck ( \

   898             blcCopyRow ## xoffBorderCheck, srcMem, dstMem, \

   899             xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, \

   900             loopVar1, loopVar2, srcXSize, dstXSize, blkXSize, srcInc, dstInc); \

   901       } \

   902    } \

   903 }

   904 

   905 

   906 /*

   907  *

   908  * blcCopyBlockBC

   909  * blcCopyBlockNBC

   910  *

   911  * Parameters:

   912  *    u_char HUGE *srcMem  source block

   913  *    u_char HUGE *dstMem  destination block

   914  *

   915  *    The next parameters describe a row of source pixels.

   916  *    int xlt0             the number of the source pixels in the left of

   917  *                         the image area

   918  *    int xNormal          the number of the source pixels within the image

   919  *                         area

   920  *    int xgtmax           the number of the source pixels in the right of

   921  *                         the image area

   922  *

   923  *    The next parameters describe a column of source pixels.

   924  *    int ylt0             the number of the source pixels above the image area

   925  *    int yNormal          the number of the source pixels withing the image

   926  *                         area

   927  *    int ygtmax           the number of the source pixels below the image area

   928  *

   929  *    int subpixelX        1 if source pixels are in half pixel position in

   930  *                         horizontal direction, 0 otherwise

   931  *    int subpixelY        1 if source pixels are in half pixel position in

   932  *                         vertical direction, 0 otherwise

   933  *

   934  *    srcXSize             the horizontal size of the source image

   935  *    dstXSize             the horizontal size of the destination image

   936  *

   937  *    blkXSize             the horizontal size of the block to be copied,

   938  *                         should be equal to xlt0 + xNormal + xgtmax

   939  *    blkYSize             the vertical size of the block to be copied,

   940  *                         should be equal to ylt0 + yNormal + ygtmax

   941  *    rcontrol             0 or 1, RCONTROL as in section 6.1.2. of H.263 

   942  *                         version 2

   943  *

   944  * Function:

   945  *    blcCopyBlockBC macro copies a block according to unrestricted motion

   946  *    vector mode, i.e. it checks if the motion vector points outside the

   947  *    image area, i.e. xlt0, xgtmax, ylt0 or ygtmax != 0.

   948  *    blcCopyBlockNBC macro copies a block assuming that the whole block is

   949  *    inside the image area. blcCopyBlockNBC is used in normal prediction

   950  *    mode (no options are used).

   951  *

   952  * Changes:

   953  *    srcMem

   954  *    dstMem

   955  *

   956  * Returns:

   957  *    Nothing.

   958  *

   959  * Error codes:

   960  *    None.

   961  *

   962  */

   963 

   964 /*#define BLC_COPY_BLOCK_MACROS*/

   965 #ifdef BLC_COPY_BLOCK_MACROS

   966 #define blcCopyBlockBC(srcMem, dstMem, \

   967    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY, \

   968    srcXSize, dstXSize, blkXSize, blkYSize, rcontrol) \

   969 { \

   970    int \

   971       dstInc = dstXSize - blkXSize, \

   972       i, j; \

   973 \

   974    if (xNormal == blkXSize) { \

   975       if (yNormal == blkYSize) { \

   976          blcCopyBlockBCVar(NBC, NBC, srcMem, dstMem, \

   977             xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY, \

   978             j, i, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, rcontrol); \

   979       } \

   980       else { \

   981          blcCopyBlockBCVar(NBC, BC, srcMem, dstMem, \

   982             xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY, \

   983             j, i, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, rcontrol); \

   984       } \

   985    } \

   986    else { \

   987       if (yNormal == blkYSize) { \

   988          blcCopyBlockBCVar(BC, NBC, srcMem, dstMem, \

   989             xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY, \

   990             j, i, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, rcontrol); \

   991       } \

   992       else { \

   993          blcCopyBlockBCVar(BC, BC, srcMem, dstMem, \

   994             xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY, \

   995             j, i, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, rcontrol); \

   996       } \

   997    } \

   998 }

   999 

  1000 #define blcCopyBlockNBC(srcMem, dstMem, \

  1001    xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY, \

  1002    srcXSize, dstXSize, blkXSize, blkYSize, rcontrol) \

  1003 { \

  1004    int \

  1005       dstInc = dstXSize - blkXSize, \

  1006       i, j; \

  1007 \

  1008    blcCopyBlockBCVar(NBC, NBC, srcMem, dstMem, \

  1009       xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY, \

  1010       j, i, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, rcontrol); \

  1011 }

  1012 

  1013 #else

  1014 static void blcCopyBlockBC(u_char HUGE *srcMem, u_char HUGE *dstMem,

  1015    int xlt0, int xNormal, int xgtmax, int ylt0, int yNormal, int ygtmax,

  1016    int subpixelX, int subpixelY,

  1017    int srcXSize, int dstXSize, int blkXSize, int blkYSize, int rcontrol)

  1018 {

  1019    int

  1020       dstInc = dstXSize - blkXSize,

  1021       i, j;

  1022 

  1023    if (xNormal == blkXSize) {

  1024       if (yNormal == blkYSize) {

  1025          blcCopyBlockBCVar(NBC, NBC, srcMem, dstMem,

  1026             xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY,

  1027             j, i, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, rcontrol);

  1028       }

  1029       else {

  1030          blcCopyBlockBCVar(NBC, BC, srcMem, dstMem,

  1031             xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY,

  1032             j, i, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, rcontrol);

  1033       }

  1034    }

  1035    else {

  1036       if (yNormal == blkYSize) {

  1037          blcCopyBlockBCVar(BC, NBC, srcMem, dstMem,

  1038             xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY,

  1039             j, i, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, rcontrol);

  1040       }

  1041       else {

  1042          blcCopyBlockBCVar(BC, BC, srcMem, dstMem,

  1043             xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY,

  1044             j, i, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, rcontrol);

  1045       }

  1046    }

  1047 }

  1048 

  1049 static void blcCopyBlockNBC(u_char HUGE *srcMem, u_char HUGE *dstMem,

  1050    int xlt0, int xNormal, int xgtmax, int ylt0, int yNormal, int ygtmax,

  1051    int subpixelX, int subpixelY,

  1052    int srcXSize, int dstXSize, int blkXSize, int blkYSize, int rcontrol)

  1053 {

  1054    int

  1055       dstInc = dstXSize - blkXSize,

  1056       i, j;

  1057 

  1058    blcCopyBlockBCVar(NBC, NBC, srcMem, dstMem,

  1059       xlt0, xNormal, xgtmax, ylt0, yNormal, ygtmax, subpixelX, subpixelY,

  1060       j, i, srcXSize, dstXSize, blkXSize, blkYSize, dstInc, rcontrol);

  1061 }

  1062 #endif

  1063 

  1064 

  1065 // End of file