Abstract:
A framework for efficient sum of absolute difference (SAD) computations for variable block size, sub-pixel motion estimation is presented. Simultaneous, or parallelized, SAD computations can be performed by storing and re-using previous SAD computational information, which can speed up the performance of a motion estimation module by reducing the number of cycles necessary to perform a particular motion estimation algorithm.

Description:
BACKGROUND 
     1. Field of the Application 
     Generally, this application relates to the coding of video signals. More specifically, it relates to systems and methods for efficient, variable block size motion estimation used in video coding. 
     2. Description of the Related Art 
     The typical video display, such as a cathode ray tube (CRT) display or a liquid crystal display (LCD), provides a visible picture that is made up of a sequence of individual images, or frames, indexed by time. The sequence of frames is displayed, for example, at a rate of 30 frames per second. Because each frame includes a large amount of raw information, the sequenced video data is associated with a very high bandwidth requirement. This high bandwidth requirement typically necessitates efficient video compression coding to facilitate more efficient handling of the sequenced video data. 
       FIG. 1  illustrates the typical video sequence breakdown as is known in the art today. As shown in  FIG. 1 , a typical video sequence  100  includes a time indexed stream of individual frames  120 ,  170 - 190 . A particular frame  120  is made up of many slices of data, for example, slice  121 . Slice  121  can typically be partitioned into a set of macro-blocks  124 - 128 , where each macro-block is typically 16 picture elements (or pixels) by 16 pixels. Thus, frame  120  can be thought of as a grid of macro-blocks. Representative macro-block  127  can be further sub-divided, for example, into two 16×8 sub-blocks, such as  127   b , or into four 8×8 sub-blocks, such as  127   a   2 . Frames can be broken down into many different sizes, shapes and configurations of macro-blocks and sub-blocks. 
     The typical video sequence is characterized by a high degree of correlation between successive frames. Given the highly correlated nature of consecutive frames, a very simple block-motion model can offer a reasonably good description of the video process.  FIG. 2  illustrates a very simple block-motion model as is typically used in the art today. In this simple block-motion model, a current frame  211  includes two current macro-blocks  221 ,  231 . Each current macro-block  221 ,  231  can be thought of as being shifted from a previous macro-block  220 ,  230  of a previous frame  210 . The shift of each current macro-block  221 ,  231  can be indicated by a motion vector  250  associated with their respective previous macro-block  220 ,  230 . Thus, each macro-block in a current frame can be viewed as arising from a shifted location of that same macro-block in the previous frame, where the amount of shift is designated by its motion vector. 
     Commercial grade video compression systems known in the art today, including well-known industry standards, such as, International Telecommunications Union (ITU) H.261, H.263 and H.264, as well as International Standardization Organization (ISO)/International Electro-technical Commission (IEC) MPEG-1, MPEG-2 and MPEG-4, utilize the above properties associated with the video process to efficiently represent and compress video data. In recent years, advances have been made in how motion vector data is represented in the video bit-stream syntax, starting from H.261, when a single motion vector at full pixel resolution was allowed per macro-block, to H.264, where multiple motion vectors (as high as one per 4×4 sub-block or 16 per macro-block) at quarter-pixel resolutions and pointing to multiple reference frames are used. 
     In general, these video coding systems deploy a motion estimation module that searches for, and measures, the most likely motion vector for the current block (e.g., macro-block, sub-block, full frame, etc.) of data being analyzed. Typically, the motion estimation module is the most computation-intensive, and thus power-hungry, module of a particular video coding system. Once the motion vector is estimated by the motion estimation module, the motion vector, along with any residue information, between the current block of data and the predictor or reference block (i.e., the preceding block from the preceding frame), pointed to by the motion vector, is encoded to form the compressed bit-stream. Typically, the lower the amount of residue information the better the motion estimation. 
     Accordingly, sophisticated motion estimation algorithms attempt to offer a video quality similar to that of performing an exhaustive pixel-by-pixel motion search, but with a much lower complexity than the exhaustive search. One conventionally popular, high-performance motion estimation algorithm is called the unrestricted center biased diamond search (UCBDS) algorithm. The UCBDS algorithm generally compares a 16×16 macro-block in the current frame to a selection of 16×16 macro-blocks in the reference (or preceding) frame until the ‘best’ motion vector is determined. The most common metric used to compare various motion vector positions is the sum of absolute differences (SAD) metric. However other metrics are known in the art and at least some of them can also benefit from certain embodiments disclosed herein. As the name suggests, SAD is obtained by adding the absolute value of the differences between the current and reference pixel values over all of the pixels of the blocks under analysis. That is, for a 16×16 block SAD comparison between a current frame block and a reference frame block, each of the values of the 256 pixels in the current block is subtracted from each of the values of the associated 256 pixels in the reference block. The absolute values of all of these 256 pixel value differences are then added together to result in the SAD value for that block comparison. As one might expect, the lower the SAD value the better the motion vector position. 
     Typically, the UCBDS algorithm selects a starting position in the current block, e.g., the upper, left-hand integer pixel, and then selects a corresponding seed position in the reference block with which to begin the SAD comparisons. The seed position in the reference block will be the starting location (i.e., the upper, left-hand pixel) for defining the reference block in the reference frame. The UCBDS will compare the SAD value at the seed position to the SAD values at positions in a diamond pattern that is centered around the seed position, where the points of the diamond pattern are at locations that are plus or minus two (+/−2) pixels away from the seed position (i.e., for a total of nine SAD calculations). If the SAD value at the seed position is the best, then the UCBDS algorithm is complete for that block and the motion vector for determined. However, if one of the pixel locations on the diamond pattern results in the best SAD value, then that location is set as a new seed position and its SAD value is now compared to the SAD values at locations defined by a new diamond pattern centered around that new seed position. This method is continued until the new seed position has the best SAD value as compared to the SAD values at locations on the diamond pattern around it. On average, the UCBDS algorithm is known to finish searching and comparing after calculating the SAD values at about 18-20 integer pixel locations, resulting in a good motion vector for a particular block. 
     Where the motion vectors are desired to be represented with half-pixel accuracy, a conventional strategy for determining a half-pixel motion vector consists of first determining a good integer pixel resolution motion vector (as above, with the UCBDS algorithm) and then searching and comparing the SAD values at the eight half-pixel locations around the good integer pixel motion vector location to find a good half-pixel motion vector location. Likewise, when motion vectors are desired to be represented with quarter-pixel accuracy, first the good integer pixel motion vector location is determined, which is followed by determining the good half-pixel motion vector location, which in turn is followed by searching and comparing the SAD values at the eight quarter-pixel locations around the good half-pixel motion vector location to find a good quarter-pixel motion vector location. 
     As used herein, integer pixel and pixel (i.e., without qualification) refer to the actual, picture element location within a particular block (i.e., macro-block, sub-block, etc.) or frame, while sub-pixel (i.e., partial-pixel, half-pixel, quarter-pixel, and the like) refers to a fictitious picture element located a fraction of the way (i.e., one, two or three quarters of the way, and the like) between two integer pixel locations (i.e., horizontally, vertically and/or diagonally). A sub-pixel location is typically associated with a value given by a weighted averaging of the values of the nearby integer locations. For example, in the MPEG-4 video compression standard, the vertical half-pixel location between two vertically adjacent integer pixels with values A and B, respectively, is given by equation (1):
 
