Patent Publication Number: US-2021168354-A1

Title: Video Coding System

Description:
FIELD OF THE INVENTION 
     The present invention relates to video coding. 
     COPYRIGHT NOTICE 
     A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all rights whatsoever. 
     BACKGROUND OF THE INVENTION 
     Video coding generally takes place in accordance with a standard. Known standards include, but are not limited to: AVC; VP9; HEVC; AV1; and VVC. 
     Persons skilled in the art will appreciate the following: 
     1. Providing solutions to issues mentioned in the present application (including in the Background thereof) in exemplary embodiments of the present invention have applicability to various use cases, and not only to data center and/or cloud use cases.
 
2. Solutions provided in exemplary embodiments of the present invention have applicability to (by way of non-limiting example): video compression; motion estimation; video deblocking filter; Current Picture Referencing (CPR) and video transform. Non-limiting examples of relevant systems to which exemplary embodiments of the present invention may be applicable include, by way of non-limiting example: HEVC/H.265 (high efficiency video coding); AVC/H.264 (advanced video coding); VP9; AV-1 (AOMedia Video 1); and VVC (versatile video coding). While, generally, uses of exemplary embodiments of the present invention are described in the context of motion estimation, such descriptions are not meant to be limiting, and persons skilled in the art will appreciate, in light of the description herein, how to provide solutions in at least the other cases mentioned above in the present paragraph.
 
     The load of a single encoding task itself is generally too big for a single CPU. Reference is now made to  FIG. 9 , which is a simplified graphical illustration depicting a relationship between CPU power and various encoding tasks; to  FIG. 10 , which is a simplified pictorial illustration depicting an approximate timeline view of various past, present, and future encoding standards; and to  FIG. 11 , which is a simplified tabular illustration depicting complexity of various encoding standards.  FIG. 9  shows that, for quite some time, a single CPU has not been able to keep up with a single encoding task; this problem, it is believed, will become more severe in the future, as future standards are adopted and become more widely used (see  FIG. 10 ) and as the complexity of those future standards is expected to be higher, as shown in  FIG. 11 . 
     In addition, the amount of information/data in every stream is increasing, as more and more information/data is produced and streamed into the edge devices at higher resolution. Reference is now additionally made to  FIG. 12 , which is a simplified partly pictorial, partly graphical illustration depicting relationships between resolution and complexity.  FIG. 12  show a very conservative forecast of resolution mixture along the years, and also shows the nominal complexity involved with the fact that there are more pixels in every stream. 
     Reference is now additionally made to  FIG. 13 , which is a simplified graphical illustration depicting relationships between video complexity, CPU capability, and computational effort.  FIG. 13  shows that the real video complexity (complexity per pixel X number of pixels) is suffering from a growing gap between CPU capability and the computational effort needed. 
     The consideration of the problem presented up to this point does not include the major increase, which is expected to continue, in the number of video streams needs to be simultaneously processed in the data center. 
     Having considered the above, it is fair to ask why the art, as known to the inventors of the present invention, does not yet include any acceleration device offering video encoding acceleration for the data center. Without limiting the generality of the present invention, the term “device” may be used in the present description to describe implementations of exemplary embodiments of the present invention, as well as (in the preceding sentence) apparent lacks in the known art. It is appreciated that, in exemplary embodiments of the present invention, by way of non-limiting example, implementation may take place in: an ASIC [Application Specific Integrated Circuit]; an ASSP [Application Specific Standard Part]; an SOC [System on a Chip], an FPGA [Field Programable Gate Array]; in a GPU [graphics processing unit]; in firmware; or in any appropriate combination of the preceding. 
     The inventors of the present invention believe that the reasons that the art, as known to the inventors of the present invention, does not yet include an appropriate video acceleration as described above include: 
     Technological Reason 
     The huge diversity in the video standards (as partially imposed by the situation depicted in  FIG. 10 ) which need to be supported, as well as the rich feature-set needed in order to fully support any single encoder, might make it appear, prior to the invention of exemplary embodiments of the present invention, to be impossible to create a generic acceleration device for accelerating video encoding in the data center. 
     Business Reason 
     In the last decade, a huge amount of technology and knowledge was gained in the industry by encoder vendors (who generally, but not necessarily, provide their encoders in software [SW]; for purposes of ease of description, the term “SW” is used throughout the present specification and claims to describe such encoders, which might in fact be provided, generally by encoder vendors in software, firmware, hardware, or any appropriate combination thereof) that tuned the video encoding to “their best sweet spot”, representing what each encoder vendor believed to be their competitive advantage. It is important in this context to understand that video compression, by its nature as a lossy compression, differs in various implementations in many aspects, such as: performance; CPU load; latency; (which are also well known in other, non-video workloads); but also in quality. For the aspect of quality, there is no common and accepted objective metric that quantifies and grades the quality; rather, multiple metrics (such as, for example, PSNR, SSIM, and VMAF) are known, with no universal agreement on which metric is appropriate. Thus, the accumulated knowledge and reputation of each company somehow blocks any potential acceleration device vendor that wishes to penetrate the market of acceleration devices. In other words, if such a vendor were to create a device such as, by way of on particular non-limiting example, an ASIC implementing a video codec, the vendor would find himself competing against the entire ecosystem. Even within a given vendor, different quality measures might be used for different use cases, thus leading to an incentive to produce multiple such ASIC implementations.
 
The present invention, in exemplary embodiments thereof, seeks to provide an improved video encoding, video compression, motion estimation, Current Picture Referencing (CPR), and computer architecture system in which part of the work (such as, by way of non-limiting example, any one or more of the following: motion estimation; Current Picture Referencing (CPR) transform; deblocking; loop filter; and context-adaptive binary arithmetic coding (CABAC) engine) is offloaded in such a way that (in the specific non-limiting example of an encoder):
 
Work will be dramatically offloaded from the encoder;
 
The exemplary embodiments of the present invention will be agnostic to the specific encoder being implemented; and
 
