Groups > comp.lang.c > #402356 > unrolled thread

[c+ai] one night with image codec

Started by	fir <profesor.fir@gmail.com>
First post	2026-09-24 15:36 +0200
Last post	2026-10-01 00:08 +0800
Articles	19 — 7 participants

Back to article view | Back to comp.lang.c

  [c+ai] one night with image codec fir <profesor.fir@gmail.com> - 2026-09-24 15:36 +0200
    Re: [c+ai] one night with image codec fir <profesor.fir@gmail.com> - 2026-09-24 16:06 +0200
      Re: [c+ai] one night with image codec fir <profesor.fir@gmail.com> - 2026-09-24 16:17 +0200
    Re: [c+ai] one night with image codec bart <bc@freeuk.com> - 2026-09-24 15:30 +0100
      Re: [c+ai] one night with image codec fir <profesor.fir@gmail.com> - 2026-09-24 16:45 +0200
        Re: [c+ai] one night with image codec "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2026-09-24 16:31 -0700
          Re: [c+ai] one night with image codec fir <profesor.fir@gmail.com> - 2026-09-25 02:05 +0200
            Re: [c+ai] one night with image codec "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2026-09-27 15:05 -0700
              Re: [c+ai] one night with image codec bart <bc@freeuk.com> - 2026-09-28 00:44 +0100
                Re: [c+ai] one night with image codec fir <profesor.fir@gmail.com> - 2026-09-28 04:22 +0200
                Re: [c+ai] one night with image codec Paul <nospam@needed.invalid> - 2026-09-28 04:27 -0400
      Re: [c+ai] one night with image codec fir <profesor.fir@gmail.com> - 2026-09-24 18:27 +0200
        Re: [c+ai] one night with image codec David Brown <david.brown@hesbynett.no> - 2026-09-25 10:38 +0200
          Re: [c+ai] one night with image codec fir <profesor.fir@gmail.com> - 2026-09-25 10:57 +0200
      Re: [c+ai] one night with image codec David Brown <david.brown@hesbynett.no> - 2026-09-25 10:49 +0200
        Re: [c+ai] one night with image codec bart <bc@freeuk.com> - 2026-09-25 10:49 +0100
        Re: [c+ai] one night with image codec Jim Jackson <jj@franjam.org.uk> - 2026-09-25 12:01 +0000
          Re: [c+ai] one night with image codec fir <profesor.fir@gmail.com> - 2026-09-26 02:51 +0200
    Re: [c+ai] one night with image codec Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid> - 2026-10-01 00:08 +0800

#402356 — [c+ai] one night with image codec

From	fir <profesor.fir@gmail.com>
Date	2026-09-24 15:36 +0200
Subject	[c+ai] one night with image codec
Message-ID	<119391l$2ng62$1@dont-email.me>

i once was writing on this -
the idea is take bitmap (like 960x540) take some pixels of it
(in practice i take liek 2% maybe 5% random pixels store it as a file
(new image codec) and interpolate it to recreate the image

i just wonder how it would work..
it was a bit to tedious to write it alone but in present times you just
say it to chat gpt and it practically write it to yourself

the technical quest is here mainly

1) what interpolation function tu use (ai write me some im not sure how
good it is)

2) optimiser function - it just generates various pixels interpolate and
compare it to oryginal bitmap searching for least error among 
interpolated and oryginal

3) additionally if i store this 2% pixels in disk file there is
also option to store it in most 'packed' way..right now i just
used 3 butes for storing xy of pixels (12 bits for x and 12 bits y)
and 3 bytes for rgb color - so on pixel its 6 bytes

generally t showed to work like i take about 2 MB source bitmap
and result is about 180kb -250kb result that in fact is not such bad
(i could post pices of images how it work but later)

its notably worse than jpg of its size but still its quite ok


almost whole code here was simply generated by ai..and i post it below

it is in some kind interesting topic...so if someone want to comment on 
that may commnet on tah if no may just ignore (the group has not so
many topics to comment so i dont hink is harm such post on this)



(note i compile in c++ mode as i dont ike use #defines i prefer use 
const int from c++, also i use my own green fire library to setup
windowm with frame bitmap i cant set pixels to it and draw things on 
client area of window)



#define _WIN32_WINNT 0x0501
#define WIN32_LEAN_AND_MEAN
#define WIN32_EXTRA_LEAN
#include <windows.h>
#include <Mmsystem.h>
#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include <stdint.h>

#include "green-fire.h"



const int GRID_SIZE = 5;
const int INTERP_K = 3;

const int MIN_POINTS_PER_GRID = 1;
const int MAX_POINTS_PER_GRID = 10;

const int TRIALS = 100; //50
const int OPT_PASSES = 5; //10


typedef struct {
     short x, y;
     unsigned color;
} PointColor;


typedef struct {
     unsigned *pixels;
     int w, h, stride;
} Bitmap;


typedef struct {
     int *p;
     int n;
} GridCell;


static GridCell *grid;
static int grid_w, grid_h;



int LoadBitmap(const char *filename, Bitmap *b)
{
     HBITMAP bmp = (HBITMAP)LoadImageA(
         0, filename, IMAGE_BITMAP, 0, 0,
         LR_LOADFROMFILE | LR_CREATEDIBSECTION);

     if (!bmp)
     {
         ERROR_("LoadImageA failed");
         return 0;
     }

     DIBSECTION ds;

     if (!GetObject(bmp, sizeof(ds), &ds))
     {
         ERROR_("GetObject failed");
         DeleteObject(bmp);
         return 0;
     }

     int bpp = ds.dsBm.bmBitsPixel;

     if (bpp != 24 && bpp != 32)
     {
         ERROR_("bitmap must be 24 or 32 bit");
         DeleteObject(bmp);
         return 0;
     }

     b->w = ds.dsBm.bmWidth;
     b->h = ds.dsBm.bmHeight;
     b->stride = b->w;

     b->pixels = (unsigned*)malloc(
         b->w * b->h * sizeof(unsigned));

     if (!b->pixels)
     {
         DeleteObject(bmp);
         return 0;
     }

     unsigned char *src =
         (unsigned char*)ds.dsBm.bmBits;

     int src_stride = ds.dsBm.bmWidthBytes;
     int top_down = ds.dsBmih.biHeight < 0;

     for (int y = 0; y < b->h; y++)
     {
         int sy = top_down ? y : b->h - 1 - y;

         unsigned char *row =
             src + sy * src_stride;

         for (int x = 0; x < b->w; x++)
         {
             unsigned char *p =
                 row + x * (bpp / 8);

             // BMP stores B,G,R,(A)
             b->pixels[y * b->w + x] =
                 p[0] | (p[1] << 8) | (p[2] << 16);
         }
     }

     DeleteObject(bmp);
     return 1;
}

static int ColorError(unsigned a, unsigned b)
{
     Color ca, cb;

     ca.u = a;
     cb.u = b;

     int dr = ca.r - cb.r;
     int dg = ca.g - cb.g;
     int db = ca.b - cb.b;

     return dr * dr +
            dg * dg +
            db * db;
}


/*
  * Lokalna "złożoność" grida.
  *
  * Liczymy różnice pomiędzy sąsiednimi
  * pikselami. Jednolity obszar daje mały
  * wynik, krawędzie i tekst duży.
  */
