← Back to branch summary

~ubuntu-branches/ubuntu/warty/xmedcon/warty

« back to all changes in this revision

Viewing changes to libs/ljpg/predict.h

  • Committer: Bazaar Package Importer
  • Author(s): Roland Marcus Rutschmann
  • Date: 2004-06-07 09:00:14 UTC
  • Revision ID: james.westby@ubuntu.com-20040607090014-t39n52qc9zjqqqkh
Tags: upstream-0.9.6
Import upstream version 0.9.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/ljpg/predict.h
 
1
/*
 
2
 * predict.h --
 
3
 *
 
4
 * Code for predictor calculation. Its function version, predictor.c,
 
5
 * is used in debugging compilation.
 
6
 */
 
7
/*
 
8
 * $Id: predict.h,v 1.1 2002/10/14 21:56:03 enlf Exp $
 
9
 */
 
10
#ifndef _PREDICTOR
 
11
#define _PREDICTOR
 
12
 
 
13
#ifndef DEBUG
 
14
 
 
15
/*
 
16
 *--------------------------------------------------------------
 
17
 *
 
18
 * Predict --
 
19
 *
 
20
 *      Calculate the predictor for pixel[row][col][curComp],
 
21
 *      i.e. curRowBuf[col][curComp]. It handles the all special 
 
22
 *      cases at image edges, such as first row and first column
 
23
 *      of a scan.
 
24
 *
 
25
 * Results:
 
26
 *      predictor is passed out.
 
27
 *
 
28
 * Side effects:
 
29
 *      None.
 
30
 *
 
31
 *--------------------------------------------------------------
 
32
 */
 
33
#define Predict(row,col,curComp,curRowBuf,prevRowBuf,Pr,Pt,psv,predictor) \
 
34
{    register int left,upper,diag,leftcol;                                \
 
35
                                                                          \
 
36
    leftcol=col-1;                                                        \
 
37
    if (row==0) {                                                         \
 
38
                                                                          \
 
39
       /*                                                                 \
 
40
        * The predictor of first pixel is (1<<(Pr-Pt-1), and the          \
 
41
        * predictors for rest of first row are left neighbors.            \
 
42
        */                                                                \
 
43
       if (col==0) {                                                      \
 
44
          *predictor = (1<<(Pr-Pt-1));                                    \
 
45
       }                                                                  \
 
46
       else {                                                             \
 
47
          *predictor = curRowBuf[leftcol][curComp];                       \
 
48
       }                                                                  \
 
49
    }                                                                     \
 
50
    else {                                                                \
 
51
                                                                          \
 
52
       /*                                                                 \
 
53
        * The predictors of first column are upper neighbors.             \
 
54
        * All other preditors are calculated according to psv.            \
 
55
        */                                                                \
 
56
       upper=prevRowBuf[col][curComp];                                    \
 
57
       if (col==0)                                                        \
 
58
          *predictor = upper;                                             \
 
59
       else {                                                             \
 
60
          left=curRowBuf[leftcol][curComp];                               \
 
61
          diag=prevRowBuf[leftcol][curComp];                              \
 
62
          switch (psv) {                                                  \
 
63
             case 0:                                                      \
 
64
                     *predictor = 0;                                      \
 
65
                     break;                                               \
 
66
             case 1:                                                      \
 
67
                     *predictor = left;                                   \
 
68
                     break;                                               \
 
69
             case 2:                                                      \
 
70
                     *predictor = upper;                                  \
 
71
                     break;                                               \
 
72
             case 3:                                                      \
 
73
                     *predictor = diag;                                   \
 
74
                     break;                                               \
 
75
             case 4:                                                      \
 
76
                     *predictor = left+upper-diag;                        \
 
77
                     break;                                               \
 
78
             case 5:                                                      \
 
79
                     *predictor = left+((upper-diag)>>1);                 \
 
80
                     break;                                               \
 
81
             case 6:                                                      \
 
82
                     *predictor = upper+((left-diag)>>1);                 \
 
83
                     break;                                               \
 
84
             case 7:                                                      \
 
85
                     *predictor = (left+upper)>>1;                        \
 
86
                     break;                                               \
 
87
             default:                                                     \
 
88
                     fprintf(stderr,"Warning: Undefined PSV\n");          \
 
89
                     *predictor = 0;                                      \
 
90
           }                                                              \
 
91
        }                                                                 \
 
92
      }                                                                   \
 
93
}
 