round(( A+B )/2),  (1)
 
where “round” denotes a rounding operation. Of course, equation (1) is for illustrative purposes only and is in no way intended to limit the scope of this application.
 
     A naïve algorithm to determine quarter-pixel accuracy would exhaustively search all eight half-pixel locations followed by exhaustively searching all eight quarter-pixel locations before providing a good quarter-pixel motion vector location. This can result in as many as sixteen extra searches and SAD comparisons, on top of the original 18-20 integer pixel searches. Additionally, more computations are required to determine the values corresponding to all of the half- and quarter-pixel locations. Furthermore, when variable block size motion vectors and multiple reference frames are allowed, such a search must potentially be carried out for each variety of block size and reference frame used. In summary, the possibility of sub-pixel, variable block sized, motion vectors can significantly increase the complexity of the motion estimation module. 
     Therefore, what are needed are systems and methods for performing the computations associated with motion estimation for variable block size, sub-pixel motion vectors in a more efficient manner, for example, by using a common core of SAD computations that are capable of quickly calculating different block size motion vector resolutions, at least partially in parallel. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       Aspects and features will become apparent to those ordinarily skilled in the art from the following detailed description of certain embodiments in conjunction with the accompanying drawings, wherein: 
         FIG. 1  illustrates the typical video sequence breakdown as is known in the art today; 
         FIG. 2  illustrates a very simple block-motion model as is conventionally used in the art today; 
         FIG. 3  illustrates a portion of an exemplary reference frame, showing full pixel positions and half-pixel locations as used in conjunction with certain embodiments; 
         FIG. 4  illustrates an additional algorithmic method that can enhance the motion estimation of the typical UCBDS algorithm and be used according to certain embodiments; 
         FIG. 5  illustrates an exemplary schematic for pipelining at least some of the operations for simultaneous SAD calculations according to certain embodiments; 
         FIG. 6  illustrates an exemplary parallelization of SAD calculations for a 16×16 macro-block according to certain embodiments; and 
         FIG. 7  illustrates an instance of a hardware design that facilitates the processing of cycle four as shown in  FIG. 5  according to certain embodiments. 
     
    
    
     DETAILED DESCRIPTION 
     Certain embodiments will now be described in detail with reference to the drawings, which are provided as illustrative examples so as to enable those skilled in the art to practice the embodiments and are not meant to limit the scope of the present application. Where certain elements of embodiments can be partially or fully implemented using known components or steps, only those portions of such known components or steps that are necessary for an understanding of the embodiments will be described, and detailed description of other portions of such known components or steps will be omitted so as to not obscure the embodiments. Further, certain embodiments are intended to encompass presently known and future equivalents to the components referred to herein by way of illustration. 
     Certain embodiments will be illustrated with an MPEG-4 simple profile example wherein half-pixel motion resolution and two different block sizes (e.g., 16×16 and 8×8) are used in conjunction with the UCBDS motion search algorithm discussed above. However, those skilled in the art will recognize that certain embodiments are broadly applicable to any block size as well as any sub-pixel resolution. Further, various video compression standards and motion search algorithms can also benefit from certain embodiments. All combinations of block sizes, sub-pixel resolutions, compression standards and search algorithms are intended to be within the scope of the present application. 
     Consider  FIG. 3 , which illustrates a portion of an exemplary reference frame  310  (i.e., the previous frame to which a current frame is compared), showing full pixel positions with plus signs, +s, and half-pixel locations with the letters X and O (e.g., Xs and Os), as used in conjunction with certain embodiments. Assume in  FIG. 3  that full pixel E represents a UCBDS location for a good motion vector for the current 16×16 macro-block and corresponds to the center pixel of a UCBDS diamond  320  defined by pixels S, A, O, C, K, J, W and G. At this point, the typical diamond evolution of the UCBDS search algorithm, as discussed above, has been completed. 
       FIG. 4  illustrates an additional algorithmic method that can enhance the motion estimation of the typical UCBDS algorithm and be used according to certain embodiments. As shown in  FIG. 4 , this additional algorithm begins at step  410  where the typical UCBDS algorithm ends, i.e., with a good integer pixel motion vector location for a current 16×16 macro-block. At steps  420   a - b , pixel data for the current and reference blocks are retrieved and the SAD for four more integer pixel locations can be compared to the SAD at the UCBDS good motion vector location (e.g., each SAD being calculated using the current 16×16 macro-block). As shown in  FIG. 3 , these four additional integer pixel locations of reference frame  310  correspond to a set of full pixel locations in an internal diamond  330  defined by pixels D, B, F and H, and adjacent to the good motion vector location, E. The better SAD of these five full pixel locations is then chosen as the best integer pixel motion vector location for the current 16×16 macro-block. For this example, and without limitation, let the corresponding motion vector for the current 16×16 macro-block associated with the best integer pixel motion vector location be denoted as mv — 16×16 and the associated SAD for this location be denoted as SAD — 16×16. 
     At steps  430   a - b , pixel data for the current sub-blocks and reference sub-blocks are retrieved so that searches and SAD comparisons can be performed to determine the best integer pixel motion vector location for each of the four current 8×8 sub-blocks defined in the current 16×16 macro-block. The current 16×16 macro-block can be divided into four 8×8 sub-blocks. Each of these four current 8×8 sub-blocks has, initially, a corresponding reference 8×8 sub-block within the reference 16×16 macro-block that is defined by the mv — 16×16 location. For each of the four current 8×8 sub-blocks, a best full pixel motion vector can be determined by comparing the SAD at the initial location for a particular 8×8 reference sub-block to the SADs at the locations corresponding to the eight adjacent integer pixels to the initial location (i.e., for a total of nine SAD calculations at integer pixel locations arranged in a square, with the initial location at the center of the square). The best integer pixel motion vector location for each of the 8×8 sub-blocks is chosen from these nine locations. For this example, and without limitation, let the corresponding motion vectors for each of the current 8×8 sub-blocks be denoted as mv — 8×8(i) and the associated SAD at each of the four locations be denoted as SAD — 8×8(i), for i=0, 1, 2, 3. 
     At step  440 , the integer pixel motion vector for the 16×16 macro-block, mv — 16×16, is compared to the four integer pixel motion vectors for the four 8×8 sub-blocks, mv — 8×8(i), to determine which representation is better for estimating the motion of the current 256 pixels (i.e., the pixels within the current 16×16 macro-block and within the four current 8×8 sub-blocks). Specifically, the condition of equation (2), below, is evaluated.
 
