CV/CV.xs

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include <gdk-pixbuf/gdk-pixbuf.h>

#include <gperl.h>
#include <gtk2perl.h>

#define IW 80

#define RAND (seed = (seed + 7141) * 54773 % 134456)

#define LINELENGTH 240

#define ELLIPSIS "\xe2\x80\xa6"

static guint32 a85_val;
static guint a85_cnt;
static guchar a85_buf[LINELENGTH], *a85_ptr;

static void
a85_init (void)
{
  a85_cnt = 4;
  a85_ptr = a85_buf;
}

static void
a85_push (PerlIO *fp, guchar c)
{
  a85_val = a85_val << 8 | c;

  if (!--a85_cnt)
    {
      a85_cnt = 4;
      if (a85_val)
        {
          a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85; 
          a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85; 
          a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85; 
          a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
          a85_ptr[0] = (a85_val     ) + 33;

          a85_ptr += 5;
        }
      else
        *a85_ptr++ = 'z';

      if (a85_ptr >= a85_buf + sizeof (a85_buf) - 7)
        {
          *a85_ptr++ = '\n';
          PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
          a85_ptr = a85_buf;
        }
    }
    
}

a85_finish (PerlIO *fp)
{
  while (a85_cnt != 4)
    a85_push (fp, 0);

  *a85_ptr++ = '~'; // probably buggy end-marker
  *a85_ptr++ = '>'; // probably buggy end-marker
  *a85_ptr++ = '\n';

  PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
}

/////////////////////////////////////////////////////////////////////////////

MODULE = Gtk2::CV PACKAGE = Gtk2::CV::ImageWindow

PROTOTYPES: ENABLE

GdkPixbuf_noinc *
transpose (GdkPixbuf *pb)
        CODE:
{
        int w = gdk_pixbuf_get_width (pb);
        int h = gdk_pixbuf_get_height (pb);
        int bpp = gdk_pixbuf_get_n_channels (pb);
        int x, y, i;
        guchar *src = gdk_pixbuf_get_pixels (pb), *dst;
        int sstr = gdk_pixbuf_get_rowstride (pb), dstr;

        RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, h, w);

        dst = gdk_pixbuf_get_pixels (RETVAL);
        dstr = gdk_pixbuf_get_rowstride (RETVAL);

        for (y = 0; y < h; y++)
          for (x = 0; x < w; x++)
            for (i = 0; i < bpp; i++)
              dst[y * bpp + x * dstr + i] = src[x * bpp + y * sstr + i];
}
        OUTPUT:
        RETVAL

GdkPixbuf_noinc *
flop (GdkPixbuf *pb)
        CODE:
{
        int w = gdk_pixbuf_get_width (pb);
        int h = gdk_pixbuf_get_height (pb);
        int bpp = gdk_pixbuf_get_n_channels (pb);
        int x, y, i;
        guchar *src = gdk_pixbuf_get_pixels (pb), *dst;
        int sstr = gdk_pixbuf_get_rowstride (pb), dstr;

        RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, w, h);

        dst = gdk_pixbuf_get_pixels (RETVAL);
        dstr = gdk_pixbuf_get_rowstride (RETVAL);

        for (y = 0; y < h; y++)
          for (x = 0; x < w; x++)
            for (i = 0; i < bpp; i++)
              dst[(w - 1 - x) * bpp + y * dstr + i] = src[x * bpp + y * sstr + i];
}
        OUTPUT:
        RETVAL

#############################################################################

MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer

GdkPixbuf_noinc *
p7_to_pb (int w, int h, guchar *src)
        CODE:
{
        int x, y;
        guchar *dst, *d;
        int dstr;

        RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8,  w, h);
        dst = gdk_pixbuf_get_pixels (RETVAL);
        dstr = gdk_pixbuf_get_rowstride (RETVAL);

        for (y = 0; y < h; y++)
          for (d = dst + y * dstr, x = 0; x < w; x++)
            {
              *d++ = (((*src >> 5) & 7) * 255 + 4) / 7;
              *d++ = (((*src >> 2) & 7) * 255 + 4) / 7;
              *d++ = (((*src >> 0) & 3) * 255 + 2) / 3;

              src++;
            }
}
        OUTPUT:
        RETVAL

