← Back to branch summary

~ubuntu-branches/ubuntu/hoary/kdemultimedia/hoary

« back to all changes in this revision

Viewing changes to mpg123_artsplugin/mpg123/xfermem.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Schulze
  • Date: 2003-01-22 15:00:51 UTC
  • Revision ID: james.westby@ubuntu.com-20030122150051-uihwkdoxf15mi1tn
Tags: upstream-2.2.2
Import upstream version 2.2.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
mpg123_artsplugin/mpg123/xfermem.c
 
1
/*
 
2
 *   xfermem.c
 
3
 *
 
4
 *   Oliver Fromme  <oliver.fromme@heim3.tu-clausthal.de>
 
5
 *   Sun Apr  6 02:26:26 MET DST 1997
 
6
 *
 
7
 *   See xfermem.h for documentation/description.
 
8
 */
 
9
 
 
10
#ifndef NOXFERMEM
 
11
 
 
12
#include <stdio.h>
 
13
#include <stdlib.h>
 
14
#include <string.h>
 
15
#include <unistd.h>
 
16
#include <errno.h>
 
17
#include <sys/types.h>
 
18
#include <sys/time.h>
 
19
#include <sys/uio.h>
 
20
#include <sys/mman.h>
 
21
#include <sys/socket.h>
 
22
#include <fcntl.h>
 
23
 
 
24
#ifdef AIX
 
25
#include <sys/select.h>
 
26
#endif
 
27
 
 
28
#include "mpg123.h"
 
29
 
 
30
#ifndef USE_MMAP
 
31
#include <sys/ipc.h>
 
32
#include <sys/shm.h>
 
33
#endif
 
34
 
 
35
extern int errno;
 
36
 
 
37
#if defined (USE_MMAP) && defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
 
38
#define MAP_ANON MAP_ANONYMOUS
 
39
#endif
 
40
 
 
41
void xfermem_init (txfermem **xf, int bufsize, int msize, int skipbuf)
 
42
{
 
43
        int regsize = bufsize + msize + skipbuf + sizeof(txfermem);
 
44
        extern int preload;
 
45
 
 
46
#ifdef USE_MMAP
 
47
#  ifdef MAP_ANON
 
48
        if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE,
 
49
                        MAP_ANON | MAP_SHARED, -1, 0)) == (txfermem *) -1) {
 
50
                perror ("mmap()");
 
51
                exit (1);
 
52
        }
 
53
#  else
 
54
        int devzero;
 
55
        if ((devzero = open("/dev/zero", O_RDWR, 0)) == -1) {
 
56
                perror ("open(/dev/zero)");
 
57
                exit (1);
 
58
        }
 
59
        if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE,
 
60
                        MAP_SHARED, devzero, 0)) == (txfermem *) -1) {
 
61
                perror ("mmap()");
 
62
                exit (1);
 
63
        }
 
64
        close (devzero);
 
65
#  endif
 
66
#else
 
67
        struct shmid_ds shmemds;
 
68
        int shmemid;
 
69
        if ((shmemid = shmget(IPC_PRIVATE, regsize, IPC_CREAT | 0600)) == -1) {
 
70
                perror ("shmget()");
 
71
                exit (1);
 
72
        }
 
73
        if ((*xf = (txfermem *) shmat(shmemid, 0, 0)) == (txfermem *) -1) {
 
74
                perror ("shmat()");
 
75
                shmctl (shmemid, IPC_RMID, &shmemds);
 
76
                exit (1);
 
77
        }
 
78
        if (shmctl(shmemid, IPC_RMID, &shmemds) == -1) {
 
79
                perror ("shmctl()");
 
80
                xfermem_done (*xf);
 
81
                exit (1);
 
82
        }
 
83
#endif
 
84
        if (socketpair(AF_UNIX, SOCK_STREAM, 0, (*xf)->fd) < 0) {
 
85
                perror ("socketpair()");
 
86
                xfermem_done (*xf);
 
87
                exit (1);
 
88
        }
 
89
        (*xf)->freeindex = (*xf)->readindex = 0;
 
90
        (*xf)->wakeme[0] = (*xf)->wakeme[1] = FALSE;
 
91
        (*xf)->data = ((byte *) *xf) + sizeof(txfermem) + msize;
 
92
        (*xf)->metadata = ((byte *) *xf) + sizeof(txfermem);
 
93
        (*xf)->size = bufsize;
 
94
        (*xf)->metasize = msize + skipbuf;
 
95
        preload = bufsize>>3;
 
96
}
 
97
 
 
98
void xfermem_done (txfermem *xf)
 
99
{
 
100
        if(!xf)
 
101
                return;
 
102
#ifdef USE_MMAP
 
103
        munmap ((caddr_t) xf, xf->size + xf->metasize + sizeof(txfermem));
 
104
#else
 
105
        if (shmdt((void *) xf) == -1) {
 
106
                perror ("shmdt()");
 
107
                exit (1);
 
108
        }
 
109
#endif
 
110
}
 
111
 
 
112
void xfermem_init_writer (txfermem *xf)
 
113
{
 
114
        if(xf)
 
115
                close (xf->fd[XF_READER]);
 
116
}
 
117
 
 
118
void xfermem_init_reader (txfermem *xf)
 
119
{
 
120
        if(xf)
 
121
                close (xf->fd[XF_WRITER]);
 
122
}
 