SAD — 16×16−offset SAD — 8×8(0)+SAD — 8×8(1)+SAD — 8×8(2)+SAD — 8×8(3),  (2)
 
where ‘offset’ is a positive quantity to compensate for an estimated amount of additional overhead required to encode four 8×8 motion vectors as compared to only one 16×16 motion vector for the same current 256 pixels. If the condition of equation (2) is true, then the four 8×8 integer pixel motion vectors, mv — 8×8(i), are considered better. If the condition of equation (2) is false, then the one 16×16 motion vector, mv — 16×16, is considered better for estimating the motion of the current 16×16 macro-block. As will now be evident to those skilled, ‘offset’ can be selected such that the comparison made in equation (2) could favor either half of the expression.
 
     In steps  450   a - b , pixel data for the current and reference (sub-)blocks are retrieved and, for the chosen condition of equation (2) from step  440  (i.e., either the four 8×8 motion vectors or the one 16×16 motion vector), the best half-pixel motion vector(s) is (are) determined. Assuming for this example that pixel E of  FIG. 3  is still the best location and that the one 16×16 motion vector is the better motion estimation representation, then the best motion vector location between E and the four Xs and four Os immediately adjacent to E (i.e., the 8 half-pixels either on or within inner diamond  330 ) will be selected. This selection can be accomplished by comparing the SAD for each of the eight half-pixel locations to the SAD at full pixel center of the half-pixel locations. The better of these nine locations would then be selected as the motion vector location and the process for that current macro-block would end, while the same process for a new current 16×16 macro-block would begin. However, in some implementations, determining the best half-pixel location can be abbreviated based on statistically analyses, to only those half-pixel locations that have the greatest likelihood of producing a lower SAD value than the SAD of the associated full pixel location. For example, the half-pixel determination step can be limited to searching and comparing only the three half-pixel locations to the right, below and diagonally right-below the previously chosen better integer pixel location. 
     A step-by-step, serial implementation of the additional algorithm illustrated in  FIG. 4  can result in fetching the same reference data from the reference frame and the same current data from the current frame into a processor&#39;s computation unit over and over again. It can also result in repeating the same or similar calculations over and over again. For example, the individual pixel value differences between the macro-block defined by the reference pixel location E and the corresponding pixel location in the current macro-block, i.e., X E , used to calculate the 16×16 integer pixel SAD can also be used in the computation of the corresponding 8×8 integer pixel SAD, as well as the half-pixel SAD calculations for the half-pixel locations in the neighborhood of E. Certain embodiments can store at least some of these repetitive and often-used calculation results to improve computational performance of the motion estimation process and modules by performing at least some (or some portions of) the various SAD calculations in parallel. 
     For example, in the case of a motion estimation module operating within a 32-bit architecture environment and using an 8-bit pixel resolution, the cycle count for the serial implementation of  FIG. 4  can be computed as follows. Note that cycles are being counted from the point where the UCBDS stops (i.e., after step  410 ). First, at steps  420   a - b , a 16×16 macro-block will include 64 words of 4 bytes each. If it takes one cycle to load a word, then one row of data from the macro-block will load in 4 cycles. For the case when memory is not aligned properly, an extra cycle will be needed. This results in a total of 5 cycles per row, which results in 80 cycles for one 16×16 integer pixel SAD. Since this SAD is calculated at 4 pixel locations of internal diamond  330 , a total of at least 320 cycles will be needed to complete steps  420   a - b.    
     Second, at steps  430   a - b , for each of the 8×8 sub-blocks, assuming an unaligned memory access, 3 cycles will be needed to load a row. This results in a total of 24 cycles per 8×8 sub-block, which results in 96 cycles for all four of the 8×8 sub-blocks. If searching nine locations for each of the 8×8 sub-blocks, this corresponds to almost 900 cycles. The overhead for evaluating the step  440  condition is nominal by comparison and will be ignored for this example. 
     Finally, at steps  450   a - b , half-pixel computations are made. Before going into the half-pixel details, note that for both vertical and diagonal half-pixel computations, two rows must be fetched for generating one row of half-pixels. For horizontal-only half-pixel computations, however, only one row of integer pixels must be fetched to generate the half-pixel values. In the implementations of certain embodiments presented herein, the examples assume only computing half-pixel values for at three half-pixel locations: one horizontal half-pixel to the right, one vertical half-pixel down and one diagonal half-pixel down and to the right for either a 16×16 block or the four 8×8 blocks, depending on whether the 16×16 representation is better or the four 8×8 representations are better. 
     First, when the one 16×16 representation is better, vertical and diagonal half-pixel computations consume about 160 cycles per SAD. The horizontal half-pixel computation would consume about 80 cycles. Thus, the three half-pixel computations would consume about 400 cycles. Second, when the four 8×8 representations are better, the vertical and diagonal half-pixel computations would consume about 48 cycles and the horizontal half-pixel computation would consume around 24 cycles, for each 8×8 sub-block. Thus, the three half-pixel computations would consume about 120 cycles per 8×8 sub-block. Given that there are four such 8×8 sub-blocks in a 16×16 macro-block, half-pixel computations for all four 8×8 sub-blocks would consume about 500 cycles. 
     To summarize the example of a serial implementation of the process shown in  FIG. 4 : when the 16×16 representation is better, it would take a total of about 1600 cycles to perform the algorithm; and when the four 8×8 representations are better, it would take a total of about 1720 cycles to perform the algorithm. Therefore, certain embodiments can take advantage of the strong commonality in the data needed for, and computations of, the various SAD calculations to reduce the processing cycles needed to perform the exemplary algorithm of  FIG. 4 . As in the above exemplary cycle calculations, the description below of certain embodiments assumes a 32-bit architecture and a per-pixel resolution of 8 bits. 
     Referring back to  FIG. 3 , certain embodiments consist of maintaining (e.g., storing accumulating or collecting, for example in random access memory, registers, accumulators, disks, memory cards, etc., and the like) the integer pixel value differences used for nine SAD calculations for each of the four 8×8 sub-blocks at each of the nine full pixel locations including and adjacent to the best location (i.e., A, B, C, D, E, F, G, H and I in  FIG. 3 , where E is the best location) resulting in maintaining a total of 36 SAD calculations for all four 8×8 sub-blocks. Further, certain embodiments can include maintaining the half-pixel values and half-pixel value differences used for 16 half-pixel SAD calculations for each of the four 8×8 sub-blocks corresponding to each of the 16 half-pixel locations between the nine full pixel locations including and adjacent to the best location (i.e., the half-pixel Xs and Os between each pair of the integer pixel locations of A, B, C, D, E, F, G, H and I in  FIG. 3 ) resulting in a total of 64 SAD calculations for all four 8×8 sub-blocks. The corresponding 16×16 SAD calculations, both integer pixel and half-pixel, can be directly inferred from all of the maintained 8×8 SAD calculations. 
       FIG. 5  illustrates an exemplary flow for pipelining, or parallelizing, at least some of the operations for simultaneous SAD calculations according to certain embodiments, so as to better utilize the system resources while decreasing the cycle count required for accomplishing the SAD calculations. In  FIG. 5 , each operand shown corresponds to a set of 4 adjacent integer pixels in a row identified, for discussion purposes only, by the left-most pixel in the row. This example uses a naming convention such that the letters A through I denote data locations from the reference frame (as illustrated in  FIG. 3 ) that are used in SAD calculations for current data (i.e., macro-block, sub-block, etc.) in the current frame, which is denoted by the letter X. In this example, assume that SAD calculations are desired as between each of the reference frame locations (i.e., A through I) and the current data location for a 16×16 macro-block. 
     As shown in  FIG. 5 , certain embodiments can achieve a complete set of calculations for one 4-byte word in 9 cycles (i.e., as used in this example, a “complete set” refers to the calculations discussed above with reference to steps  420 - 450  of  FIG. 4 ). Since each macro-block has a size equal to 64 words (i.e., 256 pixels at 8 bits per pixel using 4-byte words), this results in a total of only about 576 cycles the entire macro-block (i.e., 9 cycles per word for 64 words). This represents about a 64-66% decrease in the number of required cycles over the serial approach shown in  FIG. 4 , which was shown to take between about 1600 and 1700 cycles to accomplish the same task. 
       FIG. 6  illustrates an exemplary parallelization of SAD calculations for a 16×16 macro-block according to certain embodiments. As shown in  FIG. 6 , and similar to  FIG. 4  for ease of comparison purposes, step  610  begins where the where the typical UCBDS algorithm ends, i.e., with a good integer pixel motion vector location for a current 16×16 macro-block. At steps  615   a - b  pixel data for the current and reference blocks are retrieved and pipelining calculations for the current block are performed and maintained. These pipelined calculations help to parallelize the process of  FIG. 6  as compared to the serial process of  FIG. 4 . In this example, as discussed further with reference to  FIG. 5 , steps  620 - 650  can be accomplished for a complete set of calculations for one 4-byte word in 9 cycles. Steps  620 - 650  generally accomplish the same result as steps  420 - 450  of  FIG. 4 . However steps  620 - 650  are pipelined, or parallelized, and do not necessarily require repetitive fetches of the current and reference data, as do steps  420   a ,  430   a  and  450   a . Additionally, in certain embodiments, step  615   a  of  FIG. 6  can be performed prior to step  610 , to accomplish retrieving the current and reference data only once for the UCBDS portion of this exemplary method as well as for steps  620 - 650 . 
     Further examining  FIG. 5 , cycles  4 ,  5 ,  7 , and  8  correspond to the most intensive processing cycles in this exemplary pipelined processing chain. The underlying hardware for each of these cycles would need sufficient logic so as to enable performance of the operations in a single cycle. One example of an efficient hardware design that facilitates the above mentioned processing is shown in  FIG. 7 . Without loss of generality, the action of this hardware design is further illustrated for cycle  4  of the pipelined processing chain of  FIG. 5 . Further, upon review of this hardware design with reference to  FIG. 5  and the remainder of this disclosure, it will become apparent to those skilled in the art how to expand and implement the certain embodiments of this disclosure into various video coding applications using various combinations of software and hardware, including, for example, application specific integrated circuits (ASICs), processors, micro-controllers and the like. 
     For example, consider the case when the pixel location E (as shown in  FIG. 3 ) is being processed for SAD computation in the UCBDS algorithm (e.g., step  410  of  FIG. 4 ) for a current macro-block. Assume further that pixels A, B, C and D were processed as in cycles  0 ,  1 ,  2 ,  3  of  FIG. 5  to generate their corresponding SAD computations before the SAD computation for pixel E is performed.  FIG. 7  shows the computations that can be performed simultaneously to obtain other SAD values along with the regular 16×16 SAD computation performed for pixel E. Based on these assumption, difference results corresponding to pixels adjacent to E, i.e., (D-X), (B-X) and (A-X), have already been calculated and stored. With these previously calculated values available, all of the following SAD computations can be performed simultaneously with the hardware shown in  FIG. 7  (i.e., where the → symbol indicates an accumulation operation). 
     16×16 Integer Pixel SAD corresponding to Pixel E (SAD16 E )
 