A given encoder vendor (by way of non-limiting example, a software encoder vendor) will be enabled to run their own “secret sauce” and use one or more exemplary embodiments of the present invention to provide acceleration as a primitive operation. The appropriate quality/performance can be chosen by a given encoder vendor for the appropriate use case/s.
 
     There is thus provided in accordance with an exemplary embodiment of the present invention a system including an acceleration device including input circuitry configured, for each of a first plurality of video frames to be encoded, to receive an input including at least one raw video frame and at least one reference frame, and to divide each of the first plurality of video frames to be encoded into a second plurality of blocks, and similarity computation circuitry configured, for each one of the first plurality of video frame to be encoded: for each block of the second plurality of blocks, to produce a score of result blocks based on similarity of each block in each frame to be encoded to every block of the reference frame, an AC energy coefficient, and a displacement vector. 
     Further in accordance with an exemplary embodiment of the present invention the at least one raw video frame and the at least one reference frame are identical. 
     Still further in accordance with an exemplary embodiment of the present invention the score of result blocks includes a ranked list. 
     Additionally in accordance with an exemplary embodiment of the present invention the result blocks are one of fixed size, and variable size. 
     Moreover in accordance with an exemplary embodiment of the present invention the system also includes weighting circuitry configured to weight at least some of the second plurality of blocks. 
     Further in accordance with an exemplary embodiment of the present invention, for a given block B of the second plurality of blocks, the weighting circuitry is configured to weight the block B to produce a weighted block B′ in accordance with the following formula: B′=A*B+C 1 , where A and C 1  are scalars. 
     Still further in accordance with an exemplary embodiment of the present invention the system also includes upsampling circuitry configured to upsample at least some of the second plurality of blocks, and the score of results blocks is based on similarity of each block to at least one upsampled block. 
     Additionally in accordance with an exemplary embodiment of the present invention the system also includes a second component, and the second component receives an output from the acceleration device and produces, based at least in part on the output received from the acceleration device, a second component output in accordance with a coding standard. 
     Moreover in accordance with an exemplary embodiment of the present invention the second component includes a plurality of second components, each of the plurality of second components producing a second component output in accordance with a coding standard, the coding standard for one of the plurality of second components being different from a coding standard of others of the plurality of second components. 
     Further in accordance with an exemplary embodiment of the present invention the second component includes an aggregation component configured to aggregate a plurality of adjacent blocks having equal displacement vectors into a larger block. 
     Still further in accordance with an exemplary embodiment of the present invention the larger block has a displacement vector equal to a displacement vector of each of the plurality of blocks having equal displacement vectors, and the larger block has a score equal to a sum of scores of the plurality of blocks having equal displacement vectors. 
     There is also provided in accordance with another exemplary embodiment of the present invention a method including providing an acceleration device including input circuitry configured, for each of a first plurality of video frames to be encoded, to receive an input including at least one raw video frame and at least one reference frame, and to divide each of the first plurality of video frames to be encoded into a second plurality of blocks, and similarity computation circuitry configured, for each one of the first plurality of video frame to be encoded: for each block of the second plurality of blocks, to produce a score of result blocks based on similarity of each block in each frame to be encoded to every block of the reference frame, an AC energy coefficient and a displacement vector, and providing the input to the acceleration device, and producing the score of result blocks and the displacement vector based on the input. 
     Further in accordance with an exemplary embodiment of the present invention the at least one raw video frame and the at least one reference frame are identical. 
     Still further in accordance with an exemplary embodiment of the present invention the score of result blocks includes a ranked list. 
     Additionally in accordance with an exemplary embodiment of the present invention the result blocks are one of fixed size, and variable size. 
     Moreover in accordance with an exemplary embodiment of the present invention the method also includes weighting at least some of the second plurality of blocks. 
     Further in accordance with an exemplary embodiment of the present invention, for a given block B of the second plurality of blocks, the weighting weights the block B to produce a weighted block B′ in accordance with the following formula: B′=A*B+C 1 , where A and C 1  are scalars. 
     Still further in accordance with an exemplary embodiment of the present invention the method also includes upsampling at least some of the second plurality of blocks, and the score of results blocks is based on similarity of each block to at least one upsampled block. 
     Additionally in accordance with an exemplary embodiment of the present invention the method also includes providing a second component receiving an output from the acceleration device and producing, based at least in part on the output received from the acceleration device, a second component output in accordance with a coding standard. 
     Further in accordance with an exemplary embodiment of the present invention the second component includes a plurality of second components, each of the plurality of second components producing a second component output in accordance with a coding standard, the coding standard for one of the plurality of second components being different from a coding standard of others of the plurality of second components. 
     Still further in accordance with an exemplary embodiment of the present invention the second component includes an aggregation component configured to aggregate a plurality of adjacent blocks having equal motion vectors into a larger block. 
     Additionally in accordance with an exemplary embodiment of the present invention the larger block has a displacement vector equal to a displacement vector of each of the plurality of blocks having equal rank, and the larger block has a score equal to a sum of scores of the plurality of blocks having equal displacement vectors. 
     Moreover in accordance with exemplary embodiments of the present invention the reference frame includes one of a reconstructed reference frame, and an original reference frame. 
     The present invention, in certain embodiments thereof, seeks to provide improved systems and methods for video coding. 
     There is thus provided in accordance with an exemplary embodiment of the present invention a system including an acceleration device including input circuitry configured, for each of a first plurality of video frames to be encoded, to receive an input including at least one raw video frame and at least one reference frame, and to divide each of the first plurality of video frames to be encoded into a second plurality of blocks, and similarity computation circuitry configured, for each one of the first plurality of video frame to be encoded: for each the block of the second plurality of blocks, to produce an intra-prediction hint and an intra-prediction direction. 
     Further in accordance with an exemplary embodiment of the present invention the reference frame includes a target frame. 
     Still further in accordance with an exemplary embodiment of the present invention the reference frame does not include a reconstructed frame. 
     Additionally in accordance with an exemplary embodiment of the present invention the intra-prediction hint and the intra-prediction direction are provided to a software component, external to the acceleration device, for encoding the first plurality of video frames. 
     Moreover in accordance with an exemplary embodiment of the present invention the software component is configured to encode video in accordance with a video coding standard. 
     Further in accordance with an exemplary embodiment of the present invention the acceleration device is configured to provide the intra-prediction hint and the intra-prediction direction in a manner which is adapted for use with more than one video coding standard. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The present invention will be understood and appreciated more fully from the following detailed description, taken in conjunction with the drawings in which: 
         FIG. 1A  is a simplified tabular illustration depicting an inter block in a video bit stream; 
         FIG. 1B  is a simplified block diagram illustration of an application acceleration system, constructed and operative in accordance with an exemplary embodiment of the present invention; 
         FIG. 2  is a simplified pictorial illustration depicting H.264/AVC block partitioning; 
         FIG. 3  is a simplified pictorial illustration depicting HEVC (H.265) block partitioning; 
         FIG. 4  is a simplified tabular illustration depicting an exemplary order of block encoding, intended in exemplary cases to be performed by an application acceleration system such as the system of  FIG. 1B ; 
         FIG. 5  is a simplified tabular illustration depicting an exemplary result of operations performed by an acceleration device in accordance with an exemplary embodiment of the present invention; 
         FIG. 6  is another simplified tabular illustration depicting an exemplary result of operations performed by an acceleration device in accordance with an exemplary embodiment of the present invention; 
         FIG. 7  is a simplified pictorial illustration depicting a “local minimum” problem that may be encountered by an exemplary system in accordance with an exemplary embodiment of the present invention; 
         FIG. 8  is a simplified pictorial illustration depicting an operation on a low-resolution image, which operation may be carried out by an exemplary system in accordance with an exemplary embodiment of the present invention; 
         FIG. 9  is a simplified graphical illustration depicting a relationship between CPU power and various encoding tasks; 
         FIG. 10  is a simplified pictorial illustration depicting an approximate timeline view of various past, present, and future encoding standards; 
         FIG. 11  is a simplified tabular illustration depicting complexity of various encoding standards; 
         FIG. 12  is a simplified partly pictorial, partly graphical illustration depicting relationships between resolution and complexity; 
         FIG. 13  is a simplified graphical illustration depicting relationships between video complexity, CPU capability, and computational effort; 
         FIG. 14  is a simplified pictorial illustration depicting various portions of video codec standards; 
         FIG. 15  is a simplified pictorial illustration depicting an exemplary search area for motion vector prediction; 
         FIG. 16  is a simplified pictorial illustration depicting a non-limiting example of pixel sub blocks; 
         FIG. 17A  is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream; 
         FIG. 17B  is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, including use of an exemplary embodiment of the acceleration system of  FIG. 1B ; 
         FIG. 18  is a simplified block diagram illustration depicting a particular exemplary case of using the acceleration system of  FIG. 1B ; 
         FIG. 19  is a simplified block diagram illustration depicting another particular exemplary case of using the acceleration system of  FIG. 1B ; 
         FIG. 20  is a simplified block diagram illustration depicting still another particular exemplary case of using the acceleration system of  FIG. 1B ; 
         FIG. 21  is a simplified block diagram illustration depicting yet another particular exemplary case of using the acceleration system of  FIG. 1B ; 
         FIG. 22  is a simplified partly pictorial, partly block diagram illustration of an exemplary embodiment of a portion of the application acceleration system of  FIG. 1B ; 
         FIG. 23  is a simplified tabular illustration depicting an exemplary result of operations performed by an acceleration device in accordance with another exemplary embodiment of the present invention; 
         FIG. 24  is a simplified tabular illustration depicting an exemplary result of operations performed by an acceleration device in accordance with still another exemplary embodiment of the present invention; 
         FIG. 25  is a simplified tabular illustration depicting an exemplary result of operations performed by an acceleration device in accordance with yet another exemplary embodiment of the present invention; 
         FIGS. 26A and 26B  are simplified tabular illustrations useful in understanding still another exemplary embodiment of the present invention; 
         FIG. 27A  is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream; 
         FIG. 27B  is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, including use of an exemplary embodiment of the acceleration system of  FIG. 1B ; 
         FIG. 28  is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, including use of an exemplary embodiment of the acceleration system of  FIG. 1B ; 
         FIG. 29  is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, including direction estimation and including use of an exemplary embodiment of the acceleration system of  FIG. 1B ; 
         FIG. 30  is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, including direction estimation and inter-prediction hint, and including use of an exemplary embodiment of the acceleration system of  FIG. 1B ; 
         FIGS. 31-34  depict video frame encoding under various scenarios; and 
         FIG. 35  depicts DC intra prediction (on the left side thereof) and Planar intra prediction (on the right side thereof). 
     
    
    
     DETAILED DESCRIPTION OF EMBODIMENTS 
     The following general discussion may be helpful in understanding certain exemplary embodiments of the present invention which are described herein. 
     Among hundreds of tools in a video compression standard, the motion estimation portion/tool, (which is described in the standard by the motion compensation procedure), is generally considered to be the most demanding one when it comes to computational effort. The preceding also applies a Current Picture Referencing (CPR) tool. 
     Theoretically, motion estimation is not part of the video standard, as illustrated in  FIG. 14 , which is a simplified pictorial illustration depicting various portions of video codec standards. However, a motion estimation procedure is involved in comparing a block (termed herein a “reference block”) against many blocks in the reference frames, finding the block with greatest (or in some cases close to greatest) similarity, and then performing a motion compensation which comprises, as is well known, writing the residual (as is known in the art) as well as the motion vectors (also termed herein “displacement vectors”) in the bitstream. In some cases, a “factor” may be used to find a block which, multiplied by some constant (factor), is close to a given block. In other cases, two blocks from two different frames may be combined via weighted summing, and then a block close to the average may be found. 
     Typically, in many codec systems, the motion estimation and the motion compensation are built as one unit, which means that the motion estimation score function (which is the “similarity” to the reference block), is the same as the compensation part, thus allowing the codec to use the score of the best matching block as a residual in the bitstream without further processing. 
     Reference is now made to  FIG. 1A , which is a simplified tabular illustration depicting an inter block, generally designated  101 , in a video bit stream. A high level view of a inter block in a video bitstream is shown in  FIG. 1A . 
     A block header  103  specifies the block type (which can in general be, by way of non-limiting example, inter or intra, the particular non-limiting example shown in  FIG. 1A  being an inter block with a single motion vector (MV) structure). 
     A motion vector  105  represents the distance between the top left corner of the inter block to the top left corner of the reference block, while residual bits  107  (which are, in certain exemplary embodiments, represent the difference between the reference block and the target block (a given block). Each one of the sections shown in  FIG. 1A  may be compressed differently, as is known in the art. 
     The portion/size of each section in  FIG. 1A  is dynamic, in that each one of the three sections can be of variable size. A goal, in exemplary embodiments of the present invention, is to reduce the total number of bits in an entire bitstream, not just to reduce the total number of bits in a given inter block. 
     Generally speaking, the part of the process of generating an inter block which involves heavy computation is to read (in many case, by way of non-limiting example) tens of blocks for every reference block and to calculate the respective differences. Performing this operation itself may consume approximately 50 times more memory bandwidth than accessing the raw video itself. It is also appreciated that the compute effort of the process of generating an inter block may be very large, approximately, as well as the compute effort which is estimated to be approximately 50 O(number of pixels). 
     The motion estimation part is generally responsible not only for finding a block with the minimal residual relative to each reference, but also for finding an optimal partitioning; by way of non-limiting example, a 32×32 block with 5 bits residual will consume many fewer bits in the bitstream than 4 8×8 blocks with 0 bits residual in each of them. In this particular non limiting example, the 32×32 block partitioning would be considered optimal. Persons skilled in the art will appreciate that the method of selecting the best matched block is dependent on the details of the particular codec standard, including, by way of non-limiting example, because different standards treat motion vectors having large magnitude differently. Non-limiting examples of “differently” in the preceding sentence include: different partitioning; different sub-pixel interpolation; and different compensation options which may be available. It is appreciated that, in exemplary embodiments of the present invention, sub-pixels are produced by upsampling, as is known in the art. 
     In addition to what has been stated above, the different video standards differ from one another, with respect to motion compensation, in at least the following parameters: 
     Motion Vector Resolution: 
     Older standards allow only full pixel comparison (against real blocks), while newer standards allow fractional sampling interpolations. The different standards also differ in filters used for the interpolation/s. Other features which differ between different standards include the particulars of rounding and clipping, as are well known in the art.
 
Motion compensation residual function: calculates residual data in the bitstream. Block size being compensated. By way of particular non-limiting example: In H.264/AVC block partitioning as shown in  FIG. 2  was allowed by the standard.
 
By contrast, in H.265/HEVC, the partitioning shown in  FIG. 3  was introduced. Weighted prediction. Weighted prediction was introduced in H.264 standard, in the Main and Extended profiles. The weighted prediction tool allows scaling of a reference frame with a multiplicative weighting factor, and also add an additive offset (constant) to each pixel. The weighted prediction tool is generally considered to be highly powerful in scenes of fade in/fade out.
 
     When fades are uniformly applied across the entire picture, a single weighting factor and offset are sufficient to efficiently encode all macroblocks in a picture that are predicted from the same reference picture. When multiple reference pictures are used, the best weighting factor and offsets generally differ during a fade for the different reference pictures, as brightness levels are more different for more temporally distant pictures. 
     By way of particular non-limiting example: for single directional prediction the following equation represents the motion compensation with weighted prediction: 
       Sample P =Clip1(((Sample P·W 0+2LWD−1)&gt;&gt;LWD)+ O 0)
 
     where Clip 1 ( ) is an operator that clips to the range [0, 255], W 0  and O 0  are the reference picture weighting factor and offset respectively, and LWD is the log weight denominator rounding factor. SampleP is the list 0 initial predictor, and SampleP is the weighted predictor. 
     Persons skilled in the art will appreciate that the motion estimation is generally performed against the weighted reference frame (resulting from applying the above SampleP formula). Persons skilled in the art will further appreciate that it is a reasonable assumption that the compensation function will be different in future codecs. 
     It appears reasonable to assume that future codec standards will continue to differ in the points mentioned immediately above. 
     Motion estimation procedures include “secret sauce” as described above. In order to allow agnostic preparation which will later allow motion estimation with the desired “secret sauce”, exemplary embodiments of the present invention will make many more calculations than are known in systems which do not use an acceleration device in accordance with exemplary embodiments of the present invention, leaving open later decisions to be made by the motion compensation/estimation software. 
     The following is a description of an exemplary embodiment of a method useable in order to create a generic and agnostic acceleration device, offloading motion estimation and Current Picture Referencing (CPR) for a particular codec. By way of non-limiting example, implementation of an appropriate acceleration device may take place in: an ASIC [Application Specific Integrated Circuit]; an ASSP [Application Specific Standard Part]; an SOC [System on a Chip], an FPGA [Field Programable Gate Array]; in firmware; in a GPU [graphics processing unit]; or in any appropriate combination of the preceding. Implementations described in the preceding sentence may also be referred to herein as “circuitry”, without limiting the generality of the foregoing. The description will be followed by a detailed explanation of how the acceleration device overcomes issues related to each of Motion vector resolution; Motion compensation residual function; Block size being compensated; and Weighted prediction, as mentioned above. As mentioned above, motion estimation is described as one particular non-limiting example. 
     Reference is now made to  FIG. 1B , which is a simplified block diagram illustration of an application acceleration system, constructed and operative in accordance with an exemplary embodiment of the present invention. 
     In the particular non-limiting example of  FIG. 1B , the application acceleration system, generally designated  110 , comprises a video acceleration system. 
     The video acceleration system  110  comprises a video acceleration device  120 ; exemplary embodiments of the construction and operation of the video acceleration device  120  are further described herein. As described in further detail below, the video acceleration device  120  is, in exemplary embodiments, configured to produce a result map  140 . 
     The result map  140  is provided as input to a further component (often termed herein “SW”, as described above); the further component, in exemplary embodiments, comprises a motion estimation/block partitioning/rate-distortion control unit  130 . The control until 130 may be, as implied by its full name, responsible for: 
     motion estimation;
 
block partitioning; and
 
rate distortion (determining tradeoffs between bit rate and distortion, for example)
 
     In certain exemplary embodiments of the present invention, it is appreciated that optimal performance may take place when: high memory bandwidth is available; multiple queues are available for managing memory access; and virtual memory address translation is available at high performance and to multiple queues. One non-limiting example of a commercially available system which fulfills the previously-mentioned criteria for optimal performance is the ConnectX-5, commercially available from Mellanox Technologies Ltd. It is appreciated that the example of ConnextX-5 is provided as on particular example, and is not meant to be limiting; other systems may alternatively be used. 
     The operation of the system of  FIG. 1B , and particularly of the video acceleration device  120  of  FIG. 1B , is now described in more detail. 
     Input to the system: 
     In certain exemplary embodiments of the present invention, for each video frame being encoded (termed herein “target frame”), the video acceleration device  120  reads previously decoded frames (also known as reconstructed raw video), against which the target frame is being compensated; by way of particular non-limiting example, two previously decoded frames may be read. It is appreciated that, in an exemplary embodiment using CPR, the video acceleration device  120  may read/use the target frame twice, once as a target frame and once as a reference frame. In addition and optionally, a map of motion vector prediction may be provided; the map of motion vector prediction shows a center of a search area for each block. The particular example in the previous sentence is non-limiting, it being appreciated that a center of search are may be determined, including independently, for any given block. Reference is now additionally made to  FIG. 15 , which is a simplified pictorial illustration depicting an exemplary search area for motion vector prediction. In  FIG. 15 , an exemplary map (generally designated  1500 ) is shown. In the particular non-limiting example of  FIG. 15 , the center of the search area for a given block is designated  1510 . In the particular non-limiting example of  FIG. 15 , the search area comprises a plurality of search blocks  1520 , only some of which have been labeled with reference number  1520  for ease of depiction. It is appreciated that, optionally, other parameters may be configured and may help the system “tune” to a specific encoder, specifying desired quality and speed; such parameters may include, by way of non-limiting example: accuracy of sub pixel interpolation; search area size; aggregation level (maximum block size being aggregated); partitioning information (whether partitioning may be, for example, only into squares or also into rectangles); and block matching function to be used (such as, by way of non-limiting example: SAD (Sum of Absolute Difference); and SSE (Sum of Square Error)). 
     Output of the System: 
     Reference is now additionally made to  FIG. 4 , which is a simplified tabular illustration depicting an exemplary order of block encoding, intended in exemplary cases to be performed by an application acceleration system such as the application acceleration system  110  of  FIG. 1B . In certain exemplary embodiments of the present invention, the video acceleration device  120  outputs a list of the top ranked blocks, which have maximal similarity to each and every one of the blocks being encoded; for example, the current encoded frame is divided into small blocks (such as, by way of non-limiting example, 8×8 blocks). This is illustrated, including an exemplary non-limiting example of an order of block encoding, in  FIG. 4 . 
     Reference is now additionally made to  FIG. 5 , which is a simplified tabular illustration depicting an exemplary result of operations performed by an acceleration device, such as the video acceleration device  120  of  FIG. 1B , in accordance with an exemplary embodiment of the present invention. A result map  500  (which may also be termed an “acceleration vector”), shown in  FIG. 5 , is an example of the output (also termed herein a “result score board”) produced in exemplary embodiments of the present invention; the result map in  FIG. 5  is a particular non-limiting example of the result map  140  of  FIG. 1B . 
     The result map of  FIG. 5  demonstrate the flexibility which is provided to the SW when using embodiments of the acceleration device described herein, in that (by way of non-limiting example) block partitioning decisions can be carried out based on the data comprised in the result map  500  of  FIG. 5 . Thus, by way of one non-limiting example, if the SW is “naïve”, and uses the first score for every block, it will produce four 8×8 blocks, with a total residual of (5+0+0+0)=5 (see entries marked in bold underscore in the result map  500 ). 
     Alternativity, in another non-limiting example, the SW may choose to create one single 32×32 block (since there are 4 scores that has the same MV value, so that the corresponding blocks can be combined) with a residual of: (6+3+1+1)=11 (see entries marked in bold italics in the result map  500 ). 
     Similarly, the SW can choose to re-partition to bigger blocks, for example when (by way of non-limiting example) based the results of blocks: 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23 which have arrived from the video acceleration device  120  of  FIG. 1 , in order to partition to 64×64 sizes. 
     Reference is now made to  FIG. 17A , which is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, as is known in the field of video. In the system of  FIG. 17A , a plurality of target frames  1705  are input. For a given block  1710  (of one or more target frames  1705 , it being appreciated that in general the process is carried out on a plurality of target frames), a comparison operation is carried out at comparison element  1715 . The comparison operation is carried out relative to a reference block  1720 , produced/chosen by a motion estimation unit  1725 , based on a decoded picture input received from a decoded picture buffer  1730 . 
     The result of the comparison element  1715  is a residual block  1735 . The residual block  1735  undergoes a transform operation at a transform unit  1740 ; quantization at a quantizing unit  1750 ; and entropy encoding in an entropy unit  1755 . The output the system of  FIG. 17A  is a bitstream. 
     Meanwhile, quantized data from the quantizing unit  1750  is dequantized an inverse quantizing unit  1760 , and undergoes an inverse transform operation at an inverse transform unit  1765 , thus producing a decoded residual block  1770 . The decoded residual block  1770  is added to the reference block  1720  at element  1772 , with a result thereof being processed by loop filters  1775 , and then sent to the decoded picture buffer  1730 , for further processing as previously described. 
     Reference is now made to  FIG. 17B , which is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, including use of an exemplary embodiment of the acceleration system of  FIG. 1B . In the exemplary system and process of  FIG. 17B , the motion estimation unit  1725  ( FIG. 17A ) has been replaced with a block matching unit  1780 , instantiated in a video acceleration device such as the video acceleration device  120  of  FIG. 1B . Other elements of  FIG. 17B , having like numbers to elements in  FIG. 17A , may be similar thereto. 
     The block matching unit  1780  produces a result map  1782 , which may be similar to the result map  140  of  FIG. 1B , and which is sent to an RDO (rate distortion optimization unit)  1785 , whose function is to choose (in accordance with an applicable metric) a best reference block and partition, with a goal of having bit stream length at the end of the process match a target bitrate, with maximal available quality. In accordance with the above-mentioned discussion, the RDO  1785 , along with the elements which are common between  FIGS. 17A and 17B , are SW elements as explained above. 
     In order to elucidate further the above discussion of certain goals of certain exemplary embodiments of the present invention, the following describes a sense in which exemplary embodiments of an acceleration device described herein is “codec agnostic” or a “generic device” 
     Agnostic 
     (1)
 
In exemplary embodiments of the present invention, the problem of motion vector resolution described above is overcome by allowing device configuration, in the case of any particular coding standard, to (by way of one non-limiting example) limit the search to full pixels and half pixels, as appropriate for that standard. The difference in the kernel coefficient of sub pixels described above is overcome by allowing SW to configure the kernel coefficient. This coefficient does not generally change “on the fly”; even though the coefficient/coefficients are codec dependent, they are fixed for the entire video stream. It is also appreciated that video encodings may differ in motion vector resolution which is allowed in describing the bit stream; by way of non-limiting example, some may allow ¼ pixel resolution, while some may allow higher resolution (less than ¼ pixel, such as, for example, ⅛ pixel). Encodings may also differ in a way in which sub pixel samples are defined by interpolation of neighboring pixels using known and fixed coefficients; the coefficients being also termed herein “kernel”.
 
For each block, the acceleration device may produce (by way of particular non-limiting example, in the case of ¼ size pixels) sixteen sub-blocks, each of which represent different fractional motion vectors. Reference is now made to  FIG. 16 , which is a simplified pictorial illustration depicting a non-limiting example of pixel sub blocks. In  FIG. 16 , each shaded rectangle (such as, by way of non-limiting example, rectangle A1,0) represents the upper-left-hand corner of a pixel, while the nearby non-shaded rectangles (in the example of shaded rectangle A1,0, an additional fifteen rectangles (a1,0; b1,0; c1,0; d1,0; e1,0; f1,0; g1,0; h1,0; i1,0; j1,0; k1,0; n1,0; p1,0; p1,0; and r1,0), for a total of sixteen rectangles (sub-blocks). In general, in preferred embodiments of the present invention, the kernel may be configured as an input.
 
(2)
 
Different video encodings also differ in compensation, meaning that the representation of the residual block  1735  of  FIG. 17A  and  FIG. 17B , is done differently in different video encodings. In exemplary embodiments of the present invention, the estimation (which block is probably best) is separated from the compensation (how to express the difference between a given block in a reference frame and in a target frame), which in previous systems were computed together. Thus, in distinction to previous systems, in exemplary embodiments of the present invention the SW will calculate the residual (what remains after compensation), but not the estimation. In certain embodiments it may be that different score functions are implemented in the acceleration device (such as the video acceleration device  120  of  FIG. 1B ) thus allowing SW to choose one of them to be used. The following is a non-limiting list of exemplary score functions, which functions are known in the art: SAD (Sum of Absolute Difference); and SSE (Sum of Square Error).
 
(3)
 
Some encoding standards allow compensating blocks against a weighted image, meaning that a reference frame (previously decoded frame) is multiplied by a factor. (rational number). Alternatively, a sum of 2 reference frames may each be multiplied by a different weighting factor. The acceleration device, in preferred embodiments of the present invention, may either allow configuring a weighting factor for each reference frame, or may receive as input an already weighted frame.
 
     Reference is now additionally made to  FIG. 6 , which is another simplified tabular illustration depicting an exemplary result of operations performed by an acceleration device in accordance with an exemplary embodiment of the present invention. By way of non-limiting example of a score board, consider a result score board  600  as shown in  FIG. 6 ; in  FIG. 6 , bold underscore and bold italics are used similarly to their usage in  FIG. 5 . 
     “Smart SW” is able to see that two reference frames in the result score board  600  have the same MV (¼,−¼), so the smart SW can itself calculate the compensation of weighted prediction between frame 0 and frame 1, and might thus get a better result than the score board indicates. In the particular example shown, since blocks 0, 1, 2, 3, all have a given score, those blocks can be re-partitioned into one 16×16 block (this being only one particular example, which could, for example, be expandable to larger blocks). The reason for the possibility of achieving a better result is that, by separating functions between an acceleration device and SW as described herein, the SW can use the varied results provided by the acceleration device to potentially find the “bigger picture” and produce a better result. 
     Turning now to the partitioning issue as described above: 
     It is believed that the flexible acceleration device output allows the SW to do re-partitioning based on the acceleration device result, as described immediately above. 
     In certain exemplary embodiments of the present invention, the acceleration device may not necessarily stop the search when reaching a threshold; by contrast, SW algorithms generally have a minimal threshold that causes the SW to stop looking for candidates, which means (by way of non-limiting example) that if the SW found a block with a small residual in the first search try, it will terminate the search process. 
     In the particular non-limiting case described above, since the partitioning is done later in the process, and as described in the example, in order to avoid inappropriate termination, the acceleration device will complete the search and return a vector of the best results found, in order to allow the SW to do re partitioning. Re-partitioning is discussed in more detail above with reference to  FIG. 5 . 
     Aggregation Towards Larger Blocks 
     The acceleration device also, in exemplary embodiments, provides matching scores for adjacent blocks (blocks that are “upper” and “left”, by way of non-limiting example, relative to a given block) in order to allow aggregation to take place efficiently. In exemplary embodiments, the aggregation is done when adjacent blocks has the same displacement vector, with a bigger block which is aggregated to replace the adjacent blocks having a matching result which is the sum of the score of the sub blocks, since the score function is additive. 
     Avoiding Local Minimum 
     Reference is now additionally made to  FIG. 7 , which is a simplified pictorial illustration depicting a “local minimum” problem that may be encountered by an exemplary system in accordance with an exemplary embodiment of the present invention When searching on small blocks, it may happen that the search algorithm will “fall” into a local minimum, as shown in  FIG. 7 . Local minimum in this context refers to a small block which may have a very good match (even a perfect match) to a certain region, even though there may exist a match using a much bigger block. Exemplary techniques for overcoming a local minimum problem, using a plurality of block sizes to do so, are discussed below with reference to  FIG. 8 . 
     When dealing with small blocks, there is higher chance that many of the small blocks will be similar and the present invention, in exemplary embodiments thereof, will not find the entire area of a larger object. In order to overcome this problem, the acceleration device, in exemplary embodiments, performs a full and hierarchical search over the following so-called predictors: 
     Results of the collocated (the term “collocated” being known in the video art) block/s in one or more previously decoded frames. In exemplary embodiments, using such results is configured by SW. Such results may comprise a P&amp;A map, as described below.
 
Result/s from adjacent block/s, as described above.
 
The result around the global motion vector of the image (that is, the global motion vector is used as a center of a search area), using such result being configured by SW, which may be the case when SW provides such a global motion vector.
 
The result of a low resolution image search, as described below in more detail, including with reference to  FIGS. 19-21 .
 
     Low Resolution Image Search 
     Reference is now additionally made to  FIG. 8 , which is a simplified pictorial illustration depicting an operation on a low resolution image, which operation may be carried out by an exemplary system in accordance with an exemplary embodiment of the present invention. In the low resolution search technique, resolution of the image is reduced (the picture is made smaller), such as, by way of non-limiting example, by a factor of 4 in each dimension. In an exemplary embodiment, searching and motion estimation are then performed on the reduced resolution image, as shown in  FIG. 8 . In the non-limiting example of reduction by a factor of 4, in the reduced resolution image of  FIG. 8  an 8×8 block represents a 64×64 block in the original image; persons skilled in the art will appreciate that there is less noise in such a reduced resolution image than in the original image. Thus, a candidate anchor identified in the reduced resolution image will allow us to look for a larger anchor in the full-resolution partition. 
     It is appreciated that, in embodiments of the present invention, the acceleration device returns the best result of each anchor, and sometimes the second best result, and not the total ranking score. 
     Reference is now made to  FIG. 18 , which is a simplified block diagram illustration depicting a particular exemplary case of using the acceleration system of  FIG. 1B .  FIG. 18  depicts an exemplary case in which a single pass is executed in order to obtain a result; in general, whether a single pass or multiple passes are used is decided by SW. Other exemplary cases, in which more than a single pass may be executed, are described below. 
     In  FIG. 18 , the video acceleration device  120  of  FIG. 1B  is shown receiving the following inputs: 
     a first prediction and aggregation (P&amp;A) map  1810 ; 
     a second P&amp;A map  1820 , which may refer to a second reference frame (such as the second reference frame  1840  mentioned below); 
     a first reference frame  1830 ; 
     a second reference frame  1840 ; and 
     a target frame  1850 . 
     The first reference frame  1830 , second reference frame  1840 , and the target frame  1850  will be understood in light of the above discussion. 
     The first P&amp;A map  1810  and the second P&amp;A map  1820  may be similar in form to the result map  140  of  FIG. 1B , or, by way of very particular non-limiting example, to the result map  500  of  FIG. 5 . In general, the first P&amp;A map  1810  and the second P&amp;A map  1820 : 
     may be optional;
 
are provided by SW; and
 
are provided with a deliberately poor score, since it is believed that providing a poor score will lead to a better result.
 
     The video acceleration device  120  produces a result map  1860  which may be similar in form to the result map  140  of  FIG. 1B , or, by way of very particular non-limiting example, to the result map  500  of  FIG. 5 . 
     The above description of  FIG. 18  may be further elaborated on as follows. In general, one or more reference frames and one or more target frames are received as input. A plurality of P&amp;A maps may be received; by way of one particular non-limiting example, when two reference frames and two target frames are received, up to four P&amp;A maps may be received. In general, a given P&amp;A map refers to a reference frame paired with a target frame, so that if there are two reference frames and two target frames, there would be four P&amp;A maps to cover the applicable pairings. In a case where a particular P&amp;A map is blank, this may be an indication to the video acceleration device  120  to search without any additional information as to where to search. In general, a P&amp;A map provides predication and aggregation points to aid the video acceleration device  120  in searching related to each target. 
     Reference is now made to  FIG. 19 , which is a simplified block-diagram illustration depicting another particular exemplary case of using the acceleration system of  FIG. 1B .  FIG. 19  depicts an exemplary case in which a two passes executed in order to obtain a result; in general, whether a single pass or multiple passes are used is decided by SW. The two passes depicted in  FIG. 19  use downscaling, which is intended to assist in avoiding a local minimum, as described above. 
     In  FIG. 19 , a full resolution target frame  1910  and a full resolution reference frame  1920  are provided as input. Each of the full resolution target frame  1910  and the full resolution reference frame  1920  are downscaled at downscale units  1930  and  1940  respectively (which for sake of simplicity of depiction and explanation are shown as separate units, it being appreciated that alternatively a single downscale unit may be used to carry out multiple downscale operations). In the particular non-limiting example shown in  FIG. 19  the downscale units  1930  and  1940  are shown as downscaling by a factor of 1:8, but it is appreciated that the example of 1:8 is not meant to be limiting. 
     The output of the downscale unit  1930  is a downscaled target frame  1950 . The output of the downscale unit  1940  is a downscaled reference frame  1960 . The downscaled target frame  1950  and the downscaled reference frame  1960  are input into the video acceleration device  120 . Two instances of the video acceleration device  120  are shown in  FIG. 19  for ease of depiction and acceleration, it being appreciated that only a single video acceleration device  120  may be used. 
     By way of non-limiting example, an empty P&amp;A map  1965  (see description of P&amp;A maps above, with reference to  FIG. 18 ) is also input into the video acceleration device  120 . The video acceleration device  120  which receives the downscaled target frame  1950  and the downscaled reference frame  1960  produces a P&amp;A map(R)  1970 , “R” designating that the map relates to a reference frame, representing the best downscaled result found for the downscaled target frame  1950  in the downscaled reference frame  1960 . 
     Meanwhile, the full resolution target frame  1910  and the full resolution reference frame  1920  are each provide as input to the video acceleration device  120 , which also receives the P&amp;A map(R)  1970 , an which produces a second P&amp;A map(R)  1975 . It is appreciated that, when a method such as that depicted in  FIG. 19  is used, so that in addition to a full search on an entire frame a downscaled search is used, information is produced which may assist in finding larger blocks (such as, by way of non-limiting example, 64×64 blocks). This may be because, in effect, the system has “zoomed in” on each frame, so that more of each frame will be in an effective search area. 
     Reference is now made to  FIG. 20 , which is a simplified block-diagram illustration depicting still another particular exemplary case of using the acceleration system of  FIG. 1B , and to  FIG. 21 , which is a simplified block-diagram illustration depicting yet another particular exemplary case of using the acceleration system of  FIG. 1B .  FIGS. 20 and 21  will be understood with reference to the above description of  FIG. 19 .  FIG. 20  depicts a situation in which 1:4 and 1:8 downscaling are both used and are combined.  FIG. 21  depicts a situation in which both symmetrical and asymmetrical downscaling are used and combined. In general, in the situations depicted in  FIGS. 20 and 21 , the “quality” of output of the video acceleration device  120  may be improved, with little additional work expended in a few additional passes. 
     Reference is now made to  FIG. 22 , which is a simplified partly pictorial, partly block diagram illustration of an exemplary embodiment of a portion of the application acceleration system of  FIG. 1B .  FIG. 22  depicts a particular exemplary non-limiting embodiment of the video acceleration device  120  of  FIG. 1B . 
     The video acceleration device  120  of  FIG. 22  is shown receiving as input: a P&amp;A map  2210 ; a reference frame  2215 ; and a target frame  2220 . Each of the P&amp;A map  2210 , the reference frame  2215 , and the target frame  2220  may be similar to P&amp;A maps, reference frames, and target frames described above. 
     The video acceleration device  120  of  FIG. 22  comprises the following elements: 
     a result map buffer  2225 ; 
     a reference frame buffer  2230 ; 
     a target frame buffer  2235 ; 
     a block matching engine  2240 ; 
     a score board storage unit  2245 ; and 
     aggregation and ranking circuitry  2255 . 
     The result map buffer  2260  is shown as storing a map  2260 , which may be the input P&amp;A map  2210  or another map, as also described below. 
     A non-limiting example of operation of the video acceleration device  120  of  FIG. 22  is now briefly described: 
     The target frame  2220  or a relevant portion thereof (typically determined under SW control) is received by the video acceleration device  120 , and at least a relevant portion is stored in the target frame buffer  2235 . By way of a particular non limiting example, the relevant portion could comprise a current block of 8×8 pixels to be searched. 
     The reference frame  2215  or a relevant portion thereof is received by the video acceleration device  120 , and a relevant search area (which may be a search area around the current block in the target frame) is stored in the reference frame buffer  2230 . 
     The block matching engine  2240  (which may comprise a plurality of block matching engines, in order to execute more than one operation in parallel) receives current block stored in the target frame buffer  2235  and the relevant blocks stored in the reference frame buffer  2230 . The block matching engine  2240  determines a score (using, by way of non-limiting example as described above, SAD or SSE), and writes the score to the score board storage unit  2245 , producing a score board  2250 . Score boards are described above; one particular non-limiting example is the score board  500  of  FIG. 5 , described above. 
     In certain exemplary embodiments, the block matching engine  2240  may use the P&amp;A map  2210  (which may be stored in the result map buffer  2225 , or elsewhere in the video acceleration device  120 ) to “focus” score determination on blocks indicated in the P&amp;A map  2210 , and blocks in proximity to those blocks. 
     The aggregation and ranking circuitry  2255  is configured, in exemplary embodiments, to determine the best results from the score board  2250 , and also to determine large blocks by aggregation, using (by way of non-limiting example) sums of values of adjacent blocks, which blocks have the same displacement vector as a given block, in order to produce an output score board/result map  2260 . While not shown in  FIG. 22 , the output score board/result map is generally provided as output from the video acceleration device  120 , as described above. 
     Reference is now made to  FIG. 23 , which is a simplified tabular illustration depicting an exemplary result of operations performed by an acceleration device in accordance with another exemplary embodiment of the present invention. Referring back to  FIG. 5  and the description thereof,  FIG. 5  described a non-limiting example of system output which included information on a reference frame. In another exemplary embodiment, an entire table (such as, by way of a very particular non-limiting example, the table depicted in  FIG. 23 , generally designated  2300 ), may refer to a particular reference frame, it being appreciated that a plurality of tables similar to the table  2300  may be provided, one for each reference frame. Thus, in the case of the table  2300  of  FIG. 23  (by contrast to the table  500  of  FIG. 5 ), the reference motion vector (Ref MV) may comprise 2 comma-delimited numbers, comprising x and y coordinates respectively (by way of non-limiting example). 
     The following description may apply, mutatis mutandis, either to the case depicted and described with reference to the table  500  of  FIG. 5 , or to the case depicted and described with reference to the table  2300  of  FIG. 23 . 
     Referring back to  FIG. 17A , each residual block  1735  undergoes a transform operation at the transform unit  1740 . The transform operation, in exemplary embodiments, converts the input (such as each residual block  1735 ) from a spatial domain (energy per location in an image) to a frequency domain. A non-limiting example of such a transform is a discrete cosine transform (DCT). Generally, the output of such a transform is a block having the same dimensions as the input block. The top left element of such a block is called a DC element; in particular, it is known in the art of video encoding that the DC element is very close to the average of the values of intensity of pixels in the block, in the spatial domain. The other elements in the transform output are called AC elements. It is well known in the art of video compression that the human eye model is less sensitive to errors in the higher frequencies, which are the last elements of the transform output, than to lower frequencies. For this reason, the quantizing unit  1750  generally quantizes the last AC elements more than the first AC elements, and much more than the DC element. 
     It is also known in the art of video compression that residual blocks with less energy in the AC coefficients are compressed better than other residual blocks. In other words, with fewer bits in a bitstream a decoder will be able to reconstruct a block which is closer to a source signal; in this context “closer” may be, by non-limiting example, as measured by the PSNR metric, as referred to above. 
     However, when doing motion estimation, or trying to find the best block in a reference image against which to compensate, it is known in the art that doing a transform to each candidate block in order to estimate the rate distortion optimization score (RDO score) of that candidate block, is extremely compute intensive, and may in fact be practically impossible. 
     The following formula is believed to be a good estimation of the energy residing in AC coefficients (a term used interchangeably herein with “AC elements”): 
     Given a Target block T and a candidate reference block C, the energy of AC coefficients a residual block R that will be created when compensating Block T from block C is:
 
AC in R˜SAD(T,C)−|AVG(T)−AVG(C)| where:
         SAD represents Sum of Absolute Difference, as described above;   AVG represents the average of pixel values in a given block;   ˜ represents approximation; and   | | represents absolute value.       

     Reference is now made to  FIG. 24 , which is a simplified tabular illustration depicting an exemplary result of operations performed by an acceleration device in accordance with still another exemplary embodiment of the present invention. The table of  FIG. 24 , generally designated  2400 , may be similar to the table  2300  of  FIG. 23 , with the addition of a column for AC energy estimation, the values of which may be computed in accordance with the formula provided above for “AC in R”. It is appreciated that such a column may also be added mutatis mutandis, to the table  500  of  FIG. 5 . 
     Referring back to  FIG. 22 , the system of  FIG. 22 , with minor variations, may be used to produce the table of  FIG. 24 , the variations being as follows: 
     The block matching engine  2240 , in additional to determining a score (using, by way of non-limiting example as described above, SAD or SSE) as described above with reference to  FIG. 22 , also determines the AC coefficient energy using the “AC in R” formula described above. If SSE was used as a score function, as described above with reference to  FIG. 22 , then SAD in the “AC in R” formula described above is replaced by SSE. When writing the score to the score board storage unit  2245 , producing a score board  2250 , as described above with reference to  FIG. 22 , score board will include: the block number MV, SAD/SSE and AC energy. 
     Referring again to  FIG. 24 , choosing the “best” block to be compensated against, from the encoder perspective, may be accomplished as follows. The “best” block will be a block that will introduce minimal quality loss, and still meet a “bit budget”; that is, generally an encoder is supplied with a “bit budget” indicating how many bits may be used in encoding. Thus, the encoder generally maintains an accounting of bit use/quality loss. For example, the best block may be determined using a formula such as: 
       Cost=MV_cost+Residual_cost*alpha 
     where: 
     MV_cost is the number of bits that the encoder needs in order to encode a given motion vector (MV) in the bitstream; 
     Residual_cost is the cost in bits, for the encoder to encode the residual coefficient in the bitstream; referring logically to the “delta” between the 2 blocks (target Vs reference). It is appreciated that the Residual_cost depends on the SAD result and on the AC energy result, since each block is transformed, subtracted from the reference block, and then quantized. The quantization process implies that, when using low bitrates, where usually higher quantizers are used, the cost of the residuals will impact less, while the cost of bits used to represent the MV is constant. To account for differences in quantization, the alpha parameter is introduced, the alpha parameter being generally different for each quantization parameter. For higher quantizers (lower bitrates) the alpha value is smaller than it is for lower quantizers (higher bitrates). 
     The discussion immediately above implies that an acceleration device as described herein may be configured to output just the overall cost, or to rank based on the Cost function above, and thus to reduce the amount of data that the encoder needs to analyze. In order to accomplish this, the encoder (or software associated therewith) configures the alpha value or values in advance of operation, and also configures, for every frame being searched against, an average quantization parameter (QP) to the acceleration device, and an alpha value in accordance therewith. 
     Reference is now made to  FIG. 25 , which is a simplified tabular illustration depicting an exemplary result of operations performed by an acceleration device in accordance with yet another exemplary embodiment of the present invention. The table of  FIG. 25 , generally designated  2500 , may be similar to the table  2300  of  FIG. 23 , except that additional information, which may be useful in facilitating bi-directional prediction, has been added to the table  2500 , relative to the table  2300  of  FIG. 23 . 
     Bi-directional prediction is available in certain video coding standards, and allows prediction from two images; this means that each block in a target image can be compensated against two different blocks, one from each of two different images. In such a case, the acceleration device may compare each block against a block which is a weighted sum of two blocks from two different images, in order to produce the table  2500 . As is known in the art, a weighting coefficient used in computing the weighted sum is constant for a given target frame. 
     Prior to the score function as shown in table  2500  being calculated (using, by way of particular non-limiting example, SAD or SSE), an “imaginary” reference block may be assembled using the following formula: 
         RefBlock  ( i,j ))= W 0*   B 0 ( i,j )+ W 1*   B 1  ( i,j )
 
     Where W 0  and W 1  are weights (generally supplied by the encoder, and based on values in relevant video compression standards); 
     (i,j) represents a location within a given block; 
     B 0  represents a first actual block; 
     B 1  represents a second actual block; and
           RefBlock  represents the computed “imaginary” reference block.       

     It is appreciated, that, generally, W 0  and W 1  are not dependent on i and j. 
     The acceleration device may then perform cost calculations on the “imaginary” reference block (using the block matching engine  2240  of  FIG. 22 , as described above) as if the “imaginary” reference block were an ordinary reference block, but with two different displacement vectors being output to the score board. The displacement vectors may be in a separate table (in a case such as that of  FIG. 25 ), or a separate row (in a case such as that of  FIG. 5 ). 
     Exemplary embodiments of the present invention which may be useful with future codecs are now described. In such future codecs, it is believed that it will be possible to copy the content of a block from a previous encoded/decoded block. Such an ability is limited to copying data from the current processed coding tree unit (CTU) or an immediately previous CTU only. This CTU restriction simplifies intra block copy (IBC) implementation which may be useful for such future codecs, since copying from a reconstructed buffer may be problematic in some systems; and the CTU restriction eliminates the need to access a reconstructed buffer by allowing addition of a separate, relatively small, buffer for IBC purpose only. 
     Reference is now made to  FIGS. 26A and 26B , which are simplified tabular illustrations useful in understanding still another exemplary embodiment of the present invention.  FIG. 26A  shows an array of blocks, generally designated  2610 . A current block being processed  2620  is depicted, along with a plurality of “valid” possible reference blocks  2630 . 
     The inventors of the present invention believe that by relaxing the restriction of which blocks are “valid” as depicted in  FIG. 26A , efficiencies may be achieved by allowing computations to take place for future codecs using frame data already processed.  FIG. 26B  shows an array of blocks for such a case, generally designated  2640 . A current block  2650  is depicted, along with a plurality of “valid possible reference blocks  2660  and  2670 . 
     Using the acceleration device in accordance with exemplary embodiments of the present invention (in particular with reference to  FIGS. 17A and 17B , and the above explanation thereof), acceleration is based on receiving a reconstructed buffer in frame resolution, meaning that each frame can access only the previous processed reconstructed frame and can not the current reconstructed frame data. Since future codecs as described above use the reconstructed buffer of the current frame, implementation of a solution in accordance with the exemplary embodiment of  FIGS. 17A and 17B  would be difficult or perhaps impossible, since a current frame reconstructed image is generally not available during operation of the system of  FIGS. 17A and 17B   
     Reference is now made to  FIG. 27A , which is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream; and to  FIG. 27B , which is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, including use of an exemplary embodiment of the acceleration system of  FIG. 1B .  FIGS. 27A and 27B  are similar to  FIGS. 17A and 17B , respectively, and like reference numbers have been used therein. 
     Using the systems and processes of  FIGS. 27A and 27B , a motion vector (MV) search is run on the original frame rather than on the reconstructed frame. This solution can be executed prior to the encoding of the frame. A limitation of this solution may be differences between the original frame data and the reconstructed frame data, but the inventors of the present invention believe the original frame and the reconstructed frame (and hence the corresponding data) images are quite similar, especially for encoding in high bitrate. The purpose of the MV search in this case is mainly for finding the best vector rather than calculating the cost of such a vector, since it can be assumed that the best MV is the same for both the original and the reconstructed frames, while the cost itself is believed to be more affected by the difference of the frames. The “real” cost can be calculated by the encoder rather than by the systems and processes of  FIGS. 27A and 27B , and since no additional search is required the cost operation is relatively simple. 
     Additionally, in alternative exemplary embodiments of the present invention, it is appreciated that a similar concept can be used for regular MV search; by running the MV search on the original frame data rather than on reconstructed frame data it is possible to use the acceleration device on an entire video prior to the encoder running, so encoding can be more efficient and parallel implementation can be made simpler. 
     The following description covers additional exemplary embodiments. 
     I. Hardware Accelerated Intra Prediction Direction Estimation 
     1. Introduction and Problems Formulations.
         In common video coding standards (AVC, VP9, HEVC, AV1 and VVC) intra predictions for texture blocks include angular (directional) intra predictions and non-angular intra predictions. Angular intra prediction modes corresponded to an angle so that for texture prediction the data of the neighboring block pixels is propagated to the block interior at this angle. Due to the large number of possible intra prediction angles (e.g. 65 in VVC) the procedure of choosing the optimal intra prediction may become very complex and the challenge of simplifying it is important to overall encoder performance.   The technique disclosed herein implements an Intra Prediction hint for Hardware-based accelerators (GPU/FPGA/ASIC), providing universal method for optimization of Intra Prediction decisions for various block-based encoders.       

     2. Minimal Activity Direction Approach. 
     Minimal activity direction may be interpreted as the direction inside the area S in which the variation of the function is minimal. In particular, minimal activity direction of the picture area is the direction of the most noticeable boundaries and lines inside the selected area S. 
     Denote, 
     
       
         
           
             E 
             = 
             
               ( 
               
                 
                   
                     ∑ 
                     
                       
                         ( 
                         
                           x 
                           , 
                           y 
                         
                         ) 
                       
                       ∈ 
                       S 
                     
                   
                    
                   
                     
                       Dx 
                       2 
                     
                      
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                 
                 - 
                 
                   
                     ∑ 
                     
                       
                         ( 
                         
                           x 
                           , 
                           y 
                         
                         ) 
                       
                       ∈ 
                       S 
                     
                   
                    
                   
                     
                       Dy 
                       2 
                     
                      
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                 
               
               ) 
             
           
         
       
       
         
           
             F 
             = 
             
               ( 
               
                 
                   ∑ 
                   
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                     ∈ 
                     S 
                   
                 
                  
                 
                   Dx 
                    
                   
                       
                   
                    
                   
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                     · 
                     Dy 
                   
                    
                   
                       
                   
                    
                   
                     ( 
                     
                       x 
                       , 
                       y 
                     
                     ) 
                   
                 
               
               ) 
             
           
         
       
     
     Where Dx(x,y) and Dy(x,y) are the difference values between the pixels to the left and right of pixel (x,y) and between the pixels above and below pixel (x,y), accordingly.
 
The further calculations are performed according to the following four cases:
 
     Case 1: E≤0 and F&lt;0 
     Case 2: E&gt;0 and F&lt;0 
     Case 3: E≥0 and F≥0 
     Case 4: E&lt;0 and F≥0 
     Those four cases correspond to directional angles in the intervals:
         [0;π/4], [π/4,λ/2], [π/2,3π/4], [3π/4,π]   Solving the minimization problem explicitly, one can obtain the following expressions for minimal activity direction:       

     we define: 
     
       
         
           
             A 
             = 
             
               
                 
                   E 
                   2 
                 
                 
                   
                     E 
                     2 
                   
                   + 
                   
                     4 
                     · 
                     
                       F 
                       2 
                     
                   
                 
               
             
           
         
       
     
     Then, for each of the four cases we defined we have: 
       α( S )−√{square root over ((1+ A )/2)}  Case 1:
 
       α( S )=√{square root over ((1− A )/2)}  Case 2:
 
       α( S )=−√{square root over ((1− A )/2)}  Case 3:
 
       α( S )=−√{square root over ((1+ A )/2)}  Case 4:
 
     The corresponding direction angle is calculated as 
       φ=arccos(α( S ))
 
     For each case 1-4 defined above there is a one-to-one correspondence between the value of the intra prediction direction defined by the angle φ(S, W) and the value of the ratio 
     
       
         
           
             
                
               
                 E 
                 F 
               
                
             
              
             
                 
             
              
             
               
                 ( 
                 
                   or 
                    
                   
                       
                   
                    
                   
                      
                     
                       F 
                       E 
                     
                      
                   
                 
                 ) 
               
               . 
             
           
         
       
     
     That is why in practical usage the approximate calculation of the minimal activity directions and the corresponding angular intra prediction mode may be simplified significantly by using some pre-calculated tables. 
     3. Hardware and Software Algorithm Partitioning 
     The most computational extensive part can be effectively executed in hardware, while codec-dependent mapping of minimal activity direction to exact intra-direction mode should be performed on CPU. For estimation of minimal activity direction for various block sizes, it is necessary to calculate the following values: 
     
       
         
           
             Ex 
             = 
             
               ( 
               
                 
                   ∑ 
                   
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                     ∈ 
                     S 
                   
                 
                  
                 
                   
                     Dx 
                     2 
                   
                    
                   
                     ( 
                     
                       x 
                       , 
                       y 
                     
                     ) 
                   
                 
               
               ) 
             
           
         
       
       
         
           
             Ey 
             = 
             
               ( 
               
                 
                   ∑ 
                   
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                     ∈ 
                     S 
                   
                 
                  
                 
                   
                     Dy 
                     2 
                   
                    
                   
                     ( 
                     
                       x 
                       , 
                       y 
                     
                     ) 
                   
                 
               
               ) 
             
           
         
       
       
         
           
             F 
             = 
             
               ( 
               
                 
                   ∑ 
                   
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                     ∈ 
                     S 
                   
                 
                  
                 
                   Dx 
                    
                   
                       
                   
                    
                   
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                     · 
                     Dy 
                   
                    
                   
                       
                   
                    
                   
                     ( 
                     
                       x 
                       , 
                       y 
                     
                     ) 
                   
                 
               
               ) 
             
           
         
       
     
     Ex, Ey, and F should be calculated for each 8×8 block in picture, assuming 8×8 is the minimal intra-prediction block size. For bigger intra blocks, values calculated for 8×8 can be grouped using simple summation. 
     4. Practical Implementation in Hardware 
     For blocks 8×8, simplified pseudocode of HW-part for Intra direction estimation, without access to neighboring pixels, could as simple, as following: 
                                void IntraHint8×8_HW_Part(uint8_t Block[8][8], int &amp; Ex, int &amp;       Ey, int &amp; F)       {        Ex = Ey = F = 0;        for (int y = 1; y &lt; 7; y++)         for (int x = 1; x &lt; 7; x++)         {          int DX = (Block[y][x+1] − Block[y][x−1]);          int DY = (Block[y+1][x] − Block[y−1][x]);          Ex += (iDX*iDX);          Ey += (iDY*iDY);          F += (iDX*iDY);         }       }                    
For full picture processing, with boundaries handled by padding, the following code could be used:
 
                                void intra_hint_HW(int width, int height,           uchar * Src, int s/src_stride*/,           int * Dst, int d/dst_stride*/)       {        for(int y=0;y&lt;height;y+=8)        for(int x=0;x&lt;width;x+=8)        {         uchar * S = Src + y*s + x;         int * D = Dst + (y/8)*d + (x/8)*3;         int Ex = 0, Ey = 0, F = 0;         for(int Y=0; Y&lt;8; Y++,S+=s)          for(int X=0; X&lt;8; X++)          {            int DX = (S[X−1] − S[X+1]);            int DY = (S[X−s] − S[X+s]);            Ex += DX*DX;            Ey += DY*DY;            F += DX*DY;          }         D[0] = Ex; D[1] = Ey; D[2] = F;        }       }                    
Accuracy(bits) of Ex, Ey and F could be reduced, but in this case, values should be scaled accordingly.
 
     5. Codec Agnostic Hardware Assist to Software
         Modern Video standards contain intra prediction as a common idea but differ in the details. 2 major differences:
           1. The various standards allow different block partitioning   2. The various standards allow different numbers of angles to be predicted in intra coding   
           In exemplary embodiments of the present invention, note that the block partitioning problem has already been solved (see above description), based on generic and scalable 8×8 blocks, which can be aggregated to any appropriated desired partition size. The different angle is solved by the fact that we can narrow down the direction dramatically as described herein; it is then typically software which chooses the best, or a best, codec-dependent angle to use for prediction. We give here as an example, the implementation part (typically performed in software) for HEVC encoders.   The following non-limiting exemplary code illustrates an appropriate hardware implementation:       

     
       
         
           
               
             
               
                   
               
               
                 Code for HW-part of Intra-Direction Hint: 
               
               
                   
               
             
            
               
                 void IntraHint8×8_HW_Part(uint8_t Block[8][8], int 
               
               
                 iDW[3]) 
               
               
                 { 
               
               
                 for (int y = 1; y &lt; 7; y++) 
               
               
                 for (int x = 1; x &lt; 7; x++) 
               
               
                 { 
               
               
                 int iDX = (Block[y][x+1] − Block[y][x−1]); 
               
               
                 int iDY = (Block[y+1][x] − Block[y−1][x]); 
               
               
                 iDW[0] += (iDX*iDX); 
               
               
                 iDW[1] += (iDY*iDY); 
               
               
                 iDW[2] += (iDX*iDY); 
               
               
                 } 
               
               
                 } 
               
               
                   
               
            
           
         
       
     
     6. Pre-Calculated Tables for HEVC Encoder. 
     A proven implementations is HEVC encoder with up to 35 intra prediction modes. Using proposed technique and pre-calculated tables it is possible to predict Intra Direction in simple and effective way. 
     
       
         
           
               
             
               
                   
               
             
            
               
                 /* 
               
               
                   Software part of Intra Direction prediction algorithm 
               
               
                 for HEVC 
               
               
                   (will be different for various encoders) 
               
               
                   iDW[3] values (Ex = X*X, Ey = Y*Y, F = X*Y) could be 
               
               
                 pre-calculated in HW for blocks 8×8 
               
               
                   and grouped for different block sizes. 
               
               
                   (c) Beamr Imaging Ltd 2019, All Rights Reserved 
               
               
                 */ 
               
               
                 int CalcIntraDirection_HEVC(int iDW[3], int iDefaultDir = 
               
               
                 0) 
               
               
                 { 
               
               
                 if (iDW[0] + iDW[1] != 0) 
               
               
                 { 
               
               
                     int uiN1 = (int) (iDW[2] &gt;= 0 ? iDW[2] : − 
               
               
                 iDW[2]); 
               
               
                     int uiN2 = (int) ((iDW[0] − iDW[1]) &gt;= 0 ?  
               
               
                 (iDW[0] − iDW[1]) : − (iDW[0] − iDW[1])); 
               
               
                     if (uiN1 != 0 | | uiN2 != 0) 
               
               
                     { 
               
               
                      int bAQInverse = (uiN1 &gt;= uiN2); 
               
               
                      int uiAQ128 = bAQInverse ? (uiN2 * 
               
               
                 128 + uiN1 / 2) / uiN1 : 
               
               
                           (uiN1 * 
               
               
                 128 + uiN2 / 2) / uiN2; 
               
               
                      int iQAngleMult128; 
               
               
                      if ((iDW[2] &gt;= 0 &amp;&amp; iDW[0] &gt;= iDW[1]) 
               
               
                 | | (iDW[2] &lt; 0 &amp;&amp; iDW[0] &lt;= iDW[1])) 
               
               
                      { 
               
               
                        if (iDW[2] &lt; 0) // [0; 
               
               
                 pi/4] 
               
               
                      iQAngleMult128 = 
               
               
                     pAq128ToAngle128_1[bAQInverse] [uiAQ128]; 
               
               
                          else// [pi/2; 3*pi/4] 
               
               
                      iQAngleMult128 = 402 − 
               
               
                     pAq128ToAngle128_2[bAQInverse] [uiAQ128]; 
               
               
                      } 
               
               
                      else 
               
               
                      { 
               
               
                        if (iDW[2] &lt; 0) // [[pi/4; 
               
               
                 pi/2] 
               
               
                       iQAngleMult128 = 
               
               
                     pAq128ToAngle128_2[bAQInverse] [uiAQ128]; 
               
               
                         else     // [3*pi/4; 
               
               
                 Pi] 
               
               
                      iQAngleMult128 = 402 − 
               
               
                      pAq128ToAngle128_1[bAQInverse] [uiAQ12 
               
               
                      8]; 
               
               
                      } 
               
               
                      int dir = piAngle128ToMode[402 − 
               
               
                 iQAngleMult128]; // predicted direction 
               
               
                      float a_ = AandB[dir] [0]; 
               
               
                      float b_ = AandB[dir] [1]; 
               
               
                      float c2 = CalcC2(iDW[0], iDW[1], 
               
               
                 iDW[2], a_, b_); 
               
               
                      if (c2 &gt;= 3.0f) return dir; 
               
               
                     } 
               
               
                    } 
               
               
                    return iDefaultDir; // angle could not be determined 
               
               
                 } 
               
               
                 // helping functions and tables 
               
               
                 float CalcC2(int&amp; iDW[0], int&amp; iDW[1], int&amp; iDW[2], const 
               
               
                 float&amp; a, const float&amp; b) 
               
               
                 { 
               
               
                    const float B = b * b; 
               
               
                    const float A = a * a; 
               
               
                    const float C1 = B * iDW[0] − 2 * b * a * iDW[2] + A 
               
               
                 * iDW[1]; 
               
               
                    const float C2 = A * iDW[0] + 2 * b * a * iDW[2] + B 
               
               
                 * iDW[1]; 
               
               
                    return C1 / C2; 
               
               
                 } 
               
               
                 const int pAq128ToAngle128_1[2] [129] = 
               
               
                 { 
               
               
                    { 
               
               
                     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 
               
               
                 13, 14, 15, 16, 17, 18, 18, 
               
               
                     19, 20, 21, 22, 23, 24, 25, 26, 26, 27, 
               
               
                 28, 29, 30, 30, 31, 32, 33, 34, 34, 35, 
               
               
                     36, 36, 37, 38, 39, 39, 40, 41, 41, 42, 
               
               
                 42, 43, 44, 44, 45, 45, 46, 47, 47, 48, 
               
               
                     48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 
               
               
                 53, 54, 54, 54, 55, 55, 56, 56, 57, 57, 
               
               
                     57, 58, 58, 58, 59, 59, 60, 60, 60, 61, 
               
               
                 61, 61, 62, 62, 62, 63, 63, 63, 64, 64, 
               
               
                     64, 64, 65, 65, 65, 65, 66, 66, 66, 67, 
               
               
                 67, 67, 67, 68, 68, 68, 68, 68, 69, 69, 
               
               
                     69, 69, 70, 70, 70, 70, 70, 71, 71 
               
               
                    }, 
               
               
                    { 
               
               
                     101, 100, 100, 100, 100, 99, 99, 99, 99, 
               
               
                 98, 98, 98, 98, 97, 97, 97, 97, 96, 96, 96, 
               
               
                     96, 95, 95, 95, 95, 94, 94, 94, 94, 93, 
               
               
                 93, 93, 93, 92, 92, 92, 92, 91, 91, 91, 
               
               
                     91, 90, 90, 90, 90, 89, 89, 89, 89, 88, 
               
               
                 88, 88, 88, 87, 87, 87, 87, 87, 86, 86, 
               
               
                     86, 86, 85, 85, 85, 85, 84, 84, 84, 84, 
               
               
                 83, 83, 83, 83, 83, 82, 82, 82, 82, 81, 
               
               
                     81, 81, 81, 80, 80, 80, 80, 80, 79, 79, 
               
               
                 79, 79, 78, 78, 78, 78, 78, 77, 77, 77, 
               
               
                     77, 76, 76, 76, 76, 76, 75, 75, 75, 75, 
               
               
                 75, 74, 74, 74, 74, 74, 73, 73, 73, 73, 
               
               
                     72, 72, 72, 72, 72, 71, 71, 71, 71 
               
               
                    } 
               
               
                 };  
               
               
                 const int pAq128ToAngle128_2[2] [129] = 
               
               
                 { 
               
               
                    { 
               
               
                  201, 200, 199, 198, 197, 196, 195, 194, 193, 192, 191, 
               
               
                 190, 189, 188, 187, 186, 185, 184, 184, 183, 
               
               
                  182, 181, 180, 179, 178, 177, 176, 176, 175, 174, 173, 
               
               
                 172, 171, 171, 170, 169, 168, 168, 167, 166, 
               
               
                  165, 165, 164, 163, 163, 162, 161, 161, 160, 159, 159, 
               
               
                 158, 157, 157, 156, 156, 155, 154, 154, 153, 
               
               
                  153, 152, 152, 151, 151, 150, 150, 149, 149, 148, 148, 
               
               
                 147, 147, 147, 146, 146, 145, 145, 145, 144, 
               
               
                  144, 143, 143, 143, 142, 142, 141, 141, 141, 140, 140, 
               
               
                 140, 139, 139, 139, 138, 138, 138, 138, 137, 
               
               
                  137, 137, 136, 136, 136, 136, 135, 135, 135, 135, 134, 
               
               
                 134, 134, 134, 133, 133, 133, 133, 132, 132, 
               
               
                  132, 132, 131, 131, 131, 131, 131, 130, 130 
               
               
                    }, 
               
               
                    { 
               
               
                  101, 101, 101, 101, 102, 102, 102, 102, 103, 103, 103, 
               
               
                 103, 104, 104, 104, 104, 105, 105, 105, 105, 
               
               
                  106, 106, 106, 106, 107, 107, 107, 107, 108, 108, 108, 
               
               
                 108, 108, 109, 109, 109, 109, 110, 110, 110, 
               
               
                  110, 111, 111, 111, 111, 112, 112, 112, 112, 113, 113, 
               
               
                 113, 113, 114, 114, 114, 114, 115, 115, 115, 
               
               
                  115, 116, 116, 116, 116, 116, 117, 117, 117, 117, 118, 
               
               
                 118, 118, 118, 119, 119, 119, 119, 119, 120, 
               
               
                  120, 120, 120, 121, 121, 121, 121, 121, 122, 122, 122, 
               
               
                 122, 123, 123, 123, 123, 123, 124, 124, 124, 
               
               
                  124, 125, 125, 125, 125, 125, 126, 126, 126, 126, 127, 
               
               
                 127, 127, 127, 127, 128, 128, 128, 128, 128, 
               
               
                  129, 129, 129, 129, 129, 130, 130, 130, 130 
               
               
                    } 
               
               
                 }; 
               
               
                 const int piAngle128ToMode[403] = 
               
               
                 { 
               
               
                    10, 10, 10, 10, 
               
               
                    9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 
               
               
                    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
               
               
                    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
               
               
                    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
               
               
                    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 
               
               
                    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
               
               
                    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
               
               
                    2, 2, 2, 2, 2, 2, 
               
               
                    34, 34, 34, 34, 34, 34, 34, 34, 
               
               
                    33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 
               
               
                    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 
               
               
                    31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 
               
               
                    30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 
               
               
                    29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
               
               
                 29, 29, 
               
               
                    28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
               
               
                 28, 
               
               
                    27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 
               
               
                    26, 26, 26, 26, 26, 26, 26, 26, 
               
               
                    25, 25, 25, 25, 25, 25, 25, 25, 25, 
               
               
                    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
               
               
                 24, 
               
               
                    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 
               
               
                 23, 23, 
               
               
                    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 
               
               
                 22, 
               
               
                    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 
               
               
                    20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 
               
               
                    19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 
               
               
                    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 
               
               
                 18, 
               
               
                    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
               
               
                    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
               
               
                    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
               
               
                    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
               
               
                    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
               
               
                 13, 13, 
               
               
                    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 
               
               
                 12, 
               
               
                    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 
               
               
                    10, 10, 10, 10 
               
               
                 }; 
               
               
                 const float AandB[35] [2] = // [i] − dir angle [0] − a 
               
               
                 [1] − b 
               
               
                 { 
               
               
                    {0.f, 0.f}, 
               
               
                    {0.f, 0.f}, 
               
               
                    { 0.707f, −0.707f },   // dir 2 
               
               
                    { 0.776f, −0.631f },   // dir 3 
               
               
                    { 0.836f, −0.549f },   // dir 4 
               
               
                    { 0.883f, −0.469f },   // dir 5 
               
               
                    { 0.926f, −0.376f },   // dir 6 
               
               
                    { 0.963f, −0.271f },   // dir 7 
               
               
                    { 0.988f, −0.154f },   // dir 8 
               
               
                    { 0.998f, −0.062f },   // dir 9 
               
               
                    { 1.000f, 0.000f },    // dir 10 
               
               
                    { 0.998f, 0.062f },    // dir 11 
               
               
                    { 0.988f, 0.154f },    // dir 12 
               
               
                    { 0.963f, 0.271f },    // dir 13 
               
               
                    { 0.926f, 0.376f },    // dir 14 
               
               
                    { 0.883f, 0.469f },    // dir 15 
               
               
                    { 0.836f, 0.549f },    // dir 16 
               
               
                    { 0.776f, 0.631f },    // dir 17 
               
               
                    { 0.707f, 0.707f },    // dir 18 
               
               
                    { 0.631f, 0.776f },    // dir 19 
               
               
                    { 0.549f, 0.836f },    // dir 20 
               
               
                    { 0.469f, 0.883f },    // dir 21 
               
               
                    { 0.376f, 0.926f },    // dir 22 
               
               
                    { 0.271f, 0.963f },    // dir 23 
               
               
                    { 0.154f, 0.988f },    // dir 24 
               
               
                    { 0.062f, 0.998f },    // dir 25 
               
               
                    { −0.000f, 1.000f },   // dir 26 
               
               
                    { −0.062f, 0.998f },   // dir 27 
               
               
                    { −0.154f, 0.988f },   // dir 28 
               
               
                    { −0.271f, 0.963f },   // dir 29 
               
               
                    { −0.376f, 0.926f },   // dir 30 
               
               
                    { −0.469f, 0.883f },   // dir 31 
               
               
                    { −0.549f, 0.836f },   // dir 32 
               
               
                    { −0.631f, 0.776f },   // dir 33 
               
               
                    { −0.707f, 0.707f },   // dir 34 
               
               
                 }; 
               
               
                   
               
            
           
         
       
     
     II. Hardware Accelerated Intra Mode Hint 
     1. Introduction
         In common video coding standards (AVC, VP9, HEVC, AV1 and VVC), blocks in non intra frames may be coded in either inter mode—using reconstructed pixels from previously encoded frames as reference, or in intra mode, using reconstructed pixels from previously encoded pixels in the current frame as reference. The supported prediction modes differ somewhat between different encoders, but similar principles are applied. In a specific encoder implementation, it is up to the encoder to make the best decisions, in a rate-distortion sense, as to which coding mode should be selected for each coding block.   In order to make this decision the encoder must evaluate how well a specific prediction mode applies to the coding block, usually measuring the rate, or number of bits associated with encoding in a candidate mode, and the distortion of this candidate mode as represented the residual or error of the prediction.   Performing these evaluations in software can be very time consuming and therefore we propose a joint HW/SW solution where the expensive “generic” computations are performed in HW, resulting in “intra hint” information, and this information is used by the SW to make the decision on prediction mode for the block, where this is an encoder specific decision and may differ according to specific encoder implementations.       

     2. Proposed Algorithm
         While it is theoretically possible to perform an exhaustive search over all possible prediction modes for both intra and inter modes, calculating actual cost values for each mode, and selecting the mode with the lowest cost, this is very compute intense and not relevant at reasonable encoding speeds.   Therefore, we propose to efficiently find an intra prediction cost, as described below. Then, according to a relation between this intra cost value and the best inter prediction cost, found by the motion estimation module, it will be determined whether the block will be encoded in inter or intra mode.   The intra prediction cost is measured as a difference between the coding block pixels and the predicted block pixel values, obtained by predicting the block from previously encoded and reconstructed pixels in one of the intra prediction modes employed by the encoder in use. The difference is calculated using for example Sum of Absolute Differences (SAD), Sum of Squared Differences (SSD) or Sum of Absolute Transformed Differences (SATD)—which often employs the well-known Hadamard transform and thus is also labeled herein as Hadamard Absolute Difference or HAD.   The prediction used to calculate the difference may be only a simple DC prediction, where the average value of the neighboring reconstructed pixels is taken as the prediction value for all pixels in the encoding block. It may use Planar prediction, where a linear “plane” function is fitted to the neighboring pixels.  FIG. 35  illustrates an example of these two prediction modes, depicting both DC intra prediction (on the left side thereof) and Planar intra prediction (on the right side thereof).   To obtain a more accurate intra cost, it is possible to further calculate the cost associated with more sophisticated angular predictions, but this comes at the price of more required calculations which may not be justified for the benefit provided by this.   For a SW/HW solution, which can be generically applied to many different encoding standards or implementations, we propose to calculate the intra cost in HW, for either only the DC prediction, or only for the Planar prediction or for both. The SW will receive this value form the HW and compare it to the Inter cost previously obtained in the motion estimation—optionally using the hybrid HW/SW module, and determine if the block should be coded in inter or intra mode.       

     3. Examples of Implementation 
     Below are provided implementation examples of the DC and planar prediction functions, as well as implementations of some possible cost or difference functions to use—as described above.
 
