img_errdif_bin.h

TMS320C64x Image／Video Processing Library (V1.04)

/*            //  Step through pixels in each row.                      //  */
/*            // ------------------------------------------------------ //  */
/*            for (x = 0; x < cols; x++, i++)                               */
/*            {                                                             */
/*               // --------------------------------------------------- //  */
/*               //  Load the error being propagated from pixel 'C'     //  */
/*               //  from our error buffer.  This was calculated        //  */
/*               //  during the previous line.                          //  */
/*               // --------------------------------------------------- //  */
/*               errC = err_buf[x+1];                                       */
/*                                                                          */
/*               // --------------------------------------------------- //  */
/*               //  Load our pixel value to quantize.                  //  */
/*               // --------------------------------------------------- //  */
/*               F = errdif_data[i];                                        */
/*                                                                          */
/*               // --------------------------------------------------- //  */
/*               //  Calculate our resulting pixel.  If we assume       //  */
/*               //  that this pixel will be set to zero, this also     //  */
/*               //  doubles as our error term.                         //  */
/*               // --------------------------------------------------- //  */
/*               errF = F + ((errE*7 + errA + errB*5 + errC*3) >> 4);       */
/*                                                                          */
/*               // --------------------------------------------------- //  */
/*               //  Set pixels that are larger than the threshold to   //  */
/*               //  255, and pixels that are smaller than the          //  */
/*               //  threshold to 0.                                    //  */
/*               // --------------------------------------------------- //  */
/*               if (errF > thresh)  errdif_data[i] = 0xFF;                 */
/*               else                errdif_data[i] = 0;                    */
/*                                                                          */
/*               // --------------------------------------------------- //  */
/*               //  If the pixel was larger than the threshold, then   //  */
/*               //  we need subtract 255 from our error.  In any       //  */
/*               //  case, store the error to the error buffer.         //  */
/*               // --------------------------------------------------- //  */
/*               if (errF > thresh)  err_buf[x] = errF = errF - 0xFF;       */
/*               else                err_buf[x] = errF;                     */
/*                                                                          */
/*               // --------------------------------------------------- //  */
/*               //  Propagate error terms for the next pixel.          //  */
/*               // --------------------------------------------------- //  */
/*               errE = errF;                                               */
/*               errA = errB;                                               */
/*               errB = errC;                                               */
/*            }                                                             */
/*         }                                                                */
/*      }                                                                   */
/*                                                                          */
/*  TECHNIQUES                                                              */
/*      Constants, 7, 5, 3, 1 for multiplication are shifted left 12 to     */
/*      avoid 'SHR 4' operation in the critical path.                       */
/*                                                                          */
/*      The processing of the filter itself is inverted so that the         */
/*      errors from previous pixels "propagate into" a given pixel at       */
/*      the time the pixel is processed, rather than "accumulate into"      */
/*      a pixel as its neighbors are processed.  This allows us to          */
/*      keep our image as an 8-bit image, and reduces the number of         */
/*      accesses to the image array.  The inverted filter kernel            */
/*      performs identically to the kernel's original form.  In this        */
/*      form, the weights specify the weighting assigned to the errors      */
/*      coming from the neighboring pixels.                                 */
/*                                                                          */
/*                          +---+---+---+                                   */
/*                          | 1 | 5 | 3 |                                   */
/*                          +---+---+---+                                   */
/*                          | 7 | P                                         */
/*                          +---+                                           */
/*                                                                          */
/*      The inner loop is software-pipelined.                               */
/*                                                                          */
/*      The outer loop has been interleaved with the prolog and epilog      */
/*      of the inner loop.                                                  */
/*                                                                          */
/*  ASSUMPTIONS                                                             */
/*      The number of columns must be at least 2.                           */
/*                                                                          */
/*      err_buf[] must be initialized to zeros for the first call and       */
/*      the returned err_buf should be provided for the next call.          */
/*                                                                          */
/*  MEMORY NOTE                                                             */
/*      No bank conflicts occur, regardless of the relative orientation     */
/*      of errdif_data[] and err_buf[].                                     */
/*                                                                          */
/*  NOTES                                                                   */
/*      This function is Endian neutral.                                    */
/*      This function is interruptible.                                     */
/*      Max interrupt delay is 4*cols + 9 cycles.                           */
/*      No checking is performed on the input arguments for correctness.    */
/*      No special alignment of data arrays is expected.                    */
/*                                                                          */
/*  CYCLES                                                                  */
/*      cycles = (4*cols + 11)*rows + 5                                     */
/*                                                                          */
/*      For an image of cols = 720, rows = 480, cycles = 1,387,687          */
/*                                                                          */
/*  CODESIZE                                                                */
/*      276 Bytes                                                           */
/*                                                                          */
/*  SOURCE                                                                  */
/*      Floyd-Steinberg Error Diffusion.                                    */
/*                                                                          */
/* ------------------------------------------------------------------------ */
/*            Copyright (c) 2003 Texas Instruments, Incorporated.           */
/*                           All Rights Reserved.                           */
/* ======================================================================== */
#ifndef IMG_ERRDIF_BIN_H_
#define IMG_ERRDIF_BIN_H_ 1

void IMG_errdif_bin
(
    unsigned char *restrict errdif_data,
    int           cols,
    int           rows,
    short         *restrict err_buf,
    unsigned char thresh
);

#endif
/* ======================================================================== */
/*  End of file:  img_errdif_bin.h                                          */
/* ------------------------------------------------------------------------ */
/*            Copyright (c) 2003 Texas Instruments, Incorporated.           */
/*                           All Rights Reserved.                           */
/* ======================================================================== */