123
 
 
124
int xfermem_get_freespace (txfermem *xf)
 
125
{
 
126
        int freeindex, readindex;
 
127
 
 
128
        if(!xf)
 
129
                return 0;
 
130
 
 
131
        if ((freeindex = xf->freeindex) < 0
 
132
                        || (readindex = xf->readindex) < 0)
 
133
                return (0);
 
134
        if (readindex > freeindex)
 
135
                return ((readindex - freeindex) - 1);
 
136
        else
 
137
                return ((xf->size - (freeindex - readindex)) - 1);
 
138
}
 
139
 
 
140
int xfermem_get_usedspace (txfermem *xf)
 
141
{
 
142
        int freeindex, readindex;
 
143
 
 
144
        if(!xf)
 
145
                return 0;
 
146
 
 
147
        if ((freeindex = xf->freeindex) < 0
 
148
                        || (readindex = xf->readindex) < 0)
 
149
                return (0);
 
150
        if (freeindex >= readindex)
 
151
                return (freeindex - readindex);
 
152
        else
 
153
                return (xf->size - (readindex - freeindex));
 
154
}
 
155
 
 
156
int xfermem_getcmd (int fd, int block)
 
157
{
 
158
        fd_set selfds;
 
159
        byte cmd;
 
160
 
 
161
        for (;;) {
 
162
                struct timeval selto = {0, 0};
 
163
 
 
164
                FD_ZERO (&selfds);
 
165
                FD_SET (fd, &selfds);
 
166
                /* #ifdef HPUX */ /* seems to trigger performance problems? strange */
 
167
#if 0
 
168
                switch (select(FD_SETSIZE, (int *) &selfds, NULL, NULL, block ? NULL : &selto)) {
 
169
#else
 
170
                switch (select(FD_SETSIZE, &selfds, NULL, NULL, block ? NULL : &selto)) {
 
171
#endif
 
172
                        case 0:
 
173
                                if (!block)
 
174
                                        return (0);
 
175
                                continue;
 
176
                        case -1:
 
177
                                if (errno == EINTR)
 
178
                                        continue;
 
179
                                return (-2);
 
180
                        case 1:
 
181
                                if (FD_ISSET(fd, &selfds))
 
182
                                        switch (read(fd, &cmd, 1)) {
 
183
                                                case 0: /* EOF */
 
184
                                                        return (-1);
 
185
                                                case -1:
 
186
                                                        if (errno == EINTR)
 
187
                                                                continue;
 
188
                                                        return (-3);
 
189
                                                case 1:
 
190
                                                        return (cmd);
 
191
                                                default: /* ?!? */
 
192
                                                        return (-4);
 
193
                                        }
 
194
                                else /* ?!? */
 
195
                                        return (-5);
 
196
                        default: /* ?!? */
 
197
                                return (-6);
 
198
                }
 
199
        }
 
200
}
 
201
 
 
202
int xfermem_putcmd (int fd, byte cmd)
 
203
{
 
204
        for (;;) {
 
205
                switch (write(fd, &cmd, 1)) {
 
206
                        case 1:
 
207
                                return (1);
 
208
                        case -1:
 
209
                                if (errno != EINTR)
 
210
                                        return (-1);
 
211
                }
 
212
        }
 
213
}
 
214
 
 
215
int xfermem_block (int readwrite, txfermem *xf)
 
216
{
 
217
        int myfd = xf->fd[readwrite];
 
218
        int result;
 
219
 
 
220
        xf->wakeme[readwrite] = TRUE;
 
221
        if (xf->wakeme[1 - readwrite])
 
222
                xfermem_putcmd (myfd, XF_CMD_WAKEUP);
 
223
        result = xfermem_getcmd(myfd, TRUE);
 
224
        xf->wakeme[readwrite] = FALSE;
 
225
        return ((result <= 0) ? -1 : result);
 
226
}
 
227
 
 
228
#elif defined(WIN32)
 
229
#include <stdio.h>
 
230
#include <stdlib.h>
 
231
#include <string.h>
 
232
#include <errno.h>
 
233
#include <sys/types.h>
 
234
#include <fcntl.h>
 
235
 
 
236
#include "mpg123.h"
 
237
 
 
238
extern int errno;
 
239
 
 
240
void xfermem_init (txfermem **xf, int bufsize, int msize, int skipbuf)
 
241
{
 
242
}
 
243
void xfermem_done (txfermem *xf)
 
244
{
 
245
}
 
246
void xfermem_init_writer (txfermem *xf)
 
247
{
 
248
}
 
249
void xfermem_init_reader (txfermem *xf)
 
250
{
 
251
}
 
252
int xfermem_get_freespace (txfermem *xf)
 
253
{
 
254
  return 0;
 
255
}
 
256
int xfermem_get_usedspace (txfermem *xf)
 
257
{
 
258
  return 0;
 
259
}
 
260
int xfermem_getcmd (int fd, int block)
 
261
{
 
262
  return 0;
 
263
}
 
264
int xfermem_putcmd (int fd, byte cmd)
 
265
{
 
266
  return 0;
 
267
}
 
268
int xfermem_block (int readwrite, txfermem *xf)
 
269
{
 
270
  return 0;
 
271
}
 
272
#endif
 
273
 
 
274
/* eof */
 
275