SV *
pb_to_p7 (GdkPixbuf *pb)
        CODE:
{
        int w = gdk_pixbuf_get_width  (pb);
        int h = gdk_pixbuf_get_height (pb);
        int x, y;
        guchar *dst;
        int bpp = gdk_pixbuf_get_n_channels (pb);
        guchar *src = gdk_pixbuf_get_pixels (pb);
        int sstr = gdk_pixbuf_get_rowstride (pb);
        int Er[IW], Eg[IW], Eb[IW];
        int seed = 77;

        RETVAL = newSV (w * h);
        SvPOK_only (RETVAL);
        SvCUR_set (RETVAL, w * h);

        dst = SvPVX (RETVAL);

        memset (Er, 0, sizeof (int) * IW);
        memset (Eg, 0, sizeof (int) * IW);
        memset (Eb, 0, sizeof (int) * IW);

        /* some primitive error distribution + random dithering */

        for (y = 0; y < h; y++)
          {
            int er = 0, eg = 0, eb = 0;

            for (x = 0; x < w; x++)
              {
                int r, g, b;
                guchar *p = src + x * bpp + y * sstr;

                r = ((p[0] + er + Er[x]) * 7 + 128) / 255;
                g = ((p[1] + eg + Eg[x]) * 7 + 128) / 255;
                b = ((p[2] + eb + Eb[x]) * 3 + 128) / 255;

                r = r > 7 ? 7 : r < 0 ? 0 : r;
                g = g > 7 ? 7 : g < 0 ? 0 : g;
                b = b > 3 ? 3 : b < 0 ? 0 : b;

                er += p[0] - (r * 255 + 4) / 7;
                eg += p[1] - (g * 255 + 4) / 7;
                eb += p[2] - (b * 255 + 2) / 3;

                Er[x] = er / 2; er -= er / 2 + RAND % 7 - 3;
                Eg[x] = eg / 2; eg -= eg / 2 + RAND % 7 - 3;
                Eb[x] = eb / 2; eb -= eb / 2 + RAND % 7 - 3;

                *dst++ = r << 5 | g << 2 | b;
              }
          }
}
        OUTPUT:
        RETVAL

#############################################################################

MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript

void
dump_ascii85 (PerlIO *fp, GdkPixbuf *pb)
        CODE:
{
        int w = gdk_pixbuf_get_width  (pb);
        int h = gdk_pixbuf_get_height (pb);
        int x, y, i;
        guchar *dst;
        int bpp = gdk_pixbuf_get_n_channels (pb);
        guchar *src = gdk_pixbuf_get_pixels (pb);
        int sstr = gdk_pixbuf_get_rowstride (pb);

        a85_init ();

        for (y = 0; y < h; y++)
          for (x = 0; x < w; x++)
            for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
              a85_push (fp, src [x * bpp + y * sstr + i]);

        a85_finish (fp);
}

void
dump_binary (PerlIO *fp, GdkPixbuf *pb)
        CODE:
{
        int w = gdk_pixbuf_get_width  (pb);
        int h = gdk_pixbuf_get_height (pb);
        int x, y, i;
        guchar *dst;
        int bpp = gdk_pixbuf_get_n_channels (pb);
        guchar *src = gdk_pixbuf_get_pixels (pb);
        int sstr = gdk_pixbuf_get_rowstride (pb);

        for (y = 0; y < h; y++)
          for (x = 0; x < w; x++)
            for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
              PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
}


