00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089 #include "all.h"
00090 #include "mtypes.h"
00091 #include "mproto.h"
00092 #include "huff.h"
00093
00094
00095
00096
00097
00098
00099
00100 static int ZAG[] =
00101 {
00102 0, 1, 8, 16, 9, 2, 3, 10,
00103 17, 24, 32, 25, 18, 11, 4, 5,
00104 12, 19, 26, 33, 40, 48, 41, 34,
00105 27, 20, 13, 6, 7, 14, 21, 28,
00106 35, 42, 49, 56, 57, 50, 43, 36,
00107 29, 22, 15, 23, 30, 37, 44, 51,
00108 58, 59, 52, 45, 38, 31, 39, 46,
00109 53, 60, 61, 54, 47, 55, 62, 63
00110 };
00111
00112
00113
00114
00115
00116
00117
00118
00119 static int qtable[] =
00120 {
00121 8, 16, 19, 22, 26, 27, 29, 34,
00122 16, 16, 22, 24, 27, 29, 34, 37,
00123 19, 22, 26, 27, 29, 34, 34, 38,
00124 22, 22, 26, 27, 29, 34, 37, 40,
00125 22, 26, 27, 29, 32, 35, 40, 48,
00126 26, 27, 29, 32, 35, 40, 48, 58,
00127 26, 27, 29, 34, 38, 46, 56, 69,
00128 27, 29, 35, 38, 46, 56, 69, 83};
00129
00130
00131
00132
00133
00134
00135
00136 void UnQuantZig(FlatBlock in, Block out, int qscale, boolean iblock)
00137 {
00138 register int index;
00139 int start;
00140 int position;
00141 register int qentry;
00142 int level, coeff;
00143 register int16 temp;
00144
00145 if ( iblock )
00146 {
00147 ((int16 *)out)[0] = (int16)(in[0]*qtable[0]);
00148
00149 start = 1;
00150 }
00151 else
00152 start = 0;
00153
00154 for ( index = start; index < DCTSIZE_SQ; index++ )
00155 {
00156 position = ZAG[index];
00157
00158 if (iblock)
00159 qentry = qtable[position] * qscale;
00160 else
00161 qentry = 16 * qscale;
00162
00163 level = in[index];
00164 coeff = (level * qentry) >> 3;
00165 if (level < 0) {
00166 coeff += (coeff & 1);
00167 } else {
00168 coeff -= (coeff & 1);
00169 }
00170
00171 ((int16 *)out)[position] = coeff;
00172 }
00173
00174 #ifdef BLEAH
00175 for ( index = 0; index < 64; index++ )
00176 fprintf(stdout, "DCT[%d] = %d\n", index,
00177 ((int16 *)out)[index]);
00178 #endif
00179 }
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196 boolean mp_quant_zig_block(Block in, FlatBlock out, int qscale, int iblock)
00197 {
00198 register int i;
00199 register int y, x;
00200 register int16 temp;
00201 register int qentry;
00202 int start;
00203 boolean nonZero = FALSE;
00204
00205 DBG_PRINT(("mp_quant_zig_block...\n"));
00206 if (iblock) {
00207
00208
00209
00210
00211 temp = ((int16 *) in)[ZAG[0]];
00212 qentry = qtable[ZAG[0]];
00213 if (temp < 0) {
00214 temp = -temp;
00215 temp += qentry >> 1;
00216 temp /= qentry;
00217 temp = -temp;
00218 } else {
00219 temp += qentry >> 1;
00220 temp /= qentry;
00221 }
00222 if ( temp != 0 )
00223 nonZero = TRUE;
00224 out[0] = temp;
00225 start = 1;
00226 } else
00227 start = 0;
00228
00229 for (i = start; i < DCTSIZE_SQ; i++) {
00230 x = ZAG[i] % 8;
00231 y = ZAG[i] / 8;
00232 temp = in[y][x];
00233 DBG_PRINT((" in[%d][%d] = %d; ", y, x, temp));
00234
00235 if (iblock)
00236 qentry = qtable[ZAG[i]] * qscale;
00237 else
00238 qentry = 16 * qscale;
00239
00240 DBG_PRINT(("quantized with %d = ", qentry));
00241
00242 if (temp < 0) {
00243 temp = -temp;
00244 temp *= 8;
00245 temp += qentry >> 1;
00246 temp /= qentry;
00247 temp = -temp;
00248 } else {
00249 temp *= 8;
00250 temp += qentry >> 1;
00251 temp /= qentry;
00252 }
00253 if ( temp != 0 )
00254 nonZero = TRUE;
00255 out[i] = temp;
00256 DBG_PRINT(("%d\n", temp));
00257 }
00258
00259 return nonZero;
00260 }
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278 void mp_rle_huff_block(FlatBlock in, BitBucket *out)
00279 {
00280 register int i;
00281 register int nzeros = 0;
00282 register int16 cur;
00283 register int16 acur;
00284 register uint32 code;
00285 register int nbits;
00286
00287
00288
00289
00290
00291 for (i = 1; i < DCTSIZE_SQ; i++) {
00292 cur = in[i];
00293 acur = ABS(cur);
00294 if (cur) {
00295 if (nzeros < HUFF_MAXRUN && acur < huff_maxlevel[nzeros]) {
00296
00297
00298
00299
00300 DBG_PRINT(("rle_huff %02d: Run %02d, Level %02d\n", i, nzeros, cur));
00301 assert(cur);
00302
00303 code = (huff_table[nzeros])[acur];
00304 nbits = (huff_bits[nzeros])[acur];
00305
00306 assert(nbits);
00307
00308 if (cur < 0)
00309 code |= 1;
00310 Bitio_Write(out, code, nbits);
00311 } else {
00312
00313
00314
00315 DBG_PRINT(("Escape\n"));
00316 Bitio_Write(out, 0x1, 6);
00317 DBG_PRINT(("Run Length\n"));
00318 Bitio_Write(out, nzeros, 6);
00319
00320 assert(cur != 0);
00321
00322
00323
00324
00325
00326 if (cur < -255)
00327 cur = -255;
00328 else if (cur > 255)
00329 cur = 255;
00330
00331 DBG_PRINT(("Level\n"));
00332 if (acur < 128) {
00333 Bitio_Write(out, cur, 8);
00334 } else {
00335 if (cur < 0) {
00336 Bitio_Write(out, 0x8001 + cur + 255, 16);
00337 } else
00338 Bitio_Write(out, cur, 16);
00339 }
00340 }
00341 nzeros = 0;
00342 } else
00343 nzeros++;
00344 }
00345 DBG_PRINT(("End of block\n"));
00346 Bitio_Write(out, 0x2, 2);
00347 }
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364 void mp_rle_huff_pblock(FlatBlock in, BitBucket *out)
00365 {
00366 register int i;
00367 register int nzeros = 0;
00368 register int16 cur;
00369 register int16 acur;
00370 register uint32 code;
00371 register int nbits;
00372 boolean first_dct = TRUE;
00373
00374
00375
00376
00377 for (i = 0; i < DCTSIZE_SQ; i++) {
00378 cur = in[i];
00379 acur = ABS(cur);
00380 if (cur) {
00381 if (nzeros < HUFF_MAXRUN && acur < huff_maxlevel[nzeros]) {
00382
00383
00384
00385
00386 DBG_PRINT(("rle_huff %02d: Run %02d, Level %02d\n", i, nzeros, cur));
00387 assert(cur);
00388
00389 if ( first_dct && (nzeros == 0) && (acur == 1) )
00390 {
00391
00392 code = (cur == 1) ? 0x2 : 0x3;
00393 nbits = 2;
00394 }
00395 else
00396 {
00397 code = (huff_table[nzeros])[acur];
00398 nbits = (huff_bits[nzeros])[acur];
00399 }
00400
00401 assert(nbits);
00402
00403 if (cur < 0)
00404 code |= 1;
00405 Bitio_Write(out, code, nbits);
00406 first_dct = FALSE;
00407 } else {
00408
00409
00410
00411 DBG_PRINT(("Escape\n"));
00412 Bitio_Write(out, 0x1, 6);
00413 DBG_PRINT(("Run Length\n"));
00414 Bitio_Write(out, nzeros, 6);
00415
00416 assert(cur != 0);
00417
00418
00419
00420
00421
00422 if (cur < -255)
00423 cur = -255;
00424 else if (cur > 255)
00425 cur = 255;
00426
00427 DBG_PRINT(("Level\n"));
00428 if (acur < 128) {
00429 Bitio_Write(out, cur, 8);
00430 } else {
00431 if (cur < 0) {
00432 Bitio_Write(out, 0x8001 + cur + 255, 16);
00433 } else
00434 Bitio_Write(out, cur, 16);
00435 }
00436
00437 first_dct = FALSE;
00438 }
00439 nzeros = 0;
00440 } else
00441 nzeros++;
00442 }
00443
00444
00445 if ( first_dct )
00446 {
00447 fprintf(stdout, "HUFF called with all-zero coefficients\n");
00448 fprintf(stdout, "exiting...\n");
00449 exit(1);
00450 }
00451
00452 DBG_PRINT(("End of block\n"));
00453 Bitio_Write(out, 0x2, 2);
00454 }