94
 
 
95
/*
 
96
 *--------------------------------------------------------------
 
97
 *
 
98
 * QuickPredict --
 
99
 *
 
100
 *      Calculate the predictor for sample curRowBuf[col][curComp].
 
101
 *        It does not handle the special cases at image edges, such 
 
102
 *      as first row and first column of a scan. We put the special 
 
103
 *        case checkings outside so that the computations in main
 
104
 *        loop can be simpler. This has enhenced the performance
 
105
 *        significantly.
 
106
 *
 
107
 * Results:
 
108
 *      predictor is passed out.
 
109
 *
 
110
 * Side effects:
 
111
 *      None.
 
112
 *
 
113
 *--------------------------------------------------------------
 
114
 */
 
115
#define QuickPredict(col,curComp,curRowBuf,prevRowBuf,psv,predictor){     \
 
116
    register int left,upper,diag,leftcol;                                 \
 
117
                                                                          \
 
118
    /*                                                                    \
 
119
     * All predictor are calculated according to psv.                     \
 
120
     */                                                                   \
 
121
    switch (psv) {                                                        \
 
122
      case 0:                                                             \
 
123
              *predictor = 0;                                             \
 
124
              break;                                                      \
 
125
      case 1:                                                             \
 
126
              *predictor = curRowBuf [col-1] [curComp];                   \
 
127
              break;                                                      \
 
128
      case 2:                                                             \
 
129
              *predictor = prevRowBuf[col][curComp];                      \
 
130
              break;                                                      \
 
131
      case 3:                                                             \
 
132
              *predictor = prevRowBuf [col-1] [curComp];                  \
 
133
              break;                                                      \
 
134
      case 4:                                                             \
 
135
                  leftcol = col-1;                                        \
 
136
                  upper   = prevRowBuf[col][curComp];                     \
 
137
                  left    = curRowBuf[leftcol][curComp];                  \
 
138
                  diag    = prevRowBuf[leftcol][curComp];                 \
 
139
              *predictor = left + upper - diag;                           \
 
140
              break;                                                      \
 
141
      case 5:                                                             \
 
142
                  leftcol = col-1;                                        \
 
143
                  upper   = prevRowBuf[col][curComp];                     \
 
144
                  left    = curRowBuf[leftcol][curComp];                  \
 
145
                  diag    = prevRowBuf[leftcol][curComp];                 \
 
146
              *predictor = left+((upper-diag)>>1);                        \
 
147
              break;                                                      \
 
148
      case 6:                                                             \
 
149
                  leftcol = col-1;                                        \
 
150
                  upper   = prevRowBuf[col][curComp];                     \
 
151
                  left    = curRowBuf[leftcol][curComp];                  \
 
152
                  diag    = prevRowBuf[leftcol][curComp];                 \
 
153
              *predictor = upper+((left-diag)>>1);                        \
 
154
              break;                                                      \
 
155
      case 7:                                                             \
 
156
                  leftcol = col-1;                                        \
 
157
                  upper   = prevRowBuf[col][curComp];                     \
 
158
                  left    = curRowBuf[leftcol][curComp];                  \
 
159
              *predictor = (left+upper)>>1;                               \
 
160
              break;                                                      \
 
161
      default:                                                            \
 
162
              fprintf(stderr,"Warning: Undefined PSV\n");                 \
 
163
              *predictor = 0;                                             \
 
164
     }                                                                    \
 
165
}
 
166
 
 
167
#endif /* DEBUG */
 
168
#endif /* _PREDICTOR */