SAD16 E →SAD16 E +|E−X|
 
8×8 Integer Pixel SAD corresponding to Pixel E (SAD8 E )
 
SAD8 E →SAD8 E +|E−X|
 
16×16 Vertical Half-pixel SAD between B &amp; E (SAD16 BE )
 
SAD16 BE →SAD16 BE +|(( E−X )+( B−X )+1)/2|
 
8×8 Vertical Half-pixel SAD between B &amp; E (SAD8 BE )
 
SAD8 BE →SAD8 BE +|(( E−X )+( B−X )+1)/2|
 
16×16 Horizontal Half-pixel SAD between D &amp; E (SAD8 DE )
 
SAD16 DE →SAD16 DE +|(( E−X )+( D−X )+1)/2|
 
8×8 Horizontal Half-pixel SAD between D &amp; E (SAD8 DE )
 
SAD8 DE →SAD8 DE +|(( E−X )+( D−X )+1)/2|
 
16×16 Diagonal Half-pixel SAD between A, B, D &amp; E (SAD8 ABDE )
 
SAD16 ABDE →SAD16 ABDE +|(( A−X )+( B−X )+( D−X )+( E−X )+2)/4|
 
8×8 Diagonal Half-pixel SAD between A, B, D &amp; E (SAD8 ABDE )
 