static long long GridComplexity(
     unsigned *src,
     int stride,
     int gx,
     int gy)
{
     const int x0 = gx * GRID_SIZE;
     const int y0 = gy * GRID_SIZE;

     int x1 = x0 + GRID_SIZE;
     int y1 = y0 + GRID_SIZE;

     if (x1 > frame_size_x)
         x1 = frame_size_x;

     if (y1 > frame_size_y)
         y1 = frame_size_y;

     long long e = 0;

     for (int y = y0; y < y1; y++) {

         for (int x = x0; x < x1; x++) {

             if (x + 1 < x1)
                 e += ColorError(
                     src[y * stride + x],
                     src[y * stride + x + 1]);

             if (y + 1 < y1)
                 e += ColorError(
                     src[y * stride + x],
                     src[(y + 1) * stride + x]);
         }
     }

     return e;
}


/*
  * Na podstawie całego obrazu ustalamy
  * progi dla 1..MAX_POINTS_PER_GRID punktów.
  *
  * Używamy min/max złożoności gridów.
  */
static int *BuildPointCounts(
     unsigned *src,
     int stride)
{
     const int grid_n =
         grid_w * grid_h;

     long long *complexity =
         (long long*)malloc(
             grid_n * sizeof(long long));

     long long min_c = 0;
     long long max_c = 0;

     for (int gy = 0; gy < grid_h; gy++)
         for (int gx = 0; gx < grid_w; gx++) {

             const int i =
                 gy * grid_w + gx;

             complexity[i] =
                 GridComplexity(
                     src,
                     stride,
                     gx,
                     gy);

             if (!i ||
                 complexity[i] < min_c)
                 min_c = complexity[i];

             if (!i ||
                 complexity[i] > max_c)
                 max_c = complexity[i];
         }


     int *counts =
         (int*)malloc(
             grid_n * sizeof(int));


     /*
      * Jeżeli cały obraz jest prawie jednolity,
      * nie ma sensu robić wielu punktów.
      */
     if (max_c == min_c) {

         for (int i = 0; i < grid_n; i++)
             counts[i] =
                 MIN_POINTS_PER_GRID;

         free(complexity);
         return counts;
     }


     /*
      * Logarytmiczna skala daje więcej punktów
      * obszarom z naprawdę dużą zmiennością,
      * zamiast rozdzielać punkty liniowo.
      *
      * Tu używamy prostego przybliżenia:
      *
      * normalized = (c-min)/(max-min)
      *
      * a potem potęgowanie przez 0.5,
      * czyli sqrt(normalized).
      */
     const double range =
         (double)(max_c - min_c);

     for (int i = 0; i < grid_n; i++) {

         double t =
             (complexity[i] - min_c) /
             range;

         t = sqrt(t);

         int n =
             MIN_POINTS_PER_GRID +
             (int)(
                 t *
                 (MAX_POINTS_PER_GRID -
                  MIN_POINTS_PER_GRID));

         if (n < MIN_POINTS_PER_GRID)
             n = MIN_POINTS_PER_GRID;

         if (n > MAX_POINTS_PER_GRID)
             n = MAX_POINTS_PER_GRID;

         counts[i] = n;
     }

     free(complexity);

     return counts;
}


/*
  * Losujemy początkowe punkty,
  * ale liczba punktów jest adaptacyjna.
  *
  * points_count[i] mówi ile punktów
  * ma grid i.
  */
static int RandomSamplesAdaptive(
     PointColor *p,
     int *points_count,
     Bitmap *b)
{
     grid_w =
         (b->w + GRID_SIZE - 1) /
         GRID_SIZE;

     grid_h =
         (b->h + GRID_SIZE - 1) /
         GRID_SIZE;

     int k = 0;

     for (int gy = 0; gy < grid_h; gy++)
         for (int gx = 0; gx < grid_w; gx++) {

             const int gi =
                 gy * grid_w + gx;

             const int x0 =
                 gx * GRID_SIZE;

             const int y0 =
                 gy * GRID_SIZE;

             int x1 =
                 x0 + GRID_SIZE;

             int y1 =
                 y0 + GRID_SIZE;

             if (x1 > b->w)
                 x1 = b->w;

             if (y1 > b->h)
                 y1 = b->h;

             for (int j = 0;
                  j < points_count[gi];
                  j++) {

                 int x =
                     x0 + rand() % (x1 - x0);

                 int y =
                     y0 + rand() % (y1 - y0);

                 p[k].x = (short)x;
                 p[k].y = (short)y;

                 p[k].color =
                     b->pixels[
                         y * b->stride + x];

                 k++;
             }
         }

     return k;
}



static unsigned InterpolatePixel(PointColor *points, int x, int y)
{
     const int gx = x / GRID_SIZE;
     const int gy = y / GRID_SIZE;

     int kd[INTERP_K];
     int kdist[INTERP_K];
     int kn = 0;

     for (int cy = gy - 1; cy <= gy + 1; cy++) {
         if (cy < 0 || cy >= grid_h) continue;

         for (int cx = gx - 1; cx <= gx + 1; cx++) {
             if (cx < 0 || cx >= grid_w) continue;

             GridCell *c = &grid[cy * grid_w + cx];

             for (int j = 0; j < c->n; j++) {
                 const int pi = c->p[j];
                 const int dx = points[pi].x - x;
                 const int dy = points[pi].y - y;
                 const int d2 = dx * dx + dy * dy;

                 if (!d2) return points[pi].color;

                 if (kn < INTERP_K) {
                     int k = kn++;

                     while (k && d2 < kdist[k - 1]) {
                         kdist[k] = kdist[k - 1];
                         kd[k] = kd[k - 1];
                         k--;
                     }

                     kdist[k] = d2;
                     kd[k] = pi;
                 }
                 else if (d2 < kdist[INTERP_K - 1]) {
                     int k = INTERP_K - 1;

                     while (k && d2 < kdist[k - 1]) {
                         kdist[k] = kdist[k - 1];
                         kd[k] = kd[k - 1];
                         k--;
                     }

                     kdist[k] = d2;
                     kd[k] = pi;
                 }
             }
         }
     }

     if (!kn) return 0;

     double sr = 0, sg = 0, sb = 0, sw = 0;

     for (int i = 0; i < kn; i++) {
         Color c;
         c.u = points[kd[i]].color;

//        const double w = 1.0 / kdist[i];
	const double w = 1.0 / (double)(kdist[i] * kdist[i]);
//	const double w = exp(-kdist[i] / 50.0);

         sr += c.r * w;
         sg += c.g * w;
         sb += c.b * w;
         sw += w;
     }

     Color c;
     c.r = (unsigned char)(sr / sw + 0.5);
     c.g = (unsigned char)(sg / sw + 0.5);
     c.b = (unsigned char)(sb / sw + 0.5);
     c.a = 0;

     return c.u;
}


static long long GridError(
     PointColor *points,
     unsigned *src,
     int src_stride,
     int gx,
     int gy)
{
     const int x0 =
         gx * GRID_SIZE;

     const int y0 =
         gy * GRID_SIZE;

     int x1 =
         x0 + GRID_SIZE;

     int y1 =
         y0 + GRID_SIZE;

     if (x1 > frame_size_x)
         x1 = frame_size_x;

     if (y1 > frame_size_y)
         y1 = frame_size_y;

     long long error = 0;

     for (int y = y0; y < y1; y++)
         for (int x = x0; x < x1; x++)
             error += ColorError(
                 InterpolatePixel(
                     points,
                     x,
                     y),
                 src[y * src_stride + x]);

     return error;
}