While we have SW implementations covering also angular costs, as this is quite coded dependent, it seems less advisable to implement these in HW.
 
     1. DC Prediction 
     
       
         
           
               
             
               
                   
               
             
            
               
                 uint16_t ASMCALL vpaIntraHintDC(uint8_t * 0, int stride, 
               
               
                 uint8_t* pdirection, void* cost_func) 
               
               
                 { 
               
               
                  vpaCost16×16_8b_f* cost16×16_8b_func = 
               
               
                 (vpaCost16×16_8b_f*)cost_func; 
               
               
                  unsigned int DC = 0; 
               
               
                  uint8_t pred[16]; //creating memory of one line of  
               
               
                 prediction 
               
               
                  for(int i=0;i&lt;16;i++) 
               
               
                   DC += O[i-stride] + O[i*stride−1]; //calculate DC 
               
               
                 as average of outer left line and outer top line 
               
               
                  for (int i = 0; i &lt; 16; i++) 
               
               
                   pred[i] = (DC &gt;&gt; 5); 
               
               
                  *pdirection = 1; 
               
               
                  return cost16×16_8b_func(O, stride, (uint8_t*)pred, 
               
               
                 0); //as all lines are same we pass only one line with 0 
               
               
                 stride; 
               
               
                 } 
               
               
                   
               
            
           
         
       
     
     2. Planar Prediction 
     
       
         
           
               
             
               
                   
               
             
            
               
                 uint16_t ASMCALL vpaIntraHintPlanarCost(uint8_t * O, int 
               
               
                 stride, uint8_t* pdirection, void* cost_func) 
               
               
                 { 
               
               
                  vpaCost16x16_8b_f* cost16×16_8b_func = 
               
               
                 (vpaCost16x16_8b_f*)cost_func; 
               
               
                  uint8_t * src = 0; 
               
               
                  uint8_t * top = &amp;src[−stride]; 
               
               
                  uint8_t pred[16 * 16]; 
               
               
                  uint8_t * dst = pred; 
               
               
                  for (int32_t i = 0; i &lt; 16; i++, src += stride, dst 
               
               
                 += 16) 
               
               
                   for (int32_t j = 0; j &lt; 16; j++) 
               
               
                    dst[j] = ((src[−1] + top[j] + 1) &gt;&gt; 1); 
               
               
                 //simplified planar prediction = average of outer top 
               
               
                 line and outer left column 
               
               
                  src = 0; 
               
               
                  *pdirection = 0; //prediction type used as output; 
               
               
                  return cost16×16_8b_func(pred, 16, src, stride); 
               
               
                 //calculating cost value 
               
               
                 } 
               
               
                   
               
            
           
         
       
     
     3. SAD Cost Function 
     
       
         
           
               
             
               
                   
               
             
            
               
                 uint32_t xCalcSAD16×16_8b( const uint8_t* pi0, int32_t  
               
               
                 iStride0, const uint8_t* pi1, int32_t iStride1) 
               
               
                 { 
               
               
                  int j, k; 
               
               
                  int sad = 0; 
               
               
                  for (k = 0; k &lt; 16; k++, pi0+=iStride0, 
               
               
                 pi1+=iStride1) 
               
               
                  { 
               
               
                   for (j = 0; j &lt; 16; j++) 
               
               
                   { 
               
               
                    sad+=abs((int)pi0[j] − (int)pi1[j]); 
               
               
                   } 
               
               
                  } 
               
               
                  return sad; 
               
               
                 } 
               
               
                   
               
            
           
         
       
     
     4. HAD 8×8 Cost Function 
     
       
         
           
               
             
               
                   
               
             
            
               
                 static uint32_t xCalcHAD8×8_8b( const uint8_t *piOrg, 
               
               
                 int32_t iStrideOrg, const uint8_t *piCur, int32_t  
               
               
                 iStrideCur) 
               
               
                 { 
               
               
                  int32_t iStep = 1; 
               
               
                  int32_t k, i, j, jj, sad=0; 
               
               
                  int32_t diff[64], m1[8] [8], m2[8] [8], m3[8] [8]; 
               
               
                  int32_t iStep2 = iStep&lt;&lt;1; 
               
               
                  int32_t iStep3 = iStep2 + iStep; 
               
               
                  int32_t iStep4 = iStep3 + iStep; 
               
               
                  int32_t iStep5 = iStep4 + iStep; 
               
               
                  int32_t iStep6 = iStep5 + iStep; 
               
               
                  int32_t iStep7 = iStep6 + iStep; 
               
               
                  for( k = 0; k &lt; 64; k+=8 ) 
               
               
                  { 
               
               
                   diff[k+0] = (int)piOrg[0] − (int)piCur[  0]; 
               
               
                   diff[k+1] = (int)piOrg[1] − (int)piCur[iStep ]; 
               
               
                   diff[k+2] = (int)piOrg[2] − (int)piCur[iStep2]; 
               
               
                   diff[k+3] = (int)piOrg[3] − (int)piCur[iStep3]; 
               
               
                   diff[k+4] = (int)piOrg[4] − (int)piCur[iStep4]; 
               
               
                   diff[k+5] = (int)piOrg[5] − (int)piCur[iStep5]; 
               
               
                   diff[k+6] = (int)piOrg[6] − (int)piCur[iStep6]; 
               
               
                   diff[k+7] = (int)piOrg[7] − (int)piCur[iStep7]; 
               
               
                   piCur += iStrideCur; 
               
               
                   piOrg += iStrideOrg; 
               
               
                  } 
               
               
                  / /horizontal 
               
               
                  for (j=0; j &lt; 8; j++) 
               
               
                  { 
               
               
                   jj = j &lt;&lt; 3; 
               
               
                   m2[j] [0] = diff[jj ] + diff[jj+4]; 
               
               
                   m2[j] [1] = diff[jj+1] + diff[jj+5]; 
               
               
                   m2[j] [2] = diff[jj+2] + diff[jj+6]; 
               
               
                   m2[j] [3] = diff[jj+3] + diff[jj+7]; 
               
               
                   m2[j] [4] = diff[jj ] − diff[jj+4]; 
               
               
                   m2[j] [5] = diff[jj+1] − diff[jj+5]; 
               
               
                   m2[j] [6] = diff[jj+2] − diff[jj+6]; 
               
               
                   m2[j] [7] = diff[jj+3] − diff[jj+7]; 
               
               
                   m1[j] [0] = m2[j] [0] + m2[j] [2]; 
               
               
                   m1[j] [1] = m2[j] [1] + m2[j] [3]; 
               
               
                   m1[j] [2] = m2[j] [0] − m2[j] [2]; 
               
               
                   m1[j] [3] = m2[j] [1] − m2[j] [3]; 
               
               
                   m1[j] [4] = m2[j] [4] + m2[j] [6]; 
               
               
                   m1[j] [5] = m2[j] [5] + m2[j] [7]; 
               
               
                   m1[j] [6] = m2[j] [4] − m2[j] [6]; 
               
               
                   m1[j] [7] = m2[j] [5] − m2[j] [7]; 
               
               
                   m2[j] [0] = m1[j] [0] + m1[j] [1]; 
               
               
                   m2[j] [1] = m1[j] [0] − m1[j] [1]; 
               
               
                   m2[j] [2] = m1[j] [2] + m1[j] [3]; 
               
               
                   m2[j] [3] = m1[j] [2] − m1[j] [3]; 
               
               
                   m2[j] [4] = m1[j] [4] + m1[j] [5]; 
               
               
                   m2[j] [5] = m1[j] [4] − m1[j] [5]; 
               
               
                   m2[j] [6] = m1[j] [6] + m1[j] [7]; 
               
               
                   m2[j] [7] = m1[j] [6] − m1[j] [7]; 
               
               
                  } 
               
               
                  / /vertical 
               
               
                  for (i=0; i &lt; 8; i++) 
               
               
                  { 
               
               
                   m3[0] [i] = m2[0] [i] + m2[4] [i]; 
               
               
                   m3[1] [i] = m2[1] [i] + m2[5] [i]; 
               
               
                   m3[2] [i] = m2[2] [i] + m2[6] [i]; 
               
               
                   m3[3] [i] = m2[3] [i] + m2[7] [i]; 
               
               
                   m3[4] [i] = m2[0] [i] − m2[4] [i]; 
               
               
                   m3[5] [i] = m2[1] [i] − m2[5] [i]; 
               
               
                   m3[6] [i] = m2[2] [i] − m2[6] [i]; 
               
               
                   m3[7] [i] = m2[3] [i] − m2[7] [i]; 
               
               
                   m1[0] [i] = m3[0] [i] + m3[2] [i]; 
               
               
                   m1[1] [i] = m3[1] [i] + m3[3] [i]; 
               
               
                   m1[2] [i] = m3[0] [i] − m3[2] [i]; 
               
               
                   m1[3] [i] = m3[1] [i] − m3[3] [i]; 
               
               
                   m1[4] [i] = m3[4] [i] + m3[6] [i]; 
               
               
                   m1[5] [i] = m3[5] [i] + m3[7] [i]; 
               
               
                   m1[6] [i] = m3[4] [i] − m3[6] [i]; 
               
               
                   m1[7] [i] = m3[5] [i] − m3[7] [i]; 
               
               
                   m2[0] [i] = m1[0] [i] + m1[1] [i]; 
               
               
                   m2[1] [i] = m1[0] [i] − m1[1] [i]; 
               
               
                   m2[2] [i] = m1[2] [i] + m1[3] [i]; 
               
               
                   m2[3] [i] = m1[2] [i] − m1[3] [i]; 
               
               
                   m2[4] [i] = m1[4] [i] + m1[5] [i]; 
               
               
                   m2[5] [i] = m1[4] [i] − m1[5] [i]; 
               
               
                   m2[6] [i] = m1[6] [i] + m1[7] [i]; 
               
               
                   m2[7] [i] = m1[6] [i] − m1[7] [i]; 
               
               
                  } 
               
               
                  for (j=0; j &lt; 8; j++) 
               
               
                  { 
               
               
                   for (i=0; i &lt; 8; i++) 
               
               
                    sad += (abs(m2[j] [i])); 
               
               
                  } 
               
               
                  sad= ( (sad+2) &gt;&gt;2) ; 
               
               
                  return sad; 
               
               
                 } 
               
               
                   
               
            
           
         
       
     
     5. Codec Agnostic
         In exemplary embodiments of the present invention, the above-mentioned methods are “codec-agnostic”, in that the compute intensive part is executed in hardware, while the codec-specific and less intensive part generally remains in software. Thus, a hardware accelerator is provided which can generally assist any encoder for any codec. This can be provided in addition to the system described above.       

     Reference is now made to  FIG. 28 , which is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, including use of an exemplary embodiment of the acceleration system of  FIG. 1B .  FIG. 28 , which is identical to  FIG. 27B , is brought to show motion estimation. 
     Reference is now made to  FIG. 29  is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, including direction estimation and including use of an exemplary embodiment of the acceleration system of  FIG. 1B . 
     Reference is now made to  FIG. 30 , which is a simplified partly pictorial, partly block-diagram illustration depicting an exemplary system and process, including motion estimation, for producing a bitstream, including direction estimation and inter-prediction hint, and including use of an exemplary embodiment of the acceleration system of  FIG. 1B . In  FIG. 30 , those blocks which produce output with a dashed line ( 3010 ,  3020 ,  3030 ) are typically instantiated in hardware, as described herein. It is appreciated that, in general, only if the intra-prediction hint coming from block  3010  causes the intra-estimation-block  3020  to decide that intra-prediction should be performed, then intra-prediction is performed in block  3040  (which is typically instantiated in hardware), as described herein. 
     Reference is now made to  FIGS. 31-34 , which depict video frame encoding under various scenarios. In each case, an operation timeline is shown from left to right, and a legend depicting various tasks is included. 
       FIG. 31  depicts a typical case of software-based encoding. 
       FIG. 32  depicts a case in which hardware is used for task acceleration; in  FIG. 32 , the acceleration takes place separately for each block to be encoded. The “gaps” (such as  3210 ,  3220 ,  3230 , and  3240 ) depict communication time between hardware and software components. 
       FIG. 33  depicts a case in which the “gaps” (such as  3310 ,  3320 ,  3330 , and  3340 ) depicting communications time take a longer portion of the total time, as more operations are relegated to software; ultimately, such a strategy is thus limited by communication time between hardware and software components. 
       FIG. 34  depicts a case in which motion search (as described herein above) takes place for an entire frame, so that the relevant “gaps” (such as  3410  and  3420 ) take up a much smaller portion of the total time, so that communications time between hardware and software components is no longer limiting. 
     In certain exemplary embodiments of the present invention, the hardware combines results obtained for 8×8-blocks into larger dimension blocks. In such a case the software will receive from the hardware several filled arrays (instead of one value for 8×8 only). This will help the software make decisions and improve the quality of intra-hit on edges and will eliminate calculation of additional sums in software (for example, for 128×128, 64×64, 32×32 and 16×16) blocks, returning precalculated sums of (iDXX,iDYY,iDXY). As an example, for 4096×2176 (padded) input frame, hardware may return a 512×272 array, containing the values for 8×8 intra-directions estimation. With grouping as described, hardware will return a 256×136 array for 16×16, 128×68 (for 32×32), 64×34 (for 64×46) and 32×17 (for 128×128), which will make checking intra-hints faster and more accurate. 
     Certain techniques relevant to the present disclosure have previously been described in U.S. Pat. No. 9,451,266. 
     It is appreciated that software components of the present invention may, if desired, be implemented in ROM (read only memory) form. The software components may, generally, be implemented in hardware, if desired, using conventional techniques. It is further appreciated that the software components may be instantiated, for example: as a computer program product or on a tangible medium. In some cases, it may be possible to instantiate the software components as a signal interpretable by an appropriate computer, although such an instantiation may be excluded in certain embodiments of the present invention. 
     It is appreciated that various features of the invention which are, for clarity, described in the contexts of separate embodiments may also be provided in combination in a single embodiment. Conversely, various features of the invention which are, for brevity, described in the context of a single embodiment may also be provided separately or in any suitable subcombination. 
     It will be appreciated by persons skilled in the art that the present invention is not limited by what has been particularly shown and described hereinabove. Rather the scope of the invention is defined by the appended claims and equivalents thereof: