1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/*
* io_ss.c
*
* Implements the Source/Sink interface.
*
* As will all I/O modules, most functions are for local use only (called
* via function pointers in the I/O context).
*
* The Source/Sink model is the primary 'user' interface for alternate data
* sources; the IOCtx interface is intended (at least in version 1.5) to be
* used internally until it settles down a bit.
*
* This module just layers the Source/Sink interface on top of the IOCtx; no
* support is provided for tell/seek, so GD2 writing is not possible, and
* retrieving parts of GD2 files is also not possible.
*
* A new SS context does not need to be created with both a Source and a Sink.
*
* Written/Modified 1999, Philip Warner.
*
*/
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "gd.h"
#include "gdhelpers.h"
/* this is used for creating images in main memory */
typedef struct ssIOCtx
{
gdIOCtx ctx;
gdSourcePtr src;
gdSinkPtr snk;
} ssIOCtx;
typedef struct ssIOCtx *ssIOCtxPtr;
gdIOCtx *gdNewSSCtx (gdSourcePtr src, gdSinkPtr snk);
static int sourceGetbuf (gdIOCtx *, void *, int);
static int sourceGetchar (gdIOCtx * ctx);
static int sinkPutbuf (gdIOCtx * ctx, const void *buf, int size);
static void sinkPutchar (gdIOCtx * ctx, int a);
static void gdFreeSsCtx (gdIOCtx * ctx);
/* return data as a dynamic pointer */
gdIOCtx * gdNewSSCtx (gdSourcePtr src, gdSinkPtr snk)
{
ssIOCtxPtr ctx;
ctx = (ssIOCtxPtr) gdMalloc (sizeof (ssIOCtx));
ctx->src = src;
ctx->snk = snk;
ctx->ctx.getC = sourceGetchar;
ctx->ctx.getBuf = sourceGetbuf;
ctx->ctx.putC = sinkPutchar;
ctx->ctx.putBuf = sinkPutbuf;
ctx->ctx.tell = NULL;
ctx->ctx.seek = NULL;
ctx->ctx.gd_free = gdFreeSsCtx;
return (gdIOCtx *) ctx;
}
static void gdFreeSsCtx (gdIOCtx * ctx)
{
gdFree(ctx);
}
static int sourceGetbuf (gdIOCtx * ctx, void *buf, int size)
{
ssIOCtx *lctx;
int res;
lctx = (ssIOCtx *) ctx;
res = ((lctx->src->source) (lctx->src->context, buf, size));
/*
* Translate the return values from the Source object:
* 0 is EOF, -1 is error
*/
if (res == 0) {
return EOF;
} else if (res < 0) {
return 0;
} else {
return res;
}
}
static int sourceGetchar (gdIOCtx * ctx)
{
int res;
unsigned char buf;
res = sourceGetbuf (ctx, &buf, 1);
if (res == 1) {
return buf;
} else {
return EOF;
}
}
static int sinkPutbuf (gdIOCtx * ctx, const void *buf, int size)
{
ssIOCtxPtr lctx;
int res;
lctx = (ssIOCtx *) ctx;
res = (lctx->snk->sink) (lctx->snk->context, buf, size);
if (res <= 0) {
return 0;
} else {
return res;
}
}
static void sinkPutchar (gdIOCtx * ctx, int a)
{
unsigned char b;
b = a;
sinkPutbuf (ctx, &b, 1);
}
|
