home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: Multimed / Multimed.zip / mpegplay.zip / ORDERED.C < prev    next >
C/C++ Source or Header  |  1994-02-16  |  8KB  |  288 lines
  1. /*
  2.  * Copyright (c) 1992 The Regents of the University of California.
  3.  * All rights reserved.
  4.  * 
  5.  * Permission to use, copy, modify, and distribute this software and its
  6.  * documentation for any purpose, without fee, and without written agreement is
  7.  * hereby granted, provided that the above copyright notice and the following
  8.  * two paragraphs appear in all copies of this software.
  9.  * 
  10.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  11.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  12.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  13.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  * 
  15.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  16.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  17.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  18.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  19.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  20.  */
  21. /* This file contains C code to implement an ordered dither. */
  22.  
  23. #include "video.h"
  24. #include "proto.h"
  25. #include "dither.h"
  26.  
  27. #define DITH_SIZE 16
  28.  
  29.  
  30. /* Structures used to implement hybrid ordered dither/floyd-steinberg
  31.    dither algorithm.
  32. */
  33.  
  34. static unsigned char *l_darrays[DITH_SIZE];
  35. static unsigned char *cr_darrays[DITH_SIZE];
  36. static unsigned char *cb_darrays[DITH_SIZE];
  37.  
  38. /*
  39.  *--------------------------------------------------------------
  40.  *
  41.  *  InitOrderedDither--
  42.  *
  43.  *    Structures intialized for ordered dithering. 
  44.  *
  45.  * Results:
  46.  *    None.
  47.  *
  48.  * Side effects:
  49.  *      None.
  50.  *
  51.  *--------------------------------------------------------------
  52.  */
  53.  
  54. void
  55. InitOrderedDither()
  56. {
  57.   int i, j, k, err_range, threshval;
  58.   unsigned char *lmark, *cmark;
  59.  
  60.   for (i=0; i<DITH_SIZE; i++) {
  61.     lmark = l_darrays[i] = (unsigned char *) malloc(256);
  62.  
  63.     for (j=0; j<lum_values[0]; j++) {
  64.       *lmark++ = 0;
  65.     }
  66.  
  67.     for (j=0; j<(LUM_RANGE-1); j++) {
  68.       err_range = lum_values[j+1] - lum_values[j];
  69.       threshval = ((i * err_range) / DITH_SIZE)+lum_values[j];
  70.  
  71.       for (k=lum_values[j]; k<lum_values[j+1]; k++) {
  72.     if (k > threshval) *lmark++ = ((j+1) * (CR_RANGE * CB_RANGE));
  73.     else *lmark++ = (j * (CR_RANGE * CB_RANGE));
  74.       }
  75.     }
  76.  
  77.     for (j=lum_values[LUM_RANGE-1]; j<256; j++) {
  78.       *lmark++ = (LUM_RANGE-1)*(CR_RANGE * CB_RANGE);
  79.     }
  80.   }
  81.  
  82.   for (i=0; i<DITH_SIZE; i++) {
  83.     cmark = cr_darrays[i] = (unsigned char *) malloc(256);
  84.  
  85.     for (j=0; j<cr_values[0]; j++) {
  86.       *cmark++ = 0;
  87.     }
  88.  
  89.     for (j=0; j<(CR_RANGE-1); j++) {
  90.       err_range = cr_values[j+1] - cr_values[j];
  91.       threshval = ((i * err_range) / DITH_SIZE)+cr_values[j];
  92.  
  93.       for (k=cr_values[j]; k<cr_values[j+1]; k++) {
  94.     if (k > threshval) *cmark++ = ((j+1) * CB_RANGE);
  95.     else *cmark++ = (j * CB_RANGE);
  96.       }
  97.     }
  98.  
  99.     for (j=cr_values[CR_RANGE-1]; j<256; j++) {
  100.       *cmark++ = (CR_RANGE-1)*(CB_RANGE);
  101.     }
  102.   }
  103.  
  104.   for (i=0; i<DITH_SIZE; i++) {
  105.     cmark = cb_darrays[i] = (unsigned char *) malloc(256);
  106.  
  107.     for (j=0; j<cb_values[0]; j++) {
  108.       *cmark++ = 0;
  109.     }
  110.  
  111.     for (j=0; j<(CB_RANGE-1); j++) {
  112.       err_range = cb_values[j+1] - cb_values[j];
  113.       threshval = ((i * err_range) / DITH_SIZE)+cb_values[j];
  114.  
  115.       for (k=cb_values[j]; k<cb_values[j+1]; k++) {
  116.     if (k > threshval) *cmark++ = j+1;
  117.     else *cmark++ = j;
  118.       }
  119.     }
  120.  
  121.     for (j=cb_values[CB_RANGE-1]; j<256; j++) {
  122.       *cmark++ = CB_RANGE-1;
  123.     }
  124.   }
  125. }
  126.  
  127. /*
  128.  *--------------------------------------------------------------
  129.  *
  130.  * OrderedDitherImage --
  131.  *
  132.  *    Dithers an image using an ordered dither.
  133.  *    Assumptions made:
  134.  *      1) The color space is allocated y:cr:cb = 8:4:4
  135.  *      2) The spatial resolution of y:cr:cb is 4:1:1
  136.  *      The channels are dithered based on the standard
  137.  *      ordered dither pattern for a 4x4 area. 
  138.  *
  139.  * Results:
  140.  *    None.
  141.  *
  142.  * Side effects:
  143.  *    None.
  144.  *
  145.  *--------------------------------------------------------------
  146.  */
  147.  
  148. void
  149. OrderedDitherImage (lum, cr, cb, out, h, w)
  150.     unsigned char *lum;
  151.     unsigned char *cr;
  152.     unsigned char *cb;
  153.     unsigned char *out;
  154.     int w, h;
  155. {
  156.   unsigned char *l, *r, *b, *o1, *o2;
  157.   unsigned char *l2;
  158.   unsigned char L, R, B;
  159.   int i, j;
  160.  
  161.   l = lum;
  162.   l2 = lum+w;
  163.   r = cr;
  164.   b = cb;
  165.   o1 = out;
  166.   o2 = out+w;
  167.  
  168.   for (i=0; i<h; i+=4) {
  169.  
  170.     for (j=0; j<w; j+=8) {
  171.  
  172.       R = r[0]; B = b[0];
  173.  
  174.       L = l[0];
  175.       o1[0] = PIXEL((l_darrays[0][L] + cr_darrays[0][R] + cb_darrays[0][B]));
  176.       L = l[1];
  177.       o1[1] = PIXEL((l_darrays[8][L] + cr_darrays[8][R] + cb_darrays[8][B]));
  178.       L = l2[0];
  179.       o2[0] = PIXEL((l_darrays[12][L] + cr_darrays[12][R] + cb_darrays[12][B]));
  180.       L = l2[1];
  181.       o2[1] = PIXEL((l_darrays[4][L] + cr_darrays[4][R] + cb_darrays[4][B]));
  182.  
  183.       R = r[1]; B = b[1];
  184.  
  185.       L = l[2];
  186.       o1[2] = PIXEL((l_darrays[2][L] + cr_darrays[2][R] + cb_darrays[2][B]));
  187.       L = l[3];
  188.       o1[3] = PIXEL((l_darrays[10][L] + cr_darrays[10][R] + cb_darrays[10][B]));
  189.       L = l2[2];
  190.       o2[2] = PIXEL((l_darrays[14][L] + cr_darrays[14][R] + cb_darrays[14][B]));
  191.       L = l2[3];
  192.       o2[3] = PIXEL((l_darrays[6][L] + cr_darrays[6][R] + cb_darrays[6][B]));
  193.  
  194.       R = r[2]; B = b[2];
  195.  
  196.       L = l[4];
  197.       o1[4] = PIXEL((l_darrays[0][L] + cr_darrays[0][R] + cb_darrays[0][B]));
  198.       L = l[5];
  199.       o1[5] = PIXEL((l_darrays[8][L] + cr_darrays[8][R] + cb_darrays[8][B]));
  200.       L = l2[4];
  201.       o2[4] = PIXEL((l_darrays[12][L] + cr_darrays[12][R] + cb_darrays[12][B]));
  202.       L = l2[5];
  203.       o2[5] = PIXEL((l_darrays[4][L] + cr_darrays[4][R] + cb_darrays[4][B]));
  204.  
  205.       R = r[3]; B = b[3];
  206.  
  207.       L = l[6];
  208.       o1[6] = PIXEL((l_darrays[2][L] + cr_darrays[2][R] + cb_darrays[2][B]));
  209.       L = l[7];
  210.       o1[7] = PIXEL((l_darrays[10][L] + cr_darrays[10][R] + cb_darrays[10][B]));
  211.       L = l2[6];
  212.       o2[6] = PIXEL((l_darrays[14][L] + cr_darrays[14][R] + cb_darrays[14][B]));
  213.       L = l2[7];
  214.       o2[7] = PIXEL((l_darrays[6][L] + cr_darrays[6][R] + cb_darrays[6][B]));
  215.  
  216.       l += 8;
  217.       l2 += 8;
  218.       r += 4;
  219.       b += 4;
  220.       o1 += 8;
  221.       o2 += 8;
  222.     }
  223.  
  224.     l += w; l2 += w;
  225.     o1 += w; o2 += w;
  226.  
  227.     for (j=0; j<w; j+=8) {
  228.  
  229.       R = r[0]; B = b[0];
  230.  
  231.       L = l[0];
  232.       o1[0] = PIXEL((l_darrays[3][L] + cr_darrays[3][R] + cb_darrays[3][B]));
  233.       L = l[1];
  234.       o1[1] = PIXEL((l_darrays[11][L] + cr_darrays[11][R] + cb_darrays[11][B]));
  235.       L = l2[0];
  236.       o2[0] = PIXEL((l_darrays[15][L] + cr_darrays[15][R] + cb_darrays[15][B]));
  237.       L = l2[1];
  238.       o2[1] = PIXEL((l_darrays[7][L] + cr_darrays[7][R] + cb_darrays[7][B]));
  239.  
  240.       R = r[1]; B = b[1];
  241.  
  242.       L = l[2];
  243.       o1[2] = PIXEL((l_darrays[1][L] + cr_darrays[1][R] + cb_darrays[1][B]));
  244.       L = l[3];
  245.       o1[3] = PIXEL((l_darrays[9][L] + cr_darrays[9][R] + cb_darrays[9][B]));
  246.       L = l2[2];
  247.       o2[2] = PIXEL((l_darrays[13][L] + cr_darrays[13][R] + cb_darrays[13][B]));
  248.       L = l2[3];
  249.       o2[3] = PIXEL((l_darrays[5][L] + cr_darrays[5][R] + cb_darrays[5][B]));
  250.  
  251.       R = r[2]; B = b[2];
  252.  
  253.       L = l[4];
  254.       o1[4] = PIXEL((l_darrays[3][L] + cr_darrays[3][R] + cb_darrays[3][B]));
  255.       L = l[5];
  256.       o1[5] = PIXEL((l_darrays[11][L] + cr_darrays[11][R] + cb_darrays[11][B]));
  257.       L = l2[4];
  258.       o2[4] = PIXEL((l_darrays[15][L] + cr_darrays[15][R] + cb_darrays[15][B]));
  259.       L = l2[5];
  260.       o2[5] = PIXEL((l_darrays[7][L] + cr_darrays[7][R] + cb_darrays[7][B]));
  261.  
  262.       R = r[3]; B = b[3];
  263.  
  264.       L = l[6];
  265.       o1[6] = PIXEL((l_darrays[1][L] + cr_darrays[1][R] + cb_darrays[1][B]));
  266.       L = l[7];
  267.       o1[7] = PIXEL((l_darrays[9][L] + cr_darrays[9][R] + cb_darrays[9][B]));
  268.       L = l2[6];
  269.       o2[6] = PIXEL((l_darrays[13][L] + cr_darrays[13][R] + cb_darrays[13][B]));
  270.       L = l2[7];
  271.       o2[7] = PIXEL((l_darrays[5][L] + cr_darrays[5][R] + cb_darrays[5][B]));
  272.  
  273.       l += 8;
  274.       l2 += 8;
  275.       r += 4;
  276.       b += 4;
  277.       o1 += 8;
  278.       o2 += 8;
  279.     }
  280.  
  281.     l += w; l2 += w;
  282.     o1 += w; o2 += w;
  283.   }
  284. }
  285.  
  286.  
  287.   
  288.