void OptimizeGridSamples(
     PointColor *points,
     int n,
     int *points_count,
     unsigned *src,
     int src_stride)
{
     grid_w =
         (frame_size_x + GRID_SIZE - 1) /
         GRID_SIZE;

     grid_h =
         (frame_size_y + GRID_SIZE - 1) /
         GRID_SIZE;

     const int grid_n =
         grid_w * grid_h;

     grid =
         (GridCell*)calloc(
             grid_n,
             sizeof(GridCell));


     /*
      * Ponieważ liczba punktów w gridzie
      * jest już ustalona, możemy od razu
      * zaalokować dokładne tablice.
      */
     int k = 0;

     for (int i = 0; i < grid_n; i++) {

         const int count =
             points_count[i];

         grid[i].n = count;

         grid[i].p =
             (int*)malloc(
                 count * sizeof(int));

         for (int j = 0; j < count; j++)
             grid[i].p[j] = k++;
     }


     for (int pass = 0;
          pass < OPT_PASSES;
          pass++) {

         for (int gy = 0;
              gy < grid_h;
              gy++) {

             for (int gx = 0;
                  gx < grid_w;
                  gx++) {

                 GridCell *cell =
                     &grid[
                         gy * grid_w + gx];

                 const int count =
                     cell->n;

                 PointColor *best =
                     (PointColor*)malloc(
                         count *
                         sizeof(PointColor));

                 for (int i = 0;
                      i < count;
                      i++)
                     best[i] =
                         points[cell->p[i]];


                 long long best_error =
                     GridError(
                         points,
                         src,
                         src_stride,
                         gx,
                         gy);


                 const int x0 =
                     gx * GRID_SIZE;

                 const int y0 =
                     gy * GRID_SIZE;

                 int x1 =
                     x0 + GRID_SIZE;

                 int y1 =
                     y0 + GRID_SIZE;

                 if (x1 > frame_size_x)
                     x1 = frame_size_x;

                 if (y1 > frame_size_y)
                     y1 = frame_size_y;


                 for (int trial = 0;
                      trial < TRIALS;
                      trial++) {

                     for (int i = 0;
                          i < count;
                          i++) {

                         const int x =
                             x0 +
                             rand() %
                             (x1 - x0);

                         const int y =
                             y0 +
                             rand() %
                             (y1 - y0);

                         PointColor *p =
                             &points[cell->p[i]];

                         p->x = (short)x;
                         p->y = (short)y;

                         p->color =
                             src[
                                 y * src_stride +
                                 x];
                     }


                     const long long error =
                         GridError(
                             points,
                             src,
                             src_stride,
                             gx,
                             gy);


                     if (error < best_error) {

                         best_error = error;

                         for (int i = 0;
                              i < count;
                              i++)
                             best[i] =
                                 points[cell->p[i]];
                     }
                 }


                 for (int i = 0;
                      i < count;
                      i++)
                     points[cell->p[i]] =
                         best[i];

                 free(best);
             }
         }
     }


     for (int i = 0;
          i < grid_n;
          i++)
         free(grid[i].p);

     free(grid);
     grid = 0;
}



static int DumpSamples(
     const char *filename,
     PointColor *points,
     int n)
{
     FILE *f = fopen(filename, "wb");

     if (!f)
         return 0;

     /* magic */
     const unsigned char magic[4] = {'F', 'I', 'M', 'A'};

     if (fwrite(magic, 1, 4, f) != 4) {
         fclose(f);
         return 0;
     }

     /* image dimensions */
     uint16_t w = (uint16_t)frame_size_x;
     uint16_t h = (uint16_t)frame_size_y;

     if (fwrite(&w, 2, 1, f) != 1 ||
         fwrite(&h, 2, 1, f) != 1) {
         fclose(f);
         return 0;
     }

     /*
      * x and y are both <= 10 bits for 960x540.
      * Pack them into 20 bits:
      *
      * bits  0.. 9 = x
      * bits 10..19 = y
      */
     for (int i = 0; i < n; i++) {
         const unsigned x = (unsigned)points[i].x;
         const unsigned y = (unsigned)points[i].y;

         const unsigned xy = x | (y << 10);

         unsigned char p[6];

         p[0] = (unsigned char)(xy);
         p[1] = (unsigned char)(xy >> 8);
         p[2] = (unsigned char)(xy >> 16);

         Color c;
         c.u = points[i].color;

         p[3] = c.r;
         p[4] = c.g;
         p[5] = c.b;

         if (fwrite(p, 1, 6, f) != 6) {
             fclose(f);
             return 0;
         }
     }

     fclose(f);
     return 1;
}


static PointColor *LoadSamples(
     const char *filename,
     int *w,
     int *h,
     int *n)
{
     FILE *f = fopen(filename, "rb");

     if (!f)
         return 0;

     unsigned char magic[4];

     if (fread(magic, 1, 4, f) != 4 ||
         magic[0] != 'F' ||
         magic[1] != 'I' ||
         magic[2] != 'M' ||
         magic[3] != 'A') {
         fclose(f);
         return 0;
     }

     uint16_t uw, uh;

     if (fread(&uw, 2, 1, f) != 1 ||
         fread(&uh, 2, 1, f) != 1) {
         fclose(f);
         return 0;
     }

     *w = uw;
     *h = uh;

     fseek(f, 0, SEEK_END);
     const long file_size = ftell(f);
     fseek(f, 8, SEEK_SET);

     if (file_size < 8 || (file_size - 8) % 6 != 0) {
         fclose(f);
         return 0;
     }

     *n = (int)((file_size - 8) / 6);

     PointColor *points =
         (PointColor*)malloc(*n * sizeof(PointColor));

     if (!points) {
         fclose(f);
         return 0;
     }

     for (int i = 0; i < *n; i++) {
         unsigned char p[6];

         if (fread(p, 1, 6, f) != 6) {
             free(points);
             fclose(f);
             return 0;
         }

         const unsigned xy =
             (unsigned)p[0] |
             ((unsigned)p[1] << 8) |
             ((unsigned)p[2] << 16);

         points[i].x = (short)(xy & 1023);
         points[i].y = (short)((xy >> 10) & 1023);

         Color c;
         c.r = p[3];
         c.g = p[4];
         c.b = p[5];
         c.a = 0;

         points[i].color = c.u;
     }

     fclose(f);
     return points;
}


static void BuildGrid(
     PointColor *points,
     int n)
{
     grid_w =
         (frame_size_x + GRID_SIZE - 1) /
         GRID_SIZE;

     grid_h =
         (frame_size_y + GRID_SIZE - 1) /
         GRID_SIZE;

     grid =
         (GridCell*)calloc(
             grid_w * grid_h,
             sizeof(GridCell));


     for (int i = 0; i < n; i++) {

         int gx =
             points[i].x /
             GRID_SIZE;

         int gy =
             points[i].y /
             GRID_SIZE;

         if (gx < 0 ||
             gx >= grid_w ||
             gy < 0 ||
             gy >= grid_h)
             continue;

         grid[
             gy * grid_w + gx
         ].n++;
     }


     for (int i = 0;
          i < grid_w * grid_h;
          i++) {

         if (grid[i].n) {

             int n =
                 grid[i].n;

             grid[i].p =
                 (int*)malloc(
                     n * sizeof(int));

             grid[i].n = 0;
         }
     }


     for (int i = 0; i < n; i++) {

         int gx =
             points[i].x /
             GRID_SIZE;

         int gy =
             points[i].y /
             GRID_SIZE;

         if (gx < 0 ||
             gx >= grid_w ||
             gy < 0 ||
             gy >= grid_h)
             continue;

         GridCell *c =
             &grid[
                 gy * grid_w + gx];

         c->p[c->n++] = i;
     }
}


void InterpolateBitmap(
     PointColor *points,
     int n)
{
     BuildGrid(points, n);

     for (int y = 0;
          y < frame_size_y;
          y++)
         for (int x = 0;
              x < frame_size_x;
              x++)
             SetPixelUnsafe(
                 x,
                 y,
                 InterpolatePixel(
                     points,
                     x,
                     y));

     for (int i = 0;
          i < grid_w * grid_h;
          i++)
         free(grid[i].p);

     free(grid);
     grid = 0;
}