SAD8 ABDE →SAD8 ABDE +|(( A−X )+( B−X )+( D−X )+( E−X )+2)/4|
 
     Since each of the operands shown in  FIGS. 5 and 7  corresponds to a linear set of 4 adjacent pixels, each adder in  FIG. 7  consists of 4 atomic adders resulting in a total of nearly 20 adders. Thus, in certain embodiments, the impact of the parallelization of SAD computations according to certain embodiments can be quantified in terms of cycles saved in the overall system picture. For each of the exemplary cases below, assume the following approximate numbers to highlight the overall savings in cycles. Assume a quarter video graphics array (or QVGA) 320×240 resolution video sequence being displayed at 15 frames per second (fps). At this resolution there are 300 macro-blocks per frame, or 4500 macro-blocks per second. 
     For the serial, motion vector case using a 16×16 half-pixel approach (as illustrated with reference to  FIG. 4 ), it takes about 1600 cycles to fetch the reference and current macro-block data. It will take about another 1280 cycles to perform the initial UCBDS analysis (i.e., assuming 16 SAD computations on average). It will take about 320 cycles to perform the final UCBDS (i.e., assuming 4 integer pixel searches). It will take about 900 cycles to perform the 8×8 integer pixel motion vector calculations. It will take 400 cycles to perform the half-pixel motion vector computations for the 16×16 block. Thus, it will take about 4500 cycles for a macro-block, which means it will take about 20,250,000 cycles (i.e., 4500 cycles per macro-block times 4500 macro-blocks per second) for one second of video (i.e., 20.25 MHz). 
     For the parallelized SAD calculation, motion vector case using a 16×16 half-pixel approach (as illustrated with reference to  FIGS. 5-7 ), it still takes about 1600 cycles to fetch the reference and current macro-block data, and about another 1200 cycles to perform the initial UCBDS analysis (i.e., assuming 15 SAD computations on average). However, it will only take about 600 cycles to perform the final UCBDS, the 8×8 integer pixel motion vector calculations and the half-pixel motion vector computations. Thus, it will take about 3300 cycles for a macro-block, which means it will take about 14,850,000 cycles (i.e., 3300 cycles per macro-block times 4500 macro-blocks per second) for one second of video (i.e., 14.85 MHz). 
     For the serial, motion vector case using an 8×8 half-pixel approach (as illustrated with reference to  FIG. 4 ), it takes about 1600 cycles to fetch the reference and current macro-block data. It will take about another 1280 cycles to perform the initial UCBDS analysis (i.e., assuming 16 SAD computations on average). It will take about 320 cycles to perform the final UCBDS (i.e., assuming 4 integer pixel searches). It will take about 900 cycles to perform the 8×8 integer pixel motion vector calculations. It will take 500 cycles to perform the half-pixel motion vector computations for four, 8×8 blocks. Thus, it will take about 4600 cycles for a macro-block, which means it will take about 20,700,000 cycles (i.e., 4600 cycles per macro-block times 4500 macro-blocks per second) for one second of video (i.e., 20.70 MHz). 
     For the parallelized SAD calculation, motion vector case using an 8×8 half-pixel approach (as illustrated with reference to  FIGS. 5-7 ), it still takes about 1600 cycles to fetch the reference and current macro-block data, and about another 1200 cycles to perform the initial UCBDS analysis (i.e., assuming 15 SAD computations on average). However, it will only take about 600 cycles to perform the final UCBDS, the 8×8 integer pixel motion vector calculations and the half-pixel motion vector computations for four, 8×8 blocks. Thus, it will still take about 3300 cycles for a macro-block, which means it will take about 14,850,000 cycles (i.e., 3300 cycles per macro-block times  4500  macro-blocks per second) for one second of video (i.e., 14.85 MHz). 
     Thus in the overall system context, the parallelized SAD calculation approach of certain embodiments can get at least a 28% cycle savings over the serial approach. It will be apparent to those skilled in the art that, the parallelized calculation approach uses extra hardware as compared to the serial approach. First, to ensure the pipelining of operations as shown in  FIG. 5 , there may be a need for the storage of, in the context of the above examples, about 20-25 pixels worth of data at any given time. Second, the parallelized calculation approach may need, again, in the context of the above examples, about 20-25 additional adders to facilitate the simultaneous, pipelined SAD computations. However, this does not mean that additional storage or additional adders must necessarily be designed into the system. Rather, certain embodiments can increase the utilization of already designed-in system storage and system adders. 
     Although the application has been particularly described with reference to certain embodiments, it should be readily apparent to those of ordinary skill in the art that various changes, modifications, substitutes and deletions are intended within the spirit and scope thereof. Accordingly, it will be appreciated that in numerous instances some features can be employed without a corresponding use of other features. Further, those skilled in the art will understand that variations can be made in the number and arrangement of inventive elements illustrated and described in the above figures. It is intended that the scope of the appended claims include such changes and modifications.