Mercurial > cpython-lru_cache-weakref
annotate Modules/cdmodule.c @ 892:11ea669c231e legacy-trunk
Documented new contents of lib5.tex
| author | Guido van Rossum <guido@python.org> |
|---|---|
| date | Wed, 03 Jun 1992 17:56:44 +0000 |
| parents | fe6a5f2640a2 |
| children | 8078834996ec |
| rev | line source |
|---|---|
| 820 | 1 /********************************************************** |
| 2 Copyright 1991, 1992 by Stichting Mathematisch Centrum, Amsterdam, The | |
| 3 Netherlands. | |
| 4 | |
| 5 All Rights Reserved | |
| 6 | |
| 7 Permission to use, copy, modify, and distribute this software and its | |
| 8 documentation for any purpose and without fee is hereby granted, | |
| 9 provided that the above copyright notice appear in all copies and that | |
| 10 both that copyright notice and this permission notice appear in | |
| 11 supporting documentation, and that the names of Stichting Mathematisch | |
| 12 Centrum or CWI not be used in advertising or publicity pertaining to | |
| 13 distribution of the software without specific, written prior permission. | |
| 14 | |
| 15 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO | |
| 16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND | |
| 17 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE | |
| 18 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
| 19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
| 20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT | |
| 21 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
| 22 | |
| 23 ******************************************************************/ | |
| 24 | |
| 25 /* CD module -- interface to Mark Callow's and Roger Chickering's */ | |
| 26 /* CD Audio Library (CD). */ | |
| 27 | |
| 28 #include <sys/types.h> | |
| 29 #include <cdaudio.h> | |
| 30 #include "allobjects.h" | |
| 31 #include "import.h" | |
| 32 #include "modsupport.h" | |
| 33 #include "compile.h" | |
| 34 #include "ceval.h" | |
| 35 | |
| 36 #define NCALLBACKS 8 | |
| 37 | |
| 38 typedef struct { | |
| 39 OB_HEAD | |
| 40 CDPLAYER *ob_cdplayer; | |
| 41 } cdplayerobject; | |
| 42 | |
| 43 #define CheckPlayer(self) if ((self)->ob_cdplayer == NULL) { \ | |
| 44 err_setstr(RuntimeError, "no player active"); \ | |
| 45 return NULL; \ | |
| 46 } | |
| 47 #define CheckParser(self) if ((self)->ob_cdparser == NULL) { \ | |
| 48 err_setstr(RuntimeError, "no parser active"); \ | |
| 49 return NULL; \ | |
| 50 } | |
| 51 | |
| 52 static object * | |
| 53 CD_allowremoval(self, args) | |
| 54 cdplayerobject *self; | |
| 55 object *args; | |
| 56 { | |
| 57 CheckPlayer(self); | |
| 58 | |
| 59 if (!getnoarg(args)) | |
| 60 return NULL; | |
| 61 | |
| 62 CDallowremoval(self->ob_cdplayer); | |
| 63 | |
| 64 INCREF(None); | |
| 65 return None; | |
| 66 } | |
| 67 | |
| 68 static object * | |
| 69 CD_preventremoval(self, args) | |
| 70 cdplayerobject *self; | |
| 71 object *args; | |
| 72 { | |
| 73 CheckPlayer(self); | |
| 74 | |
| 75 if (!getnoarg(args)) | |
| 76 return NULL; | |
| 77 | |
| 78 CDpreventremoval(self->ob_cdplayer); | |
| 79 | |
| 80 INCREF(None); | |
| 81 return None; | |
| 82 } | |
| 83 | |
| 84 static object * | |
| 85 CD_bestreadsize(self, args) | |
| 86 cdplayerobject *self; | |
| 87 object *args; | |
| 88 { | |
| 89 CheckPlayer(self); | |
| 90 | |
| 91 if (!getnoarg(args)) | |
| 92 return NULL; | |
| 93 | |
| 94 return newintobject((long) CDbestreadsize(self->ob_cdplayer)); | |
| 95 } | |
| 96 | |
| 97 static object * | |
| 98 CD_close(self, args) | |
| 99 cdplayerobject *self; | |
| 100 object *args; | |
| 101 { | |
| 102 CheckPlayer(self); | |
| 103 | |
| 104 if (!getnoarg(args)) | |
| 105 return NULL; | |
| 106 | |
| 107 if (!CDclose(self->ob_cdplayer)) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
108 err_errno(IOError); /* XXX - ??? */ |
| 820 | 109 return NULL; |
| 110 } | |
| 111 self->ob_cdplayer = NULL; | |
| 112 | |
| 113 INCREF(None); | |
| 114 return None; | |
| 115 } | |
| 116 | |
| 117 static object * | |
| 118 CD_eject(self, args) | |
| 119 cdplayerobject *self; | |
| 120 object *args; | |
| 121 { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
122 CDSTATUS status; |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
123 |
| 820 | 124 CheckPlayer(self); |
| 125 | |
| 126 if (!getnoarg(args)) | |
| 127 return NULL; | |
| 128 | |
| 129 if (!CDeject(self->ob_cdplayer)) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
130 if (CDgetstatus(self->ob_cdplayer, &status) && |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
131 status.state == CD_NODISC) |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
132 err_setstr(IOError, "no disc in player"); |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
133 else |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
134 err_setstr(IOError, "eject failed"); |
| 820 | 135 return NULL; |
| 136 } | |
| 137 | |
| 138 INCREF(None); | |
| 139 return None; | |
| 140 } | |
| 141 | |
| 142 static object * | |
| 143 CD_getstatus(self, args) | |
| 144 cdplayerobject *self; | |
| 145 object *args; | |
| 146 { | |
| 147 CDSTATUS status; | |
| 148 | |
| 149 CheckPlayer(self); | |
| 150 | |
| 151 if (!getnoarg(args)) | |
| 152 return NULL; | |
| 153 | |
| 154 if (!CDgetstatus(self->ob_cdplayer, &status)) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
155 err_errno(IOError); /* XXX - ??? */ |
| 820 | 156 return NULL; |
| 157 } | |
| 158 | |
|
830
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
159 return mkvalue("(ii(iii)(iii)(iii)iiii(iii))", status.state, |
|
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
160 status.track, status.min, status.sec, status.frame, |
|
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
161 status.abs_min, status.abs_sec, status.abs_frame, |
|
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
162 status.total_min, status.total_sec, status.total_frame, |
|
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
163 status.first, status.last, status.scsi_audio, |
|
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
164 status.cur_block, status.polyfilla[0], |
|
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
165 status.polyfilla[1], status.polyfilla[2]); |
| 820 | 166 } |
| 167 | |
| 168 static object * | |
| 169 CD_gettrackinfo(self, args) | |
| 170 cdplayerobject *self; | |
| 171 object *args; | |
| 172 { | |
| 173 int track; | |
| 174 CDTRACKINFO info; | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
175 CDSTATUS status; |
| 820 | 176 |
| 177 CheckPlayer(self); | |
| 178 | |
| 179 if (!getargs(args, "i", &track)) | |
| 180 return NULL; | |
| 181 | |
| 182 if (!CDgettrackinfo(self->ob_cdplayer, track, &info)) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
183 if (CDgetstatus(self->ob_cdplayer, &status) && |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
184 status.state == CD_NODISC) |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
185 err_setstr(IOError, "no disc in player"); |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
186 else |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
187 err_setstr(IOError, "gettrackinfo failed"); |
| 820 | 188 return NULL; |
| 189 } | |
| 190 | |
|
830
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
191 return mkvalue("((iii)(iii))", |
| 820 | 192 info.start_min, info.start_sec, info.start_frame, |
| 193 info.total_min, info.total_sec, info.total_frame); | |
| 194 } | |
| 195 | |
| 196 static object * | |
| 197 CD_msftoblock(self, args) | |
| 198 cdplayerobject *self; | |
| 199 object *args; | |
| 200 { | |
| 201 int min, sec, frame; | |
| 202 unsigned long block; | |
| 203 | |
| 204 CheckPlayer(self); | |
| 205 | |
| 206 if (!getargs(args, "(iii)", &min, &sec, &frame)) | |
| 207 return NULL; | |
| 208 | |
| 209 block = CDmsftoblock(self->ob_cdplayer, min, sec, frame); | |
| 210 return newintobject((long) block); | |
| 211 } | |
| 212 | |
| 213 static object * | |
| 214 CD_play(self, args) | |
| 215 cdplayerobject *self; | |
| 216 object *args; | |
| 217 { | |
| 218 int start, play; | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
219 CDSTATUS status; |
| 820 | 220 |
| 221 CheckPlayer(self); | |
| 222 | |
| 223 if (!getargs(args, "(ii)", &start, &play)) | |
| 224 return NULL; | |
| 225 | |
| 226 if (!CDplay(self->ob_cdplayer, start, play)) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
227 if (CDgetstatus(self->ob_cdplayer, &status) && |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
228 status.state == CD_NODISC) |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
229 err_setstr(IOError, "no disc in player"); |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
230 else |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
231 err_setstr(IOError, "play failed"); |
| 820 | 232 return NULL; |
| 233 } | |
| 234 | |
| 235 INCREF(None); | |
| 236 return None; | |
| 237 } | |
| 238 | |
| 239 static object * | |
| 240 CD_playabs(self, args) | |
| 241 cdplayerobject *self; | |
| 242 object *args; | |
| 243 { | |
| 244 int min, sec, frame, play; | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
245 CDSTATUS status; |
| 820 | 246 |
| 247 CheckPlayer(self); | |
| 248 | |
| 249 if (!getargs(args, "(iiii)", &min, &sec, &frame, &play)) | |
| 250 return NULL; | |
| 251 | |
| 252 if (!CDplayabs(self->ob_cdplayer, min, sec, frame, play)) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
253 if (CDgetstatus(self->ob_cdplayer, &status) && |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
254 status.state == CD_NODISC) |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
255 err_setstr(IOError, "no disc in player"); |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
256 else |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
257 err_setstr(IOError, "playabs failed"); |
| 820 | 258 return NULL; |
| 259 } | |
| 260 | |
| 261 INCREF(None); | |
| 262 return None; | |
| 263 } | |
| 264 | |
| 265 static object * | |
| 266 CD_playtrack(self, args) | |
| 267 cdplayerobject *self; | |
| 268 object *args; | |
| 269 { | |
| 270 int start, play; | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
271 CDSTATUS status; |
| 820 | 272 |
| 273 CheckPlayer(self); | |
| 274 | |
| 275 if (!getargs(args, "(ii)", &start, &play)) | |
| 276 return NULL; | |
| 277 | |
| 278 if (!CDplaytrack(self->ob_cdplayer, start, play)) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
279 if (CDgetstatus(self->ob_cdplayer, &status) && |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
280 status.state == CD_NODISC) |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
281 err_setstr(IOError, "no disc in player"); |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
282 else |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
283 err_setstr(IOError, "playtrack failed"); |
| 820 | 284 return NULL; |
| 285 } | |
| 286 | |
| 287 INCREF(None); | |
| 288 return None; | |
| 289 } | |
| 290 | |
| 291 static object * | |
| 292 CD_playtrackabs(self, args) | |
| 293 cdplayerobject *self; | |
| 294 object *args; | |
| 295 { | |
| 296 int track, min, sec, frame, play; | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
297 CDSTATUS status; |
| 820 | 298 |
| 299 CheckPlayer(self); | |
| 300 | |
| 301 if (!getargs(args, "(iiiii)", &track, &min, &sec, &frame, &play)) | |
| 302 return NULL; | |
| 303 | |
| 304 if (!CDplaytrackabs(self->ob_cdplayer, track, min, sec, frame, play)) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
305 if (CDgetstatus(self->ob_cdplayer, &status) && |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
306 status.state == CD_NODISC) |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
307 err_setstr(IOError, "no disc in player"); |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
308 else |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
309 err_setstr(IOError, "playtrackabs failed"); |
| 820 | 310 return NULL; |
| 311 } | |
| 312 | |
| 313 INCREF(None); | |
| 314 return None; | |
| 315 } | |
| 316 | |
| 317 static object * | |
| 318 CD_readda(self, args) | |
| 319 cdplayerobject *self; | |
| 320 object *args; | |
| 321 { | |
| 322 int numframes, n; | |
| 323 object *result; | |
| 324 | |
| 325 CheckPlayer(self); | |
| 326 | |
| 327 if (!getargs(args, "i", &numframes)) | |
| 328 return NULL; | |
| 329 | |
| 330 result = newsizedstringobject(NULL, numframes * sizeof(CDFRAME)); | |
| 331 if (result == NULL) | |
| 332 return NULL; | |
| 333 | |
| 334 n = CDreadda(self->ob_cdplayer, (CDFRAME *) getstringvalue(result), numframes); | |
| 335 if (n == -1) { | |
| 336 DECREF(result); | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
337 err_errno(IOError); /* XXX - ??? (seems to work) */ |
| 820 | 338 return NULL; |
| 339 } | |
| 340 if (n < numframes) | |
| 341 if (resizestring(&result, n * sizeof(CDFRAME))) | |
| 342 return NULL; | |
| 343 | |
| 344 return result; | |
| 345 } | |
| 346 | |
| 347 static object * | |
| 348 CD_seek(self, args) | |
| 349 cdplayerobject *self; | |
| 350 object *args; | |
| 351 { | |
| 352 int min, sec, frame; | |
| 353 long block; | |
| 354 | |
| 355 CheckPlayer(self); | |
| 356 | |
| 357 if (!getargs(args, "(iii)", &min, &sec, &frame)) | |
| 358 return NULL; | |
| 359 | |
| 360 block = CDseek(self->ob_cdplayer, min, sec, frame); | |
| 361 if (block == -1) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
362 err_errno(IOError); |
| 820 | 363 return NULL; |
| 364 } | |
| 365 | |
| 366 return newintobject(block); | |
| 367 } | |
| 368 | |
| 369 static object * | |
| 370 CD_seektrack(self, args) | |
| 371 cdplayerobject *self; | |
| 372 object *args; | |
| 373 { | |
| 374 int track; | |
| 375 long block; | |
| 376 | |
| 377 CheckPlayer(self); | |
| 378 | |
| 379 if (!getargs(args, "i", &track)) | |
| 380 return NULL; | |
| 381 | |
| 382 block = CDseektrack(self->ob_cdplayer, track); | |
| 383 if (block == -1) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
384 err_errno(IOError); |
| 820 | 385 return NULL; |
| 386 } | |
| 387 | |
| 388 return newintobject(block); | |
| 389 } | |
| 390 | |
| 391 static object * | |
| 392 CD_stop(self, args) | |
| 393 cdplayerobject *self; | |
| 394 object *args; | |
| 395 { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
396 CDSTATUS status; |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
397 |
| 820 | 398 CheckPlayer(self); |
| 399 | |
| 400 if (!getnoarg(args)) | |
| 401 return NULL; | |
| 402 | |
| 403 if (!CDstop(self->ob_cdplayer)) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
404 if (CDgetstatus(self->ob_cdplayer, &status) && |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
405 status.state == CD_NODISC) |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
406 err_setstr(IOError, "no disc in player"); |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
407 else |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
408 err_setstr(IOError, "stop failed"); |
| 820 | 409 return NULL; |
| 410 } | |
| 411 | |
| 412 INCREF(None); | |
| 413 return None; | |
| 414 } | |
| 415 | |
| 416 static object * | |
| 417 CD_togglepause(self, args) | |
| 418 cdplayerobject *self; | |
| 419 object *args; | |
| 420 { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
421 CDSTATUS status; |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
422 |
| 820 | 423 CheckPlayer(self); |
| 424 | |
| 425 if (!getnoarg(args)) | |
| 426 return NULL; | |
| 427 | |
| 428 if (!CDtogglepause(self->ob_cdplayer)) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
429 if (CDgetstatus(self->ob_cdplayer, &status) && |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
430 status.state == CD_NODISC) |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
431 err_setstr(IOError, "no disc in player"); |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
432 else |
|
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
433 err_setstr(IOError, "togglepause failed"); |
| 820 | 434 return NULL; |
| 435 } | |
| 436 | |
| 437 INCREF(None); | |
| 438 return None; | |
| 439 } | |
| 440 | |
| 441 static struct methodlist cdplayer_methods[] = { | |
| 442 {"allowremoval", CD_allowremoval}, | |
| 443 {"bestreadsize", CD_bestreadsize}, | |
| 444 {"close", CD_close}, | |
| 445 {"eject", CD_eject}, | |
| 446 {"getstatus", CD_getstatus}, | |
| 447 {"gettrackinfo", CD_gettrackinfo}, | |
| 448 {"msftoblock", CD_msftoblock}, | |
| 449 {"play", CD_play}, | |
| 450 {"playabs", CD_playabs}, | |
| 451 {"playtrack", CD_playtrack}, | |
| 452 {"playtrackabs", CD_playtrackabs}, | |
| 453 {"preventremoval", CD_preventremoval}, | |
| 454 {"readda", CD_readda}, | |
| 455 {"seek", CD_seek}, | |
| 456 {"seektrack", CD_seektrack}, | |
| 457 {"stop", CD_stop}, | |
| 458 {"togglepause", CD_togglepause}, | |
| 459 {NULL, NULL} /* sentinel */ | |
| 460 }; | |
| 461 | |
| 462 static void | |
| 463 cdplayer_dealloc(self) | |
| 464 cdplayerobject *self; | |
| 465 { | |
| 466 if (self->ob_cdplayer != NULL) | |
| 467 CDclose(self->ob_cdplayer); | |
| 468 DEL(self); | |
| 469 } | |
| 470 | |
| 471 static object * | |
| 472 cdplayer_getattr(cdp, name) | |
| 473 cdplayerobject *cdp; | |
| 474 char *name; | |
| 475 { | |
| 476 return findmethod(cdplayer_methods, (object *)cdp, name); | |
| 477 } | |
| 478 | |
| 479 typeobject CdPlayertype = { | |
| 480 OB_HEAD_INIT(&Typetype) | |
| 481 0, /*ob_size*/ | |
| 482 "cdplayer", /*tp_name*/ | |
| 483 sizeof(cdplayerobject), /*tp_size*/ | |
| 484 0, /*tp_itemsize*/ | |
| 485 /* methods */ | |
| 486 cdplayer_dealloc, /*tp_dealloc*/ | |
| 487 0, /*tp_print*/ | |
| 488 cdplayer_getattr, /*tp_getattr*/ | |
| 489 0, /*tp_setattr*/ | |
| 490 0, /*tp_compare*/ | |
| 491 0, /*tp_repr*/ | |
| 492 }; | |
| 493 | |
| 494 static object * | |
| 495 newcdplayerobject(cdp) | |
| 496 CDPLAYER *cdp; | |
| 497 { | |
| 498 cdplayerobject *p; | |
| 499 | |
| 500 p = NEWOBJ(cdplayerobject, &CdPlayertype); | |
| 501 if (p == NULL) | |
| 502 return NULL; | |
| 503 p->ob_cdplayer = cdp; | |
| 504 return (object *) p; | |
| 505 } | |
| 506 | |
| 507 static object * | |
| 508 CD_open(self, args) | |
| 509 object *self, *args; | |
| 510 { | |
| 511 char *dev, *direction; | |
| 512 CDPLAYER *cdp; | |
| 513 | |
| 514 /* | |
| 515 * Variable number of args. | |
| 516 * First defaults to "None", second defaults to "r". | |
| 517 */ | |
| 518 dev = NULL; | |
| 519 direction = "r"; | |
| 520 if (!getnoarg(args)) { | |
| 521 err_clear(); | |
| 522 if (!getargs(args, "z", &dev)) { | |
| 523 err_clear(); | |
| 524 if (!getargs(args, "(zs)", &dev, &direction)) | |
| 525 return NULL; | |
| 526 } | |
| 527 } | |
| 528 | |
| 529 cdp = CDopen(dev, direction); | |
| 530 if (cdp == NULL) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
531 err_errno(IOError); |
| 820 | 532 return NULL; |
| 533 } | |
| 534 | |
| 535 return newcdplayerobject(cdp); | |
| 536 } | |
| 537 | |
| 538 typedef struct { | |
| 539 OB_HEAD | |
| 540 CDPARSER *ob_cdparser; | |
| 541 struct { | |
| 542 object *ob_cdcallback; | |
| 543 object *ob_cdcallbackarg; | |
| 544 } ob_cdcallbacks[NCALLBACKS]; | |
| 545 } cdparserobject; | |
| 546 | |
| 547 static void | |
| 548 CD_callback(arg, type, data) | |
| 549 void *arg; | |
| 550 CDDATATYPES type; | |
| 551 void *data; | |
| 552 { | |
| 553 object *result, *args, *v; | |
| 554 char *p; | |
| 555 int i; | |
| 556 cdparserobject *self; | |
| 557 | |
| 558 self = (cdparserobject *) arg; | |
| 559 args = newtupleobject(3); | |
| 560 if (args == NULL) | |
| 561 return; | |
| 562 INCREF(self->ob_cdcallbacks[type].ob_cdcallbackarg); | |
| 563 settupleitem(args, 0, self->ob_cdcallbacks[type].ob_cdcallbackarg); | |
| 564 settupleitem(args, 1, newintobject((long) type)); | |
| 565 switch (type) { | |
| 566 case cd_audio: | |
| 567 v = newsizedstringobject(data, CDDA_DATASIZE); | |
| 568 break; | |
| 569 case cd_pnum: | |
| 570 case cd_index: | |
| 571 v = newintobject(((CDPROGNUM *) data)->value); | |
| 572 break; | |
| 573 case cd_ptime: | |
| 574 case cd_atime: | |
|
830
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
575 #define ptr ((struct cdtimecode *) data) |
|
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
576 v = mkvalue("(iii)", ptr->mhi * 10 + ptr->mlo, |
|
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
577 ptr->shi * 10 + ptr->slo, |
|
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
578 ptr->fhi * 10 + ptr->flo); |
|
ea5072de7427
Return more structured data in some cases
Guido van Rossum <guido@python.org>
parents:
820
diff
changeset
|
579 #undef ptr |
| 820 | 580 break; |
| 581 case cd_catalog: | |
| 582 v = newsizedstringobject(NULL, 13); | |
| 583 p = getstringvalue(v); | |
| 584 for (i = 0; i < 13; i++) | |
| 585 *p++ = ((char *) data)[i] + '0'; | |
| 586 break; | |
| 587 case cd_ident: | |
| 588 v = newsizedstringobject(NULL, 12); | |
| 589 p = getstringvalue(v); | |
| 590 CDsbtoa(p, ((struct cdident *) data)->country, 2); | |
| 591 p += 2; | |
| 592 CDsbtoa(p, ((struct cdident *) data)->owner, 3); | |
| 593 p += 3; | |
| 594 *p++ = ((struct cdident *) data)->year[0] + '0'; | |
| 595 *p++ = ((struct cdident *) data)->year[1] + '0'; | |
| 596 *p++ = ((struct cdident *) data)->serial[0] + '0'; | |
| 597 *p++ = ((struct cdident *) data)->serial[1] + '0'; | |
| 598 *p++ = ((struct cdident *) data)->serial[2] + '0'; | |
| 599 *p++ = ((struct cdident *) data)->serial[3] + '0'; | |
| 600 *p++ = ((struct cdident *) data)->serial[4] + '0'; | |
| 601 break; | |
| 602 case cd_control: | |
| 603 v = newintobject((long) *((unchar *) data)); | |
| 604 break; | |
| 605 } | |
| 606 settupleitem(args, 2, v); | |
| 607 if (err_occurred()) { | |
| 608 DECREF(args); | |
| 609 return; | |
| 610 } | |
| 611 | |
| 612 result = call_object(self->ob_cdcallbacks[type].ob_cdcallback, args); | |
| 613 DECREF(args); | |
| 614 XDECREF(result); | |
| 615 } | |
| 616 | |
| 617 static object * | |
| 618 CD_deleteparser(self, args) | |
| 619 cdparserobject *self; | |
| 620 object *args; | |
| 621 { | |
| 622 int i; | |
| 623 | |
| 624 CheckParser(self); | |
| 625 | |
| 626 if (!getnoarg(args)) | |
| 627 return NULL; | |
| 628 | |
| 629 CDdeleteparser(self->ob_cdparser); | |
| 630 self->ob_cdparser = NULL; | |
| 631 | |
| 632 /* no sense in keeping the callbacks, so remove them */ | |
| 633 for (i = 0; i < NCALLBACKS; i++) { | |
| 634 XDECREF(self->ob_cdcallbacks[i].ob_cdcallback); | |
| 635 self->ob_cdcallbacks[i].ob_cdcallback = NULL; | |
| 636 XDECREF(self->ob_cdcallbacks[i].ob_cdcallbackarg); | |
| 637 self->ob_cdcallbacks[i].ob_cdcallbackarg = NULL; | |
| 638 } | |
| 639 | |
| 640 INCREF(None); | |
| 641 return None; | |
| 642 } | |
| 643 | |
| 644 static object * | |
| 645 CD_parseframe(self, args) | |
| 646 cdparserobject *self; | |
| 647 object *args; | |
| 648 { | |
| 649 char *cdfp; | |
| 650 int length; | |
| 651 CDFRAME *p; | |
| 652 | |
| 653 CheckParser(self); | |
| 654 | |
| 655 if (!getargs(args, "s#", &cdfp, &length)) | |
| 656 return NULL; | |
| 657 | |
| 658 if (length % sizeof(CDFRAME) != 0) { | |
| 659 err_setstr(RuntimeError, "bad length"); | |
| 660 return NULL; | |
| 661 } | |
| 662 | |
| 663 p = (CDFRAME *) cdfp; | |
| 664 while (length > 0) { | |
| 665 CDparseframe(self->ob_cdparser, p); | |
| 666 length -= sizeof(CDFRAME); | |
| 667 p++; | |
| 668 if (err_occurred()) | |
| 669 return NULL; | |
| 670 } | |
| 671 | |
| 672 INCREF(None); | |
| 673 return None; | |
| 674 } | |
| 675 | |
| 676 static object * | |
| 677 CD_removecallback(self, args) | |
| 678 cdparserobject *self; | |
| 679 object *args; | |
| 680 { | |
| 681 int type; | |
| 682 | |
| 683 CheckParser(self); | |
| 684 | |
| 685 if (!getargs(args, "i", &type)) | |
| 686 return NULL; | |
| 687 | |
| 688 CDremovecallback(self->ob_cdparser, (CDDATATYPES) type); | |
| 689 | |
| 690 XDECREF(self->ob_cdcallbacks[type].ob_cdcallback); | |
| 691 self->ob_cdcallbacks[type].ob_cdcallback = NULL; | |
| 692 | |
| 693 XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg); | |
| 694 self->ob_cdcallbacks[type].ob_cdcallbackarg = NULL; | |
| 695 | |
| 696 INCREF(None); | |
| 697 return None; | |
| 698 } | |
| 699 | |
| 700 static object * | |
| 701 CD_resetparser(self, args) | |
| 702 cdparserobject *self; | |
| 703 object *args; | |
| 704 { | |
| 705 CheckParser(self); | |
| 706 | |
| 707 if (!getnoarg(args)) | |
| 708 return NULL; | |
| 709 | |
| 710 CDresetparser(self->ob_cdparser); | |
| 711 | |
| 712 INCREF(None); | |
| 713 return None; | |
| 714 } | |
| 715 | |
| 716 static object * | |
| 717 CD_setcallback(self, args) | |
| 718 cdparserobject *self; | |
| 719 object *args; | |
| 720 { | |
| 721 int type; | |
| 722 object *funcobject, *funcargobject; | |
| 723 | |
| 724 CheckParser(self); | |
| 725 | |
| 726 /* XXX - more work here */ | |
| 727 if (!getargs(args, "(iOO)", &type, &funcobject, &funcargobject)) | |
| 728 return NULL; | |
| 729 | |
| 730 if (type < 0 || type >= NCALLBACKS) { | |
| 731 err_setstr(RuntimeError, "bad type"); | |
| 732 return NULL; | |
| 733 } | |
| 734 | |
| 735 CDsetcallback(self->ob_cdparser, (CDDATATYPES) type, CD_callback, (void *) self); | |
| 736 XDECREF(self->ob_cdcallbacks[type].ob_cdcallback); | |
| 737 INCREF(funcobject); | |
| 738 self->ob_cdcallbacks[type].ob_cdcallback = funcobject; | |
| 739 XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg); | |
| 740 INCREF(funcargobject); | |
| 741 self->ob_cdcallbacks[type].ob_cdcallbackarg = funcargobject; | |
| 742 | |
| 743 INCREF(None); | |
| 744 return None; | |
| 745 } | |
| 746 | |
| 747 static struct methodlist cdparser_methods[] = { | |
| 748 {"deleteparser", CD_deleteparser}, | |
| 749 {"parseframe", CD_parseframe}, | |
| 750 {"removecallback", CD_removecallback}, | |
| 751 {"resetparser", CD_resetparser}, | |
| 752 {"setcallback", CD_setcallback}, | |
| 753 {NULL, NULL} /* sentinel */ | |
| 754 }; | |
| 755 | |
| 756 static void | |
| 757 cdparser_dealloc(self) | |
| 758 cdparserobject *self; | |
| 759 { | |
| 760 int i; | |
| 761 | |
| 762 for (i = 0; i < NCALLBACKS; i++) { | |
| 763 XDECREF(self->ob_cdcallbacks[i].ob_cdcallback); | |
| 764 self->ob_cdcallbacks[i].ob_cdcallback = NULL; | |
| 765 XDECREF(self->ob_cdcallbacks[i].ob_cdcallbackarg); | |
| 766 self->ob_cdcallbacks[i].ob_cdcallbackarg = NULL; | |
| 767 } | |
| 768 CDdeleteparser(self->ob_cdparser); | |
| 769 DEL(self); | |
| 770 } | |
| 771 | |
| 772 static object * | |
| 773 cdparser_getattr(cdp, name) | |
| 774 cdparserobject *cdp; | |
| 775 char *name; | |
| 776 { | |
| 777 return findmethod(cdparser_methods, (object *)cdp, name); | |
| 778 } | |
| 779 | |
| 780 typeobject CdParsertype = { | |
| 781 OB_HEAD_INIT(&Typetype) | |
| 782 0, /*ob_size*/ | |
| 783 "cdparser", /*tp_name*/ | |
| 784 sizeof(cdparserobject), /*tp_size*/ | |
| 785 0, /*tp_itemsize*/ | |
| 786 /* methods */ | |
| 787 cdparser_dealloc, /*tp_dealloc*/ | |
| 788 0, /*tp_print*/ | |
| 789 cdparser_getattr, /*tp_getattr*/ | |
| 790 0, /*tp_setattr*/ | |
| 791 0, /*tp_compare*/ | |
| 792 0, /*tp_repr*/ | |
| 793 }; | |
| 794 | |
| 795 static object * | |
| 796 newcdparserobject(cdp) | |
| 797 CDPARSER *cdp; | |
| 798 { | |
| 799 cdparserobject *p; | |
| 800 int i; | |
| 801 | |
| 802 p = NEWOBJ(cdparserobject, &CdParsertype); | |
| 803 if (p == NULL) | |
| 804 return NULL; | |
| 805 p->ob_cdparser = cdp; | |
| 806 for (i = 0; i < NCALLBACKS; i++) { | |
| 807 p->ob_cdcallbacks[i].ob_cdcallback = NULL; | |
| 808 p->ob_cdcallbacks[i].ob_cdcallbackarg = NULL; | |
| 809 } | |
| 810 return (object *) p; | |
| 811 } | |
| 812 | |
| 813 static object * | |
| 814 CD_createparser(self, args) | |
| 815 object *self, *args; | |
| 816 { | |
| 817 CDPARSER *cdp; | |
| 818 | |
| 819 if (!getnoarg(args)) | |
| 820 return NULL; | |
| 821 cdp = CDcreateparser(); | |
| 822 if (cdp == NULL) { | |
|
849
fe6a5f2640a2
Wanneer er geen disk in de speler zit falen sommige routines. De
Guido van Rossum <guido@python.org>
parents:
848
diff
changeset
|
823 err_setstr(IOError, "createparser failed"); |
| 820 | 824 return NULL; |
| 825 } | |
| 826 | |
| 827 return newcdparserobject(cdp); | |
| 828 } | |
| 829 | |
| 830 static object * | |
| 831 CD_sbtoa(self, args) | |
| 832 object *self; | |
| 833 object *args; | |
| 834 { | |
| 835 char *sb; | |
| 836 int length; | |
| 837 object *result; | |
| 838 | |
| 839 if (!getargs(args, "s#", &sb, &length)) | |
| 840 return NULL; | |
| 841 result = newsizedstringobject(NULL, length); | |
| 842 CDsbtoa(getstringvalue(result), (unchar *) sb, length); | |
| 843 return result; | |
| 844 } | |
| 845 | |
| 846 static object * | |
| 847 CD_timetoa(self, args) | |
| 848 object *self; | |
| 849 object *args; | |
| 850 { | |
| 851 char *tc; | |
| 852 int length; | |
| 853 object *result; | |
| 854 | |
| 855 if (!getargs(args, "s#", &tc, &length)) | |
| 856 return NULL; | |
| 857 | |
| 858 if (length != sizeof(struct cdtimecode)) { | |
| 859 err_setstr(RuntimeError, "bad length"); | |
| 860 return NULL; | |
| 861 } | |
| 862 | |
| 863 result = newsizedstringobject(NULL, 8); | |
| 864 CDtimetoa(getstringvalue(result), (struct cdtimecode *) tc); | |
| 865 return result; | |
| 866 } | |
| 867 | |
| 868 static struct methodlist CD_methods[] = { | |
| 869 {"sbtoa", CD_sbtoa}, | |
| 870 {"open", CD_open}, | |
| 871 {"createparser",CD_createparser}, | |
| 872 {"timetoa", CD_timetoa}, | |
| 873 {NULL, NULL} /* Sentinel */ | |
| 874 }; | |
| 875 | |
| 876 void | |
| 877 initcd() | |
| 878 { | |
| 879 (void) initmodule("cd", CD_methods); | |
| 880 } |