DrawKeyPoints(PointColor *points, int n)
{
	for(int i=0;i<n; i++)
		SetPixelUnsafe(points[i].x, points[i].y, 0x0000);
}


char* args_filename = NULL;

static int LoadSamplesAndDisplay(const char *filename)
{
     int w, h, n;

     PointColor *points =
         LoadSamples(filename, &w, &h, &n);

     if (!points)
         return 0;

     frame_size_x = w;
     frame_size_y = h;

     /*
      * Standard reconstruction.
      * InterpolateBitmap() eventually uses SetPixelUnsafe()
      * for every output pixel.
      */
     InterpolateBitmap(points, n);

     free(points);

     return 1;
}



char* input = "photo1.bmp";

test_opt()
{
     Bitmap bitmap;

     if (!LoadBitmap(
             input,
             &bitmap))
         ERROR_("cant load bitmap");


     grid_w =
         (bitmap.w + GRID_SIZE - 1) /
         GRID_SIZE;

     grid_h =
         (bitmap.h + GRID_SIZE - 1) /
         GRID_SIZE;


     const int grid_n =
         grid_w * grid_h;


     /*
      * Najpierw określ, ile punktów
      * dostaje każdy grid.
      */
     int *points_count =
         BuildPointCounts(
             bitmap.pixels,
             bitmap.stride);


     /*
      * Zsumuj liczbę punktów.
      */
     int N = 0;

     for (int i = 0;
          i < grid_n;
          i++)
         N += points_count[i];


     PointColor *points =
         (PointColor*)malloc(
             N * sizeof(PointColor));


     /*
      * Adaptacyjne rozmieszczenie
      * początkowych próbek.
      */
     RandomSamplesAdaptive(
         points,
         points_count,
         &bitmap);


     OptimizeGridSamples(
         points,
         N,
         points_count,
         bitmap.pixels,
         bitmap.stride);


     DumpSamples(
         "sample.fima",
         points,
         N);


     InterpolateBitmap(
         points,
         N);
		
		
	if(i_toggler) DrawKeyPoints(points, N);	


     free(points_count);
}


test()
{
     Bitmap bitmap;

     if (!LoadBitmap(
             input,
             &bitmap))
         ERROR_("cant load bitmap");


     grid_w =
         (bitmap.w + GRID_SIZE - 1) /
         GRID_SIZE;

     grid_h =
         (bitmap.h + GRID_SIZE - 1) /
         GRID_SIZE;


     const int grid_n =
         grid_w * grid_h;


     int *points_count =
         BuildPointCounts(
             bitmap.pixels,
             bitmap.stride);


     int N = 0;

     for (int i = 0;
          i < grid_n;
          i++)
         N += points_count[i];


     PointColor *points =
         (PointColor*)malloc(
             N * sizeof(PointColor));


     RandomSamplesAdaptive(
         points,
         points_count,
         &bitmap);


     /*
      * OptimizeGridSamples(
      *     points,
      *     N,
      *     points_count,
      *     bitmap.pixels,
      *     bitmap.stride);
      */


     InterpolateBitmap(
         points,
         N);


	if(i_toggler) DrawKeyPoints(points, N);
	
     free(points_count);
}





















void ProcessMouseMove(int x_, int y_){}


void ProcessKeyDown(int key)
{

  if(key==VK_SPACE)
  {
	 test_opt();
  }

  if(key=='A')
	 test();



	
}
void OnResize(){}

void OnRMBDown(int x, int y)
{

}

void OnLMBDown(int x, int y)
{

}

void DrawFrame()
{
	
}


void RunFrame(int advance)
{
	
	static int initialised = 0;
	if(!initialised)
	{
	    initialised =1;
		
		if(args_filename)
		{
         	if (!LoadSamplesAndDisplay(args_filename))
			{
                ERROR_("Failed to load FIMA file: %s\n", args_filename);

			}
		    return;

		}
	

      test();		
		
	}
	

}




int main(int argc, char **argv)
{
        if (argc == 2)
	   {
		   args_filename= argv[1];
		}


         RegisterMouseMove( ProcessMouseMove );
         RegisterKeyDown( ProcessKeyDown );
         RegisterOnResize( OnResize );
         RegisterRunFrame( RunFrame );
         SetSleepValue(10);
         SetScaleOnResize(1);
         RegisterLeftMouseButtonDown( OnLMBDown );
         RegisterRightMouseButtonDown(OnRMBDown );

        float screen_size_y = GetSystemMetrics(SM_CYSCREEN);

         SetupWindow4(" FIR'S INTERPOLATED IMAGE CODECK  ",  10, 10, .9, 
.9, 600 );

         return 0;
}

[toc] | [next] | [standalone]

#402359

From	fir <profesor.fir@gmail.com>
Date	2026-09-24 16:06 +0200
Message-ID	<1193aol$2o3ou$1@dont-email.me>
In reply to	#402356

here are the results (if i not mistaken the links as after upload my
names vanished)

this is this codec with interpolation randomly chosen points (240 kb)

https://relavo.net/v/SZDWh8l

this is the codec after tuning this optimising routine and carefully 
chosen points (same interpolation) (240 kb)

https://relavo.net/v/DGANW4e

this is oryginal bitmap 2.07 MB

https://relavo.net/v/G563DYM

this is jotpeg 113 kb (if im not wrong with files , not carefully 
checked yet... it should be difference compered to oryginal bitmap i guess)

https://relavo.net/v/HotiojQ

[toc] | [prev] | [next] | [standalone]

#402360

From	fir <profesor.fir@gmail.com>
Date	2026-09-24 16:17 +0200
Message-ID	<1193bdv$2odlb$1@dont-email.me>
In reply to	#402359

fir pisze:
> here are the results (if i not mistaken the links as after upload my
> names vanished)
> 
> this is this codec with interpolation randomly chosen points (240 kb)
> 
> https://relavo.net/v/SZDWh8l
> 
> this is the codec after tuning this optimising routine and carefully 
> chosen points (same interpolation) (240 kb)
> 
> https://relavo.net/v/DGANW4e
> 
> this is oryginal bitmap 2.07 MB
> 
> https://relavo.net/v/G563DYM
> 
> this is jotpeg 113 kb (if im not wrong with files , not carefully 
> checked yet... it should be difference compered to oryginal bitmap i guess)
> 
> https://relavo.net/v/HotiojQ
> 

the quetion is ofc how to upgrade this (thou as i coded it in night i
not feel a much urge to improve it but i find its interesting)

note this 240 kb may be simply reduced as i use 6 bytes for
typedef struct {    short x, y;    unsigned color;} PointColor;

