#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
-#include <string.h>
#include <assert.h>
#include <math.h>
using namespace std;
-static constexpr int dc_scalefac = 8; // Matches the FDCT's gain.
-static double quant_scalefac = 5.0; // whatever?
-static double lambda = 0.1;
-
void fdct_int32(short *const In);
void idct_int32(short *const In);
-unsigned char pix_4x4[WIDTH * HEIGHT], pix_8x8[WIDTH * HEIGHT], pix[WIDTH * HEIGHT];
-short global_coeff8x8[WIDTH * HEIGHT], global_coeff4x4[WIDTH * HEIGHT];
-double err_8x8[(WIDTH/8) * (HEIGHT/8)], err_4x4[(WIDTH/8) * (HEIGHT/8)];
+unsigned char pix[WIDTH * HEIGHT];
+short coeff[WIDTH * HEIGHT];
-static const unsigned char quant_8x8[64] = {
+static const unsigned char std_luminance_quant_tbl[64] = {
#if 0
16, 11, 10, 16, 24, 40, 51, 61,
12, 12, 14, 19, 26, 58, 60, 55,
24, 35, 55, 64, 81, 104, 113, 92,
49, 64, 78, 87, 103, 121, 120, 101,
72, 92, 95, 98, 112, 100, 103, 99
-#elif 1
- // ff_mpeg1_default_intra_matrix
- 8, 16, 19, 22, 26, 27, 29, 34,
- 16, 16, 22, 24, 27, 29, 34, 37,
- 19, 22, 26, 27, 29, 34, 34, 38,
- 22, 22, 26, 27, 29, 34, 37, 40,
- 22, 26, 27, 29, 32, 35, 40, 48,
- 26, 27, 29, 32, 35, 40, 48, 58,
- 26, 27, 29, 34, 38, 46, 56, 69,
- 27, 29, 35, 38, 46, 56, 69, 83
#endif
-};
-static const unsigned char quant_4x4[16] = {
- 8, 17, 27, 37,
- 17, 27, 37, 43,
- 27, 37, 43, 49,
- 37, 43, 49, 56
- //8, 8, 8, 8,
- //8, 8, 8, 8,
- //8, 8, 8, 8,
- //8, 8, 8, 8
- // 8, 19, 26, 29,
- //19, 26, 29, 34,
- //22, 27, 32, 40,
- //26, 29, 38, 56,
+ 16, 16, 19, 22, 26, 27, 29, 34,
+ 16, 16, 22, 24, 27, 29, 34, 37,
+ 19, 22, 26, 27, 29, 34, 34, 38,
+ 22, 22, 26, 27, 29, 34, 37, 40,
+ 22, 26, 27, 29, 32, 35, 40, 48,
+ 26, 27, 29, 32, 35, 40, 48, 58,
+ 26, 27, 29, 34, 38, 46, 56, 69,
+ 27, 29, 35, 38, 46, 56, 69, 83
};
struct SymbolStats
SymbolStats stats[64];
-int pick_stats_for(int y, int x, bool is_4x4)
+int pick_stats_for(int y, int x)
{
- if (is_4x4) {
- return 8 + std::min<int>(x + y, 3);
- }
//return std::min<int>(hypot(x, y), 7);
return std::min<int>(x + y, 7);
//if (x + y >= 7) return 7;
//return x + y;
- //return y * 8 + x;
+// return y * 8 + x;
#if 0
if (y == 0 && x == 0) {
return 0;
clear();
}
- void init_prob(const SymbolStats &s1, const SymbolStats &s2)
+ void init_prob(const SymbolStats &s)
{
for (int i = 0; i < NUM_SYMS; i++) {
//printf("%d: cumfreqs=%d freqs=%d prob_bits=%d\n", i, s.cum_freqs[i], s.freqs[i], prob_bits);
- RansEncSymbolInit(&esyms[i], s1.cum_freqs[i], s1.freqs[i], prob_bits);
+ RansEncSymbolInit(&esyms[i], s.cum_freqs[i], s.freqs[i], prob_bits);
}
}
RansEncSymbol esyms[NUM_SYMS];
};
-static inline int quantize8x8(int f, int coeff_idx)
-{
- if (coeff_idx == 0) {
- return f / dc_scalefac;
- }
- if (f == 0) {
- return 0;
- }
-
- const int w = quant_8x8[coeff_idx];
- const int s = quant_scalefac;
- int sign_f = (f > 0) ? 1 : -1;
- return (32 * f + sign_f * w * s) / (2 * w * s);
-}
-
-static inline int unquantize8x8(int qf, int coeff_idx)
-{
- if (coeff_idx == 0) {
- return qf * dc_scalefac;
- }
- if (qf == 0) {
- return 0;
- }
-
- const int w = quant_8x8[coeff_idx];
- const int s = quant_scalefac;
- return (2 * qf * w * s) / 32;
-}
-
-static inline int quantize4x4(int f, int coeff_idx)
-{
- if (coeff_idx == 0) {
- return f / (dc_scalefac/2);
- }
- if (f == 0) {
- return 0;
- }
-
- const int w = quant_4x4[coeff_idx];
- const int s = quant_scalefac;
- int sign_f = (f > 0) ? 1 : -1;
- return (64 * f + sign_f * w * s) / (2 * w * s);
-}
-
-static inline int unquantize4x4(int qf, int coeff_idx)
-{
- if (coeff_idx == 0) {
- return qf * (dc_scalefac/2);
- }
- if (qf == 0) {
- return 0;
- }
-
- const int w = quant_4x4[coeff_idx];
- const int s = quant_scalefac;
- return (2 * qf * w * s) / 64;
-}
-
-// https://people.xiph.org/~xiphmont/demo/daala/demo3.shtml
-
-static inline void tf_switch(short *a, short *b, short *c, short *d)
-{
- *b = *a - *b;
- *c = *c + *d;
- short e = (*c - *b)/2;
- *a = *a + e;
- *d = *d - e;
- *c = *a - *c;
- *b = *b - *d;
-}
-
-static inline void tf_switch_second_stage(short *b, short *d, short *f, short *h)
-{
- *b += *d / 2;
- *d -= *b / 2;
- *d += *f / 2;
- *f -= *d / 2;
- *f += *h / 2;
- *h -= *f / 2;
-}
-
-static inline void tf_switch_second_stage_inv(short *b, short *d, short *f, short *h)
-{
- *h += *f / 2;
- *f -= *h / 2;
- *f += *d / 2;
- *d -= *f / 2;
- *d += *b / 2;
- *b -= *d / 2;
-}
-
-static void convert_8x8to4x4(short *c)
+int main(void)
{
- for (unsigned x = 0; x < 8; ++x) {
- tf_switch_second_stage_inv(&c[1 * 8 + x], &c[3 * 8 + x], &c[5 * 8 + x], &c[7 * 8 + x]);
- }
- for (unsigned y = 0; y < 8; ++y) {
- tf_switch_second_stage_inv(&c[y * 8 + 1], &c[y * 8 + 3], &c[y * 8 + 5], &c[y * 8 + 7]);
- }
- for (unsigned y = 0; y < 4; ++y) {
- for (unsigned x = 0; x < 4; ++x) {
- tf_switch(&c[(y*2) * 8 + x*2], &c[(y*2) * 8 + (x*2+1)], &c[(y*2+1)*8 + x*2], &c[(y*2+1)*8 + (x*2+1)]);
- }
- }
- short d[64] = {
- c[0*8 + 0], c[0*8 + 2], c[0*8 + 4], c[0*8 + 6], c[0*8 + 1], c[0*8 + 3], c[0*8 + 5], c[0*8 + 7],
- c[2*8 + 0], c[2*8 + 2], c[2*8 + 4], c[2*8 + 6], c[2*8 + 1], c[2*8 + 3], c[2*8 + 5], c[2*8 + 7],
- c[4*8 + 0], c[4*8 + 2], c[4*8 + 4], c[4*8 + 6], c[4*8 + 1], c[4*8 + 3], c[4*8 + 5], c[4*8 + 7],
- c[6*8 + 0], c[6*8 + 2], c[6*8 + 4], c[6*8 + 6], c[6*8 + 1], c[6*8 + 3], c[6*8 + 5], c[6*8 + 7],
- c[1*8 + 0], c[1*8 + 2], c[1*8 + 4], c[1*8 + 6], c[1*8 + 1], c[1*8 + 3], c[1*8 + 5], c[1*8 + 7],
- c[3*8 + 0], c[3*8 + 2], c[3*8 + 4], c[3*8 + 6], c[3*8 + 1], c[3*8 + 3], c[3*8 + 5], c[3*8 + 7],
- c[5*8 + 0], c[5*8 + 2], c[5*8 + 4], c[5*8 + 6], c[5*8 + 1], c[5*8 + 3], c[5*8 + 5], c[5*8 + 7],
- c[7*8 + 0], c[7*8 + 2], c[7*8 + 4], c[7*8 + 6], c[7*8 + 1], c[7*8 + 3], c[7*8 + 5], c[7*8 + 7]
- };
- memcpy(c, d, sizeof(d));
-}
-
-static void convert_4x4to8x8(short *c)
-{
- short d[64] = {
- c[0*8 + 0], c[0*8 + 4], c[0*8 + 1], c[0*8 + 5], c[0*8 + 2], c[0*8 + 6], c[0*8 + 3], c[0*8 + 7],
- c[4*8 + 0], c[4*8 + 4], c[4*8 + 1], c[4*8 + 5], c[4*8 + 2], c[4*8 + 6], c[4*8 + 3], c[4*8 + 7],
- c[1*8 + 0], c[1*8 + 4], c[1*8 + 1], c[1*8 + 5], c[1*8 + 2], c[1*8 + 6], c[1*8 + 3], c[1*8 + 7],
- c[5*8 + 0], c[5*8 + 4], c[5*8 + 1], c[5*8 + 5], c[5*8 + 2], c[5*8 + 6], c[5*8 + 3], c[5*8 + 7],
- c[2*8 + 0], c[2*8 + 4], c[2*8 + 1], c[2*8 + 5], c[2*8 + 2], c[2*8 + 6], c[2*8 + 3], c[2*8 + 7],
- c[6*8 + 0], c[6*8 + 4], c[6*8 + 1], c[6*8 + 5], c[6*8 + 2], c[6*8 + 6], c[6*8 + 3], c[6*8 + 7],
- c[3*8 + 0], c[3*8 + 4], c[3*8 + 1], c[3*8 + 5], c[3*8 + 2], c[3*8 + 6], c[3*8 + 3], c[3*8 + 7],
- c[7*8 + 0], c[7*8 + 4], c[7*8 + 1], c[7*8 + 5], c[7*8 + 2], c[7*8 + 6], c[7*8 + 3], c[7*8 + 7]
- };
-
- for (unsigned y = 0; y < 4; ++y) {
- for (unsigned x = 0; x < 4; ++x) {
- tf_switch(&d[(y*2) * 8 + x*2], &d[(y*2) * 8 + (x*2+1)], &d[(y*2+1)*8 + x*2], &d[(y*2+1)*8 + (x*2+1)]);
- }
- }
- for (unsigned y = 0; y < 8; ++y) {
- tf_switch_second_stage(&d[y * 8 + 1], &d[y * 8 + 3], &d[y * 8 + 5], &d[y * 8 + 7]);
- }
- for (unsigned x = 0; x < 8; ++x) {
- tf_switch_second_stage(&d[1 * 8 + x], &d[3 * 8 + x], &d[5 * 8 + x], &d[7 * 8 + x]);
- }
-
- memcpy(c, d, sizeof(d));
-}
-
-int main(int argc, char **argv)
-{
- if (argc >= 2) quant_scalefac = atof(argv[1]);
- if (argc >= 3) lambda = atof(argv[2]);
-
FILE *fp = fopen("pic.pgm", "rb");
fread(pix, 1, WIDTH * HEIGHT, fp);
fclose(fp);
for (unsigned yb = 0; yb < HEIGHT; yb += 8) {
for (unsigned xb = 0; xb < WIDTH; xb += 8) {
// Read one block
- short in[64], reconstructed8x8[64];
- short reconstructed4x4[64];
+ short in[64];
for (unsigned y = 0; y < 8; ++y) {
for (unsigned x = 0; x < 8; ++x) {
in[y * 8 + x] = pix[(yb + y) * WIDTH + (xb + x)];
- // in[y * 8 + x] = 128;
}
}
// FDCT it
fdct_int32(in);
- // quant 8x8
- for (unsigned y = 0; y < 8; ++y) {
- for (unsigned x = 0; x < 8; ++x) {
- int coeff_idx = y * 8 + x;
- int k = quantize8x8(in[coeff_idx], coeff_idx);
- global_coeff8x8[(yb + y) * WIDTH + (xb + x)] = k;
+ //constexpr int extra_deadzone = 64;
+ constexpr int extra_deadzone = 4;
- // Store back for reconstruction / PSNR calculation
- reconstructed8x8[coeff_idx] = unquantize8x8(k, coeff_idx);
- }
- }
-
-#if 0
- printf("before TF switch:\n");
- for (unsigned y = 0; y < 8; ++y) {
- for (unsigned x = 0; x < 8; ++x) {
- printf("%4d ", in[y * 8 + x]);
- }
- printf("\n");
- }
- convert_8x8to4x4(in);
- printf("after TF switch:\n");
- for (unsigned y = 0; y < 8; ++y) {
- for (unsigned x = 0; x < 8; ++x) {
- printf("%4d ", in[y * 8 + x]);
- }
- printf("\n");
- }
- convert_4x4to8x8(in);
- printf("after TF switch and back:\n");
for (unsigned y = 0; y < 8; ++y) {
for (unsigned x = 0; x < 8; ++x) {
- printf("%4d ", in[y * 8 + x]);
+ short *c = &in[y * 8 + x];
+ *c <<= 3;
+ *c = copysign(std::max(abs(*c) - extra_deadzone, 0), *c);
+ //*c /= std_luminance_quant_tbl[y * 8 + x];
+ *c = (int)(double(*c) / std_luminance_quant_tbl[y * 8 + x]);
+#if 0
+ if (x != 0 || y != 0) {
+ int ss = 1;
+ if (::abs(int(*c)) <= ss) {
+ *c = 0; // eeh
+ } else if (*c > 0) {
+ *c -= ss; // eeh
+ } else {
+ *c += ss; // eeh
+ }
+ }
+#endif
}
- printf("\n");
}
-#endif
-
- // reconstruct 8x8
- idct_int32(reconstructed8x8);
- double sum_sq_err8x8 = 0.0;
+ // Store it
for (unsigned y = 0; y < 8; ++y) {
for (unsigned x = 0; x < 8; ++x) {
- int k = reconstructed8x8[y * 8 + x];
- if (k < 0) k = 0;
- if (k > 255) k = 255;
- uint8_t *ptr = &pix[(yb + y) * WIDTH + (xb + x)];
- sum_sq_err8x8 += (*ptr - k) * (*ptr - k);
- pix_8x8[(yb + y) * WIDTH + (xb + x)] = k;
-// *ptr = k;
+ coeff[(yb + y) * WIDTH + (xb + x)] = in[y * 8 + x];
}
}
- sum_sq_err += sum_sq_err8x8;
- // now let's try 4x4
- convert_8x8to4x4(in);
+ // and back
for (unsigned y = 0; y < 8; ++y) {
for (unsigned x = 0; x < 8; ++x) {
- int coeff_idx = y * 8 + x;
- int subcoeff_idx = (y%4) * 4 + (x%4);
- int k = quantize4x4(in[coeff_idx], subcoeff_idx);
- global_coeff4x4[(yb + y) * WIDTH + (xb + x)] = k;
-
- // Store back for reconstruction / PSNR calculation
- reconstructed4x4[coeff_idx] = unquantize4x4(k, subcoeff_idx);
+ in[y * 8 + x] *= std_luminance_quant_tbl[y * 8 + x];
+ if (in[y * 8 + x] > 0) {
+ in[y * 8 + x] += extra_deadzone;
+ } else if (in[y * 8 + x] < 0) {
+ in[y * 8 + x] -= extra_deadzone;
+ }
+ in[y * 8 + x] >>= 3;
}
}
- // reconstruct 4x4
- convert_4x4to8x8(reconstructed4x4);
- idct_int32(reconstructed4x4);
+ idct_int32(in);
- double sum_sq_err4x4 = 0.0;
for (unsigned y = 0; y < 8; ++y) {
for (unsigned x = 0; x < 8; ++x) {
- int k = reconstructed4x4[y * 8 + x];
+ int k = in[y * 8 + x];
if (k < 0) k = 0;
if (k > 255) k = 255;
uint8_t *ptr = &pix[(yb + y) * WIDTH + (xb + x)];
- sum_sq_err4x4 += (*ptr - k) * (*ptr - k);
- //*ptr = k;
- pix_4x4[(yb + y) * WIDTH + (xb + x)] = k;
+ sum_sq_err += (*ptr - k) * (*ptr - k);
+ *ptr = k;
}
}
-
- err_8x8[(yb/8) * (WIDTH/8) + (xb/8)] = sum_sq_err8x8;
- err_4x4[(yb/8) * (WIDTH/8) + (xb/8)] = sum_sq_err4x4;
- //printf("err 8x8 = %6.2f err 4x4 = %6.2f win = %d\n", sum_sq_err8x8, sum_sq_err4x4, sum_sq_err4x4 < sum_sq_err8x8);
- //sum_sq_err += sum_sq_err4x4;
}
}
double mse = sum_sq_err / double(WIDTH * HEIGHT);
// DC coefficient pred from the right to left
for (unsigned yb = 0; yb < HEIGHT; yb += 8) {
for (unsigned xb = 0; xb < WIDTH - 8; xb += 8) {
- global_coeff8x8[yb * WIDTH + xb] -= global_coeff8x8[yb * WIDTH + (xb + 8)];
- }
- }
- for (unsigned yb = 0; yb < HEIGHT; yb += 4) {
- for (unsigned xb = 0; xb < WIDTH - 4; xb += 4) {
- global_coeff4x4[yb * WIDTH + xb] -= global_coeff4x4[yb * WIDTH + (xb + 4)];
+ coeff[yb * WIDTH + xb] -= coeff[yb * WIDTH + (xb + 8)];
}
}
+ fp = fopen("reconstructed.pgm", "wb");
+ fprintf(fp, "P5\n%d %d\n255\n", WIDTH, HEIGHT);
+ fwrite(pix, 1, WIDTH * HEIGHT, fp);
+ fclose(fp);
+
// For each coefficient, make some tables.
size_t extra_bits = 0, sign_bits = 0;
for (unsigned i = 0; i < 64; ++i) {
}
for (unsigned y = 0; y < 8; ++y) {
for (unsigned x = 0; x < 8; ++x) {
- SymbolStats &s = stats[pick_stats_for(x, y, false)];
+ SymbolStats &s = stats[pick_stats_for(x, y)];
for (unsigned yb = 0; yb < HEIGHT; yb += 8) {
for (unsigned xb = 0; xb < WIDTH; xb += 8) {
- short k = abs(global_coeff8x8[(yb + y) * WIDTH + (xb + x)]);
+ short k = abs(coeff[(yb + y) * WIDTH + (xb + x)]);
if (k >= ESCAPE_LIMIT) {
//printf("coeff (%d,%d) had value %d\n", y, x, k);
k = ESCAPE_LIMIT;
}
}
}
- for (unsigned y = 0; y < 4; ++y) {
- for (unsigned x = 0; x < 4; ++x) {
- SymbolStats &s = stats[pick_stats_for(x, y, true)];
-
- for (unsigned yb = 0; yb < HEIGHT; yb += 4) {
- for (unsigned xb = 0; xb < WIDTH; xb += 4) {
- short k = abs(global_coeff4x4[(yb + y) * WIDTH + (xb + x)]);
- if (k >= ESCAPE_LIMIT) {
- k = ESCAPE_LIMIT;
- extra_bits += 12; // escape this one
- }
- if (k != 0) ++sign_bits;
- ++s.freqs[k];
- }
- }
- }
- }
for (unsigned i = 0; i < 64; ++i) {
#if 0
printf("coeff %i:", i);
#else
// TODO: rather gamma-k or something
for (unsigned j = 0; j < NUM_SYMS; ++j) {
- write_varint(stats[i].freqs[j], codedfp);
+ // write_varint(stats[i].freqs[j], codedfp);
}
#endif
}
- RansEncoder rans_encoder_8x8, rans_encoder_4x4;
-
- double total_bits_8x8 = 0.0, total_bits_4x4 = 0.0, total_bits_chosen = 0.0;
- int num_chosen = 0, tot_chosen = 0;
+ RansEncoder rans_encoder;
size_t tot_bytes = 0;
- for (unsigned yb = 0; yb < HEIGHT; yb += 8) {
- for (unsigned xb = 0; xb < WIDTH; xb += 8) {
- double bits_8x8 = 0.0, bits_4x4 = 0.0;
+ for (unsigned y = 0; y < 8; ++y) {
+ for (unsigned x = 0; x < 8; ++x) {
+ SymbolStats &s = stats[pick_stats_for(x, y)];
+
+ rans_encoder.init_prob(s);
- //rans_encoder.init_prob(s1, s2);
- //rans_encoder.clear();
+ // need to reverse later
+ rans_encoder.clear();
size_t num_bytes = 0;
- for (unsigned y = 0; y < 8; ++y) {
- for (unsigned x = 0; x < 8; ++x) {
- SymbolStats &s1 = stats[pick_stats_for(x, y, false)];
- SymbolStats &s2 = stats[pick_stats_for(x%4, y%4, true)];
-
- int k8 = global_coeff8x8[(yb + y) * WIDTH + (xb + x)];
- int k4 = global_coeff4x4[(yb + y) * WIDTH + (xb + x)];
-
- if (k8 != 0) ++bits_8x8; // sign bits
- if (k4 != 0) ++bits_4x4;
- k8 = abs(k8); k4 = abs(k4);
-
- if (k8 >= ESCAPE_LIMIT) { k8 = ESCAPE_LIMIT; bits_8x8 += 12.0; }
- if (k4 >= ESCAPE_LIMIT) { k4 = ESCAPE_LIMIT; bits_4x4 += 12.0; }
-
- bits_8x8 -= log2(s1.freqs[k8] / 4096.0);
- bits_4x4 -= log2(s2.freqs[k4] / 4096.0);
+ for (unsigned yb = 0; yb < HEIGHT; yb += 8) {
+ for (unsigned xb = 0; xb < WIDTH; xb += 8) {
+ int k = coeff[(yb + y) * WIDTH + (xb + x)];
+ //printf("encoding coeff %d xb,yb=%d,%d: %d\n", y*8+x, xb, yb, k);
+ rans_encoder.encode_coeff(k);
}
-// if (yb % 16 == 8) {
-// num_bytes += rans_encoder.save_block(codedfp);
-// }
+ if (yb % 16 == 8) {
+ num_bytes += rans_encoder.save_block(codedfp);
+ }
+ }
+ if (HEIGHT % 16 != 0) {
+ num_bytes += rans_encoder.save_block(codedfp);
}
-// if (HEIGHT % 16 != 0) {
-// num_bytes += rans_encoder.save_block(codedfp);
-// }
tot_bytes += num_bytes;
- total_bits_8x8 += bits_8x8;
- total_bits_4x4 += bits_4x4;
- auto e8 = err_8x8[(yb/8)*(WIDTH/8) + (xb/8)];
- auto e4 = err_4x4[(yb/8)*(WIDTH/8) + (xb/8)];
- double rd8 = sqrt(e8) + lambda * bits_8x8;
- double rd4 = sqrt(e4) + lambda * bits_4x4;
- const unsigned char *spix = (rd4 < rd8) ? pix_4x4 : pix_8x8;
- unsigned char col = (rd4 < rd8) ? 255 : 0;
- total_bits_chosen += (rd4 < rd8) ? bits_4x4 : bits_8x8;
- num_chosen += (rd4 < rd8);
- ++tot_chosen;
- for (unsigned y = 0; y < 8; ++y) {
- for (unsigned x = 0; x < 8; ++x) {
- pix[(yb + y) * WIDTH + (xb + x)] = spix[(yb + y) * WIDTH + (xb + x)];
- //pix[(yb + y) * WIDTH + (xb + x)] = col;
- }
- }
- printf("block (%d,%d): 8x8 %.2f bits [err=%.2f], 4x4 %.2f bits [err=%.2f], win_bits = %d, win_err = %d, win = %d\n",
- yb, xb,
- bits_8x8, sqrt(e8),
- bits_4x4, sqrt(e4),
- bits_4x4 < bits_8x8,
- e4 < e8,
- rd4 < rd8);
+ printf("coeff %d: %ld bytes\n", y * 8 + x, num_bytes);
}
}
- printf("4x4: %.2f bits, 8x8: %.2f bits, chosen: %d/%d times, %.2f bits (%.0f bytes)\n", total_bits_4x4, total_bits_8x8,
- num_chosen, tot_chosen, total_bits_chosen, total_bits_chosen / 8.0);
printf("%ld bytes + %ld sign bits (%ld) + %ld escape bits (%ld) = %ld total bytes\n",
tot_bytes - sign_bits / 8 - extra_bits / 8,
sign_bits,
extra_bits,
extra_bits / 8,
tot_bytes);
-
- fp = fopen("reconstructed.pgm", "wb");
- fprintf(fp, "P5\n%d %d\n255\n", WIDTH, HEIGHT);
- fwrite(pix, 1, WIDTH * HEIGHT, fp);
- fclose(fp);
-
}
projects / narabu / commitdiff