Revision:	1.7
Committed:	Wed Nov 12 23:54:54 2003 UTC (20 years, 6 months ago) by root
Branch:	MAIN
Changes since 1.6:	+27 -7 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include "EXTERN.h"
2			#include "perl.h"
3			#include "XSUB.h"
4
5	root	1.2	#include <gdk-pixbuf/gdk-pixbuf.h>
6
7			#include <gperl.h>
8			#include <gtk2perl.h>
9
10	root	1.5	#define IW 80
11
12			#define RAND (seed = (seed + 7141) * 54773 % 134456)
13
14	root	1.7	#define LINELENGTH 240
15
16	root	1.6	#define ELLIPSIS "\xe2\x80\xa6"
17
18	root	1.4	static guint32 a85_val;
19			static guint a85_cnt;
20	root	1.7	static guchar a85_buf[LINELENGTH], *a85_ptr;
21	root	1.4
22			static void
23			a85_init (void)
24			{
25			a85_cnt = 4;
26			a85_ptr = a85_buf;
27			}
28
29			static void
30			a85_push (PerlIO *fp, guchar c)
31			{
32			a85_val = a85_val << 8 \| c;
33
34			if (!--a85_cnt)
35			{
36			a85_cnt = 4;
37			if (a85_val)
38			{
39			a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
40			a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
41			a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
42			a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
43			a85_ptr[0] = (a85_val ) + 33;
44
45			a85_ptr += 5;
46			}
47			else
48			*a85_ptr++ = 'z';
49
50			if (a85_ptr >= a85_buf + sizeof (a85_buf) - 7)
51			{
52			*a85_ptr++ = '\n';
53			PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
54			a85_ptr = a85_buf;
55			}
56			}
57
58			}
59
60			a85_finish (PerlIO *fp)
61			{
62			while (a85_cnt != 4)
63			a85_push (fp, 0);
64
65			*a85_ptr++ = '~'; // probably buggy end-marker
66			*a85_ptr++ = '>'; // probably buggy end-marker
67			*a85_ptr++ = '\n';
68
69			PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
70			}
71
72	root	1.6	/////////////////////////////////////////////////////////////////////////////
73
74	root	1.1	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::ImageWindow
75
76			PROTOTYPES: ENABLE
77	root	1.2
78	root	1.3	GdkPixbuf_noinc *
79	root	1.2	transpose (GdkPixbuf *pb)
80			CODE:
81			{
82			int w = gdk_pixbuf_get_width (pb);
83			int h = gdk_pixbuf_get_height (pb);
84	root	1.7	int bpp = gdk_pixbuf_get_n_channels (pb);
85	root	1.2	int x, y, i;
86			guchar src = gdk_pixbuf_get_pixels (pb), dst;
87			int sstr = gdk_pixbuf_get_rowstride (pb), dstr;
88
89			RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, h, w);
90
91			dst = gdk_pixbuf_get_pixels (RETVAL);
92			dstr = gdk_pixbuf_get_rowstride (RETVAL);
93
94	root	1.3	for (y = 0; y < h; y++)
95			for (x = 0; x < w; x++)
96	root	1.2	for (i = 0; i < bpp; i++)
97			dst[y * bpp + x * dstr + i] = src[x * bpp + y * sstr + i];
98			}
99			OUTPUT:
100			RETVAL
101
102	root	1.3	GdkPixbuf_noinc *
103	root	1.2	flop (GdkPixbuf *pb)
104			CODE:
105			{
106			int w = gdk_pixbuf_get_width (pb);
107			int h = gdk_pixbuf_get_height (pb);
108	root	1.7	int bpp = gdk_pixbuf_get_n_channels (pb);
109	root	1.2	int x, y, i;
110			guchar src = gdk_pixbuf_get_pixels (pb), dst;
111			int sstr = gdk_pixbuf_get_rowstride (pb), dstr;
112
113			RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, w, h);
114
115			dst = gdk_pixbuf_get_pixels (RETVAL);
116			dstr = gdk_pixbuf_get_rowstride (RETVAL);
117
118	root	1.3	for (y = 0; y < h; y++)
119			for (x = 0; x < w; x++)
120	root	1.2	for (i = 0; i < bpp; i++)
121	root	1.4	dst[(w - 1 - x) * bpp + y * dstr + i] = src[x * bpp + y * sstr + i];
122	root	1.2	}
123			OUTPUT:
124			RETVAL
125
126	root	1.6	#############################################################################
127
128	root	1.2	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer
129
130	root	1.3	GdkPixbuf_noinc *
131	root	1.2	p7_to_pb (int w, int h, guchar *src)
132			CODE:
133			{
134			int x, y;
135			guchar dst, d;
136			int dstr;
137
138			RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
139			dst = gdk_pixbuf_get_pixels (RETVAL);
140			dstr = gdk_pixbuf_get_rowstride (RETVAL);
141
142			for (y = 0; y < h; y++)
143			for (d = dst + y * dstr, x = 0; x < w; x++)
144			{
145	root	1.3	d++ = (((src >> 5) & 7) * 255 + 4) / 7;
146			d++ = (((src >> 2) & 7) * 255 + 4) / 7;
147			d++ = (((src >> 0) & 3) * 255 + 2) / 3;
148	root	1.2
149			src++;
150			}
151	root	1.3	}
152			OUTPUT:
153			RETVAL
154
155			SV *
156			pb_to_p7 (GdkPixbuf *pb)
157			CODE:
158			{
159			int w = gdk_pixbuf_get_width (pb);
160			int h = gdk_pixbuf_get_height (pb);
161			int x, y;
162			guchar *dst;
163	root	1.7	int bpp = gdk_pixbuf_get_n_channels (pb);
164	root	1.3	guchar *src = gdk_pixbuf_get_pixels (pb);
165			int sstr = gdk_pixbuf_get_rowstride (pb);
166	root	1.5	int Er[IW], Eg[IW], Eb[IW];
167			int seed = 77;
168	root	1.3
169			RETVAL = newSV (w * h);
170			SvPOK_only (RETVAL);
171			SvCUR_set (RETVAL, w * h);
172
173			dst = SvPVX (RETVAL);
174
175	root	1.5	memset (Er, 0, sizeof (int) * IW);
176			memset (Eg, 0, sizeof (int) * IW);
177			memset (Eb, 0, sizeof (int) * IW);
178
179			/* some primitive error distribution + random dithering */
180
181	root	1.3	for (y = 0; y < h; y++)
182			{
183			int er = 0, eg = 0, eb = 0;
184
185			for (x = 0; x < w; x++)
186			{
187			int r, g, b;
188			guchar p = src + x bpp + y * sstr;
189
190	root	1.5	r = ((p[0] + er + Er[x]) * 7 + 128) / 255;
191			g = ((p[1] + eg + Eg[x]) * 7 + 128) / 255;
192			b = ((p[2] + eb + Eb[x]) * 3 + 128) / 255;
193	root	1.3
194			r = r > 7 ? 7 : r < 0 ? 0 : r;
195			g = g > 7 ? 7 : g < 0 ? 0 : g;
196			b = b > 3 ? 3 : b < 0 ? 0 : b;
197
198			er += p[0] - (r * 255 + 4) / 7;
199			eg += p[1] - (g * 255 + 4) / 7;
200			eb += p[2] - (b * 255 + 2) / 3;
201	root	1.5
202			Er[x] = er / 2; er -= er / 2 + RAND % 7 - 3;
203			Eg[x] = eg / 2; eg -= eg / 2 + RAND % 7 - 3;
204			Eb[x] = eb / 2; eb -= eb / 2 + RAND % 7 - 3;
205	root	1.3
206			*dst++ = r << 5 \| g << 2 \| b;
207			}
208			}
209	root	1.2	}
210			OUTPUT:
211			RETVAL
212	root	1.6
213			#############################################################################
214	root	1.4
215			MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
216
217			void
218	root	1.7	dump_ascii85 (PerlIO fp, GdkPixbuf pb)
219	root	1.4	CODE:
220			{
221			int w = gdk_pixbuf_get_width (pb);
222			int h = gdk_pixbuf_get_height (pb);
223			int x, y, i;
224			guchar *dst;
225	root	1.7	int bpp = gdk_pixbuf_get_n_channels (pb);
226	root	1.4	guchar *src = gdk_pixbuf_get_pixels (pb);
227			int sstr = gdk_pixbuf_get_rowstride (pb);
228
229			a85_init ();
230
231			for (y = 0; y < h; y++)
232			for (x = 0; x < w; x++)
233	root	1.7	for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
234	root	1.4	a85_push (fp, src [x * bpp + y * sstr + i]);
235
236			a85_finish (fp);
237	root	1.7	}
238
239			void
240			dump_binary (PerlIO fp, GdkPixbuf pb)
241			CODE:
242			{
243			int w = gdk_pixbuf_get_width (pb);
244			int h = gdk_pixbuf_get_height (pb);
245			int x, y, i;
246			guchar *dst;
247			int bpp = gdk_pixbuf_get_n_channels (pb);
248			guchar *src = gdk_pixbuf_get_pixels (pb);
249			int sstr = gdk_pixbuf_get_rowstride (pb);
250
251			for (y = 0; y < h; y++)
252			for (x = 0; x < w; x++)
253			for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
254			PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
255	root	1.4	}
256
257	root	1.2
258	root	1.1
259