where i probably should not store x,y but deltas among pixels in image
(i mean as p = x +width*y and thise linear deltas probably mostly fit in 
one byte or maybe 9 bits so short x,y  (whis i packed to 3 bytes , 12 
bits for each) may be packed in one byte thus leading  to 33% size 
reduction...maybe also some approcha to color pallete can also reduce 
rgba values

[toc] | [prev] | [next] | [standalone]

#402361

From	bart <bc@freeuk.com>
Date	2026-09-24 15:30 +0100
Message-ID	<1193c6q$2on2p$1@dont-email.me>
In reply to	#402356

On 24/09/2026 14:36, fir wrote:
> i once was writing on this -

> #define _WIN32_WINNT 0x0501
> #define WIN32_LEAN_AND_MEAN
> #define WIN32_EXTRA_LEAN
> #include <windows.h>
> #include <Mmsystem.h>
> #include<math.h>
> #include<stdio.h>
> #include<stdlib.h>
> #include <stdint.h>
> 
> #include "green-fire.h"

What's the point of posting a 1200-line program without the headers and 
any other dependencies needed to compile it?

In any case, you should be posting links to github etc for programs this 
big.

> int LoadBitmap(const char *filename, Bitmap *b)
> {

This clashes with LoadBitmap from windows.h (where it is an alias for 
LoadBitmapA). It has a different signature.

How did you manage to get this to compile? Is there some magic in 
green-fire.h that makes it possible?

[toc] | [prev] | [next] | [standalone]

#402362

From	fir <profesor.fir@gmail.com>
Date	2026-09-24 16:45 +0200
Message-ID	<1193d2p$2p051$1@dont-email.me>
In reply to	#402361

bart pisze:
> On 24/09/2026 14:36, fir wrote:
>> i once was writing on this -
> 
>> #define _WIN32_WINNT 0x0501
>> #define WIN32_LEAN_AND_MEAN
>> #define WIN32_EXTRA_LEAN
>> #include <windows.h>
>> #include <Mmsystem.h>
>> #include<math.h>
>> #include<stdio.h>
>> #include<stdlib.h>
>> #include <stdint.h>
>>
>> #include "green-fire.h"
> 
> What's the point of posting a 1200-line program without the headers and 
> any other dependencies needed to compile it?
> 
> In any case, you should be posting links to github etc for programs this 
> big.
> 
>> int LoadBitmap(const char *filename, Bitmap *b)
>> {
> 
> This clashes with LoadBitmap from windows.h (where it is an alias for 
> LoadBitmapA). It has a different signature.
> 
> How did you manage to get this to compile? Is there some magic in 
> green-fire.h that makes it possible?
> 

i dont know its ai generated and just work (its not in green fore - in 
green fire i got a code that setups winapi window, generates frame 
bitmap of point, has some raster based drawing routines, code for 
generating raster fonts from ttf fonts that i can then use to write on 
screen in pixel based scenario, things like that)


BTW as to this code above which AI generated how it work


const int GRID_SIZE = 5;
const int INTERP_K = 3;

const int MIN_POINTS_PER_GRID = 1;
const int MAX_POINTS_PER_GRID = 10;

const int TRIALS = 100; //50
const int OPT_PASSES = 5; //10


it generates a grids of some size GRID_SIZE (5 seem work ok)
and then generates the points   for evary grid cell
(here form 1 to 10) ...though interpolation as far as
it seems only uses INTERP_K  closest points to interpolate given pixel 
color (i experimented and it seem not very much difference with
higher values so here is only 3)

then it makes number of TRIALS  passes to set pioints in grid in random
and trying to search whith base of it fits best (less error compared to
oryginal image) then it yet ises OPT_PASSES  becouse this optimisation 
works inside one grid but the result depend also on 9 near grids so
it is in passesto find for each grid/sells than if those near cells
changed search again

it is all suggested mostly by ai and i thing possibbly there could be 
found something that works much better eventually but no got clear idea 
at the moment

[toc] | [prev] | [next] | [standalone]

#402367

From	"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date	2026-09-24 16:31 -0700
Message-ID	<1194bt1$34dfm$2@dont-email.me>
In reply to	#402362

On 9/24/2026 7:45 AM, fir wrote:
> bart pisze:
>> On 24/09/2026 14:36, fir wrote:
>>> i once was writing on this -
>>
>>> #define _WIN32_WINNT 0x0501
>>> #define WIN32_LEAN_AND_MEAN
>>> #define WIN32_EXTRA_LEAN
>>> #include <windows.h>
>>> #include <Mmsystem.h>
>>> #include<math.h>
>>> #include<stdio.h>
>>> #include<stdlib.h>
>>> #include <stdint.h>
>>>
>>> #include "green-fire.h"
>>
>> What's the point of posting a 1200-line program without the headers 
>> and any other dependencies needed to compile it?
>>
>> In any case, you should be posting links to github etc for programs 
>> this big.
>>
>>> int LoadBitmap(const char *filename, Bitmap *b)
>>> {
>>
>> This clashes with LoadBitmap from windows.h (where it is an alias for 
>> LoadBitmapA). It has a different signature.
>>
>> How did you manage to get this to compile? Is there some magic in 
>> green-fire.h that makes it possible?
>>
> 
> i dont know its ai generated and just work 

PUKE!

[...]

[toc] | [prev] | [next] | [standalone]

#402369

From	fir <profesor.fir@gmail.com>
Date	2026-09-25 02:05 +0200
Message-ID	<1194dsr$3579t$1@dont-email.me>
In reply to	#402367

Chris M. Thomasson pisze:
> On 9/24/2026 7:45 AM, fir wrote:
>> bart pisze:
>>> On 24/09/2026 14:36, fir wrote:
>>>> i once was writing on this -
>>>
>>>> #define _WIN32_WINNT 0x0501
>>>> #define WIN32_LEAN_AND_MEAN
>>>> #define WIN32_EXTRA_LEAN
>>>> #include <windows.h>
>>>> #include <Mmsystem.h>
>>>> #include<math.h>
>>>> #include<stdio.h>
>>>> #include<stdlib.h>
>>>> #include <stdint.h>
>>>>
>>>> #include "green-fire.h"
>>>
>>> What's the point of posting a 1200-line program without the headers 
>>> and any other dependencies needed to compile it?
>>>
>>> In any case, you should be posting links to github etc for programs 
>>> this big.
>>>
>>>> int LoadBitmap(const char *filename, Bitmap *b)
>>>> {
>>>
>>> This clashes with LoadBitmap from windows.h (where it is an alias for 
>>> LoadBitmapA). It has a different signature.
>>>
>>> How did you manage to get this to compile? Is there some magic in 
>>> green-fire.h that makes it possible?
>>>
>>
>> i dont know its ai generated and just work 
> 
> PUKE!
> 
> [...]
> 
i asked ai for answer:

PUKE!
What a magnificent contribution to the discussion.
I can see you're a man of deep technical insight — AI bad, therefore puke.
Do try to contain yourself, old chap. The machines are coming anyway.

[toc] | [prev] | [next] | [standalone]

#402435

From	"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date	2026-09-27 15:05 -0700
Message-ID	<119c3uk$1pt97$1@dont-email.me>
In reply to	#402369

On 9/24/2026 5:05 PM, fir wrote:
> Chris M. Thomasson pisze:
>> On 9/24/2026 7:45 AM, fir wrote:
>>> bart pisze:
>>>> On 24/09/2026 14:36, fir wrote:
>>>>> i once was writing on this -
>>>>
>>>>> #define _WIN32_WINNT 0x0501
>>>>> #define WIN32_LEAN_AND_MEAN
>>>>> #define WIN32_EXTRA_LEAN
>>>>> #include <windows.h>
>>>>> #include <Mmsystem.h>
>>>>> #include<math.h>
>>>>> #include<stdio.h>
>>>>> #include<stdlib.h>
>>>>> #include <stdint.h>
>>>>>
>>>>> #include "green-fire.h"
>>>>
>>>> What's the point of posting a 1200-line program without the headers 
>>>> and any other dependencies needed to compile it?
>>>>
>>>> In any case, you should be posting links to github etc for programs 
>>>> this big.
>>>>
>>>>> int LoadBitmap(const char *filename, Bitmap *b)
>>>>> {
>>>>
>>>> This clashes with LoadBitmap from windows.h (where it is an alias 
>>>> for LoadBitmapA). It has a different signature.
>>>>
>>>> How did you manage to get this to compile? Is there some magic in 
>>>> green-fire.h that makes it possible?
>>>>
>>>
>>> i dont know its ai generated and just work 
>>
>> PUKE!
>>
>> [...]
>>
> i asked ai for answer:
> 
> PUKE!
> What a magnificent contribution to the discussion.
> I can see you're a man of deep technical insight — AI bad, therefore puke.
> Do try to contain yourself, old chap. The machines are coming anyway.

How long have you been on this group rambling about C?

[toc] | [prev] | [next] | [standalone]

#402436

From	bart <bc@freeuk.com>
Date	2026-09-28 00:44 +0100
Message-ID	<119c9p6$1sla6$1@dont-email.me>
In reply to	#402435

On 27/09/2026 23:05, Chris M. Thomasson wrote:
> On 9/24/2026 5:05 PM, fir wrote:
>> Chris M. Thomasson pisze:
>>> On 9/24/2026 7:45 AM, fir wrote:
>>>> bart pisze:
>>>>> On 24/09/2026 14:36, fir wrote:
>>>>>> i once was writing on this -
>>>>>
>>>>>> #define _WIN32_WINNT 0x0501
>>>>>> #define WIN32_LEAN_AND_MEAN
>>>>>> #define WIN32_EXTRA_LEAN
>>>>>> #include <windows.h>
>>>>>> #include <Mmsystem.h>
>>>>>> #include<math.h>
>>>>>> #include<stdio.h>
>>>>>> #include<stdlib.h>
>>>>>> #include <stdint.h>
>>>>>>
>>>>>> #include "green-fire.h"
>>>>>
>>>>> What's the point of posting a 1200-line program without the headers 
>>>>> and any other dependencies needed to compile it?
>>>>>
>>>>> In any case, you should be posting links to github etc for programs 
>>>>> this big.
>>>>>
>>>>>> int LoadBitmap(const char *filename, Bitmap *b)
>>>>>> {
>>>>>
>>>>> This clashes with LoadBitmap from windows.h (where it is an alias 
>>>>> for LoadBitmapA). It has a different signature.
>>>>>
>>>>> How did you manage to get this to compile? Is there some magic in 
>>>>> green-fire.h that makes it possible?
>>>>>
>>>>
>>>> i dont know its ai generated and just work 
>>>
>>> PUKE!
>>>
>>> [...]
>>>
>> i asked ai for answer:
>>
>> PUKE!
>> What a magnificent contribution to the discussion.
>> I can see you're a man of deep technical insight — AI bad, therefore 
>> puke.
>> Do try to contain yourself, old chap. The machines are coming anyway.
> 
> How long have you been on this group rambling about C?

Yeah, maybe he should be having more dialogues with AI than here, as it 
(she?) seems to have all the answers.

Maybe it can reply in a sexy voice too? (I've never used it so don't 
know if it can talk.)

[toc] | [prev] | [next] | [standalone]

#402441

From	fir <profesor.fir@gmail.com>
Date	2026-09-28 04:22 +0200
Message-ID	<119cj2e$1v6p0$1@dont-email.me>
In reply to	#402436

bart pisze:
> On 27/09/2026 23:05, Chris M. Thomasson wrote:
>> On 9/24/2026 5:05 PM, fir wrote:
>>> Chris M. Thomasson pisze:
>>>> On 9/24/2026 7:45 AM, fir wrote:
>>>>> bart pisze:
>>>>>> On 24/09/2026 14:36, fir wrote:
>>>>>>> i once was writing on this -
>>>>>>
>>>>>>> #define _WIN32_WINNT 0x0501
>>>>>>> #define WIN32_LEAN_AND_MEAN
>>>>>>> #define WIN32_EXTRA_LEAN
>>>>>>> #include <windows.h>
>>>>>>> #include <Mmsystem.h>
>>>>>>> #include<math.h>
>>>>>>> #include<stdio.h>
>>>>>>> #include<stdlib.h>
>>>>>>> #include <stdint.h>
>>>>>>>
>>>>>>> #include "green-fire.h"
>>>>>>
>>>>>> What's the point of posting a 1200-line program without the 
>>>>>> headers and any other dependencies needed to compile it?
>>>>>>
>>>>>> In any case, you should be posting links to github etc for 
>>>>>> programs this big.
>>>>>>
>>>>>>> int LoadBitmap(const char *filename, Bitmap *b)
>>>>>>> {
>>>>>>
>>>>>> This clashes with LoadBitmap from windows.h (where it is an alias 
>>>>>> for LoadBitmapA). It has a different signature.
>>>>>>
>>>>>> How did you manage to get this to compile? Is there some magic in 
>>>>>> green-fire.h that makes it possible?
>>>>>>
>>>>>
>>>>> i dont know its ai generated and just work 
>>>>
>>>> PUKE!
>>>>
>>>> [...]
>>>>
>>> i asked ai for answer:
>>>
>>> PUKE!
>>> What a magnificent contribution to the discussion.
>>> I can see you're a man of deep technical insight — AI bad, therefore 
>>> puke.
>>> Do try to contain yourself, old chap. The machines are coming anyway.
>>
>> How long have you been on this group rambling about C?
> 
> Yeah, maybe he should be having more dialogues with AI than here, as it 
> (she?) seems to have all the answers.
> 
> Maybe it can reply in a sexy voice too? (I've never used it so don't 
> know if it can talk.)

its shocking you never used it it is totally amazing in coding...

overally ai is quite shocking but in coding its double..

you simply say "write me procedure for that and that "and she odes it..

a bit more troublesome may be if you tell it to write whole program as 
in my experience for big doses of code at once the probability to have 
soem mistakes seem to increase

(im not much sure though as i usually want it to write pieces of code 
not whole programs

its absolutely medevial today not to use it

[toc] | [prev] | [next] | [standalone]

#402445

From	Paul <nospam@needed.invalid>
Date	2026-09-28 04:27 -0400
Message-ID	<119d8e3$25k85$1@dont-email.me>
In reply to	#402436

On Sun, 9/27/2026 7:44 PM, bart wrote:
> On 27/09/2026 23:05, Chris M. Thomasson wrote:
>> On 9/24/2026 5:05 PM, fir wrote:
>>> Chris M. Thomasson pisze:
>>>> On 9/24/2026 7:45 AM, fir wrote:
>>>>> bart pisze:
>>>>>> On 24/09/2026 14:36, fir wrote:
>>>>>>> i once was writing on this -
>>>>>>
>>>>>>> #define _WIN32_WINNT 0x0501
>>>>>>> #define WIN32_LEAN_AND_MEAN
>>>>>>> #define WIN32_EXTRA_LEAN
>>>>>>> #include <windows.h>
>>>>>>> #include <Mmsystem.h>
>>>>>>> #include<math.h>
>>>>>>> #include<stdio.h>
>>>>>>> #include<stdlib.h>
>>>>>>> #include <stdint.h>
>>>>>>>
>>>>>>> #include "green-fire.h"
>>>>>>
>>>>>> What's the point of posting a 1200-line program without the headers and any other dependencies needed to compile it?
>>>>>>
>>>>>> In any case, you should be posting links to github etc for programs this big.
>>>>>>
>>>>>>> int LoadBitmap(const char *filename, Bitmap *b)
>>>>>>> {
>>>>>>
>>>>>> This clashes with LoadBitmap from windows.h (where it is an alias for LoadBitmapA). It has a different signature.
>>>>>>
>>>>>> How did you manage to get this to compile? Is there some magic in green-fire.h that makes it possible?
>>>>>>
>>>>>
>>>>> i dont know its ai generated and just work 
>>>>
>>>> PUKE!
>>>>
>>>> [...]
>>>>
>>> i asked ai for answer:
>>>
>>> PUKE!
>>> What a magnificent contribution to the discussion.
>>> I can see you're a man of deep technical insight — AI bad, therefore puke.
>>> Do try to contain yourself, old chap. The machines are coming anyway.
>>
>> How long have you been on this group rambling about C?
> 
> Yeah, maybe he should be having more dialogues with AI than here, as it (she?) seems to have all the answers.
> 
> Maybe it can reply in a sexy voice too? (I've never used it so don't know if it can talk.)

Look for the microphone icon in the lower right corner of the interface.
In some scenarios, speech will be available.

An LLM-AI has the ability to mimic a users own voice. That makes
the voice capability "very sexy".

*******

Even if you never intend to work with LLM-AI, at least for the
agentic ones, you should know that

     stop

stops the current operation. DO NOT use more words than that.
Just the one word. That's suited to situations where you
notice the agentic LLM-AI is deleting all your local files :-)

   Paul

[toc] | [prev] | [next] | [standalone]

#402363

From	fir <profesor.fir@gmail.com>
Date	2026-09-24 18:27 +0200
Message-ID	<1193j1g$2rfv9$1@dont-email.me>
In reply to	#402361

bart pisze:
> On 24/09/2026 14:36, fir wrote:
>> i once was writing on this -
> 
>> #define _WIN32_WINNT 0x0501
>> #define WIN32_LEAN_AND_MEAN
>> #define WIN32_EXTRA_LEAN
>> #include <windows.h>
>> #include <Mmsystem.h>
>> #include<math.h>
>> #include<stdio.h>
>> #include<stdlib.h>
>> #include <stdint.h>
>>
>> #include "green-fire.h"
> 
> What's the point of posting a 1200-line program without the headers and 
> any other dependencies needed to compile it?
> 
> In any case, you should be posting links to github etc for programs this 
> big.
> 
>> int LoadBitmap(const char *filename, Bitmap *b)
>> {
> 
> This clashes with LoadBitmap from windows.h (where it is an alias for 
> LoadBitmapA). It has a different signature.
> 
> How did you manage to get this to compile? Is there some magic in 
> green-fire.h that makes it possible?
> 

i checked if the makero LoadBitmap  is defined it seems so,LoadBitmap 
from winapi is

also visible (coz if i comented definitions and only left calls it 
showed error that arguments non compatible

so i dont know..i dont kare for such things as i not use macros in my 
life..it compiles seamlessly

but note i compile is c++ mode (onlu usung it for "const int tab_max")

[toc] | [prev] | [next] | [standalone]

#402378

From	David Brown <david.brown@hesbynett.no>
Date	2026-09-25 10:38 +0200
Message-ID	<1195bti$3bbk8$1@dont-email.me>
In reply to	#402363

On 24/09/2026 18:27, fir wrote:
> bart pisze:
>> On 24/09/2026 14:36, fir wrote:
>>> i once was writing on this -
>>
>>> #define _WIN32_WINNT 0x0501
>>> #define WIN32_LEAN_AND_MEAN
>>> #define WIN32_EXTRA_LEAN
>>> #include <windows.h>
>>> #include <Mmsystem.h>
>>> #include<math.h>
>>> #include<stdio.h>
>>> #include<stdlib.h>
>>> #include <stdint.h>
>>>
>>> #include "green-fire.h"
>>
>> What's the point of posting a 1200-line program without the headers 
>> and any other dependencies needed to compile it?
>>
>> In any case, you should be posting links to github etc for programs 
>> this big.
>>
>>> int LoadBitmap(const char *filename, Bitmap *b)
>>> {
>>
>> This clashes with LoadBitmap from windows.h (where it is an alias for 
>> LoadBitmapA). It has a different signature.
>>
>> How did you manage to get this to compile? Is there some magic in 
>> green-fire.h that makes it possible?
>>
> 
> i checked if the makero LoadBitmap  is defined it seems so,LoadBitmap 
> from winapi is
> 
> also visible (coz if i comented definitions and only left calls it 
> showed error that arguments non compatible
> 
> so i dont know..i dont kare for such things as i not use macros in my 
> life..it compiles seamlessly
> 

Don't be silly.  C macros are part of C programming, whether you like 
them or not - the first line of your posted code is a macro definition! 
And Bart was talking about a macro defined in <windows.h>, not your code.

> but note i compile is c++ mode (onlu usung it for "const int tab_max")
> 

If you are compiling as C++, then you will have C++ linkage and C++ 
mangled names (unless you have an extern "C" in effect).  C++ supports 
function overloading - there is no problem having two functions with the 
same name but different parameters.  If you don't understand this and 
don't know how it works, and randomly mix C code with C++ (or C compiled 
as C++), you will cause yourself confusion.  Use C, or use C++ - and if 
you want to mix some C and some C++ files, do so in an informed and 
intentional manner.

If all you want here is to be able to write something like :

	const int tab_max = 10;
	int table[tab_max];

then in C you can simply use :

	enum { tab_max = 10 };
	int table[tab_max];

or in C23 :

	constexpr int tab_max = 10;
	int table[tab_max];

[toc] | [prev] | [next] | [standalone]

#402380

From	fir <profesor.fir@gmail.com>
Date	2026-09-25 10:57 +0200
Message-ID	<1195d32$3e7vk$1@dont-email.me>
In reply to	#402378

David Brown pisze:
> On 24/09/2026 18:27, fir wrote:
>> bart pisze:
>>> On 24/09/2026 14:36, fir wrote:
>>>> i once was writing on this -
>>>
>>>> #define _WIN32_WINNT 0x0501
>>>> #define WIN32_LEAN_AND_MEAN
>>>> #define WIN32_EXTRA_LEAN
>>>> #include <windows.h>
>>>> #include <Mmsystem.h>
>>>> #include<math.h>
>>>> #include<stdio.h>
>>>> #include<stdlib.h>
>>>> #include <stdint.h>
>>>>
>>>> #include "green-fire.h"
>>>
>>> What's the point of posting a 1200-line program without the headers 
>>> and any other dependencies needed to compile it?
>>>
>>> In any case, you should be posting links to github etc for programs 
>>> this big.
>>>
>>>> int LoadBitmap(const char *filename, Bitmap *b)
>>>> {
>>>
>>> This clashes with LoadBitmap from windows.h (where it is an alias for 
>>> LoadBitmapA). It has a different signature.
>>>
>>> How did you manage to get this to compile? Is there some magic in 
>>> green-fire.h that makes it possible?
>>>
>>
>> i checked if the makero LoadBitmap  is defined it seems so,LoadBitmap 
>> from winapi is
>>
>> also visible (coz if i comented definitions and only left calls it 
>> showed error that arguments non compatible
>>
>> so i dont know..i dont kare for such things as i not use macros in my 
>> life..it compiles seamlessly
>>
> 
> Don't be silly.  C macros are part of C programming, whether you like 
> them or not - the first line of your posted code is a macro definition! 
> And Bart was talking about a macro defined in <windows.h>, not your code.
> 
>> but note i compile is c++ mode (onlu usung it for "const int tab_max")
>>
> 
> If you are compiling as C++, then you will have C++ linkage and C++ 
> mangled names (unless you have an extern "C" in effect).  C++ supports 
> function overloading - there is no problem having two functions with the 
> same name but different parameters.  If you don't understand this and 
> don't know how it works, and randomly mix C code with C++ (or C compiled 
> as C++), you will cause yourself confusion.  Use C, or use C++ - and if 
> you want to mix some C and some C++ files, do so in an informed and 
> intentional manner.
> 
> If all you want here is to be able to write something like :
> 
>      const int tab_max = 10;
>      int table[tab_max];
> 
> then in C you can simply use :
> 
>      enum { tab_max = 10 };
>      int table[tab_max];
> 
> or in C23 :
> 
>      constexpr int tab_max = 10;
>      int table[tab_max];
> 
> 
i dont care too much ..honesty i cant take a clear decision if to
compile in c or c++ mode - i would eventually take one mode if it will
prove soeme clear advantages (like compiling faster , makin less blot in 
exe or making faster executables - things like that)

stylistycally i would slightly more compile in c++ mode becouse of those
consts, also i dont like writying typedef struct and even i consider 
using references whose c++ has (though i not using it yet.. i avoid
using pointers at all but for me a->b syntax is not to stand..but
wide using of references is maybe a bit to big step out of clasic c)

those enums i eventually could use and eventualli i could write
this typedefs so yet i dont know, macros i will not use for sure

this decision is overally not so much big deal as im rather able to
change sources to migrate from this c++ mode into c or otherwise..
seems not so much big deal to me

[toc] | [prev] | [next] | [standalone]

#402379

From	David Brown <david.brown@hesbynett.no>
Date	2026-09-25 10:49 +0200
Message-ID	<1195ci0$3bbk8$2@dont-email.me>
In reply to	#402361

On 24/09/2026 16:30, bart wrote:
> On 24/09/2026 14:36, fir wrote:
>> i once was writing on this -
> 
>> #define _WIN32_WINNT 0x0501
>> #define WIN32_LEAN_AND_MEAN
>> #define WIN32_EXTRA_LEAN
>> #include <windows.h>
>> #include <Mmsystem.h>
>> #include<math.h>
>> #include<stdio.h>
>> #include<stdlib.h>
>> #include <stdint.h>
>>
>> #include "green-fire.h"
> 
> What's the point of posting a 1200-line program without the headers and 
> any other dependencies needed to compile it?
> 
> In any case, you should be posting links to github etc for programs this 
> big.
> 
>> int LoadBitmap(const char *filename, Bitmap *b)
>> {
> 
> This clashes with LoadBitmap from windows.h (where it is an alias for 
> LoadBitmapA). It has a different signature.
> 
> How did you manage to get this to compile? Is there some magic in green- 
> fire.h that makes it possible?
> 
> 

What do you mean by "alias" here ?  Do you mean a macro?  A small static 
inline function?  An identifier defined with an "alias" attribute 
(that's a gcc attribute, but I have no idea if it works on Windows 
targets) ?  A C++ constexpr function alias?

How this will work or not depends on what you mean.

And of course it depends on which <windows.h> is used - it is not a 
remotely standardised header, and details vary enormously with different 
toolchains, libraries, versions, etc.

Obviously Fir needs to answer much of this.

[toc] | [prev] | [next] | [standalone]

#402382

From	bart <bc@freeuk.com>
Date	2026-09-25 10:49 +0100
Message-ID	<1195g3h$3fbp8$1@dont-email.me>
In reply to	#402379

On 25/09/2026 09:49, David Brown wrote:
> On 24/09/2026 16:30, bart wrote:
>> On 24/09/2026 14:36, fir wrote:
>>> i once was writing on this -
>>
>>> #define _WIN32_WINNT 0x0501
>>> #define WIN32_LEAN_AND_MEAN
>>> #define WIN32_EXTRA_LEAN
>>> #include <windows.h>
>>> #include <Mmsystem.h>
>>> #include<math.h>
>>> #include<stdio.h>
>>> #include<stdlib.h>
>>> #include <stdint.h>
>>>
>>> #include "green-fire.h"
>>
>> What's the point of posting a 1200-line program without the headers 
>> and any other dependencies needed to compile it?
>>
>> In any case, you should be posting links to github etc for programs 
>> this big.
>>
>>> int LoadBitmap(const char *filename, Bitmap *b)
>>> {
>>
>> This clashes with LoadBitmap from windows.h (where it is an alias for 
>> LoadBitmapA). It has a different signature.
>>
>> How did you manage to get this to compile? Is there some magic in 
>> green- fire.h that makes it possible?
>>
>>
> 
> What do you mean by "alias" here ?  Do you mean a macro?  A small static 
> inline function?  An identifier defined with an "alias" attribute 
> (that's a gcc attribute, but I have no idea if it works on Windows 
> targets) ?  A C++ constexpr function alias?

It will usually be this:

   #ifdef UNICODE
   ...
   #define LoadBitmap LoadBitmapW
   ...
   #else
  ...
   #define LoadBitmap LoadBitmapA
   ...

'UNICODE' is nearly always undefined. These aliases exist for pretty 
much every function takes or returns strings. The MS docs say this:

"The winuser.h header defines LoadBitmap as an alias that automatically 
selects the ANSI or Unicode version of this function based on the 
definition of the UNICODE preprocessor constant."

winuser.h will be part of the headers invoked by windows.h. But some C 
compilers use a monolithic windows.h and it will be in there.

Ones like gcc will use a collection 90 headers, and MSVC some 160 
headers (or vice versa, as observed in 2017).

[toc] | [prev] | [next] | [standalone]

#402386

From	Jim Jackson <jj@franjam.org.uk>
Date	2026-09-25 12:01 +0000
Message-ID	<slrn11bcoju.2ji.jj@iridium.wf32df>
In reply to	#402379

>
> Obviously Fir needs to answer much of this.

even if he does, what are the chances that it makes sense? Save your energy.

[toc] | [prev] | [next] | [standalone]

#402400

From	fir <profesor.fir@gmail.com>
Date	2026-09-26 02:51 +0200
Message-ID	<11974vt$31i5$1@dont-email.me>
In reply to	#402386

Jim Jackson pisze:
>>
>> Obviously Fir needs to answer much of this.
> 
> even if he does, what are the chances that it makes sense? Save your energy.
> 

there is some mental death in such kind of sentences.. you should avoid 
it for sure ( some here may be not so resistant to such mental death rays)

[toc] | [prev] | [next] | [standalone]

#402574

From	Johann 'Myrkraverk' Oskarsson <johann@myrkraverk.invalid>
Date	2026-10-01 00:08 +0800
Message-ID	<5uavS.240$Waxd.222@fx17.ams4>
In reply to	#402356

On 9/24/2026 9:36 PM, fir wrote:
> i once was writing on this -
> the idea is take bitmap (like 960x540) take some pixels of it
> (in practice i take liek 2% maybe 5% random pixels store it as a file
> (new image codec) and interpolate it to recreate the image
> 
> i just wonder how it would work..
> it was a bit to tedious to write it alone but in present times you just
> say it to chat gpt and it practically write it to yourself

Dear fir,

I have a copy of the 1993 /JPEG/ book.  You know, the one that explains
the standard, and the image manipulation behind it.  Please forgive me
for not just quoting the entire book.

Anyway, the reason I bring it up is, if you try to code an image codec
with ChatGPT, what are the chances [1] it'll just spew JPEG at you?  And
if you haven't read the book, would you know it?

Best wishes, and happy image codecs!

[1] This is a rhetorical question, I have no interest in the actual sta-
tistics.
-- 
Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
I'm not from the Internet, I just work there. | via Easynews.com
https://bsky.app/profile/myrkraverk.bsky.social | for ( ;; ) _:;
Federated at https://fed.brid.gy/bsky/myrkraverk.bsky.social

[toc] | [prev] | [standalone]

csiph-web

[c+ai] one night with image codec

Contents

#402356 — [c+ai] one night with image codec

#402359

#402360

#402361

#402362

#402367

#402369

#402435

#402436

#402441

#402445

#402363

#402378

#402380

#402379

#402382

#402386

#402400

#402574