1 /* $OpenBSD: cdio.c,v 1.72 2010/03/01 02:09:44 krw Exp $ */
2
3 /* Copyright (c) 1995 Serge V. Vakulenko
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by Serge V. Vakulenko.
18 * 4. The name of the author may not be used to endorse or promote products
19 * derived from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 /*
34 * Compact Disc Control Utility by Serge V. Vakulenko <vak@cronyx.ru>.
35 * Based on the non-X based CD player by Jean-Marc Zucconi and
36 * Andrey A. Chernov.
37 *
38 * Fixed and further modified on 5-Sep-1995 by Jukka Ukkonen <jau@funet.fi>.
39 *
40 * 11-Sep-1995: Jukka A. Ukkonen <jau@funet.fi>
41 * A couple of further fixes to my own earlier "fixes".
42 *
43 * 18-Sep-1995: Jukka A. Ukkonen <jau@funet.fi>
44 * Added an ability to specify addresses relative to the
45 * beginning of a track. This is in fact a variation of
46 * doing the simple play_msf() call.
47 *
48 * 11-Oct-1995: Serge V.Vakulenko <vak@cronyx.ru>
49 * New eject algorithm.
50 * Some code style reformatting.
51 *
52 * $FreeBSD: cdcontrol.c,v 1.13 1996/06/25 21:01:27 ache Exp $
53 */
54
55 #include <sys/param.h>
56 #include <sys/file.h>
57 #include <sys/cdio.h>
58 #include <sys/ioctl.h>
59 #include <sys/queue.h>
60 #include <sys/scsiio.h>
61 #include <sys/stat.h>
62
63 #include <ctype.h>
64 #include <err.h>
65 #include <errno.h>
66 #include <stdio.h>
67 #include <stdlib.h>
68 #include <string.h>
69 #include <unistd.h>
70 #include <histedit.h>
71 #include <util.h>
72 #include <vis.h>
73
74 #include "extern.h"
75
76 __RCSID("$MirOS: src/usr.bin/cdio/cdio.c,v 1.3 2010/03/06 19:57:41 tg Exp $");
77
78 #define ASTS_INVALID 0x00 /* Audio status byte not valid */
79 #define ASTS_PLAYING 0x11 /* Audio play operation in progress */
80 #define ASTS_PAUSED 0x12 /* Audio play operation paused */
81 #define ASTS_COMPLETED 0x13 /* Audio play operation successfully completed */
82 #define ASTS_ERROR 0x14 /* Audio play operation stopped due to error */
83 #define ASTS_VOID 0x15 /* No current audio status to return */
84
85 #ifndef DEFAULT_CD_DRIVE
86 # define DEFAULT_CD_DRIVE "cd0"
87 #endif
88
89 #define CMD_DEBUG 1
90 #define CMD_DEVICE 2
91 #define CMD_EJECT 3
92 #define CMD_HELP 4
93 #define CMD_INFO 5
94 #define CMD_PAUSE 6
95 #define CMD_PLAY 7
96 #define CMD_QUIT 8
97 #define CMD_RESUME 9
98 #define CMD_STOP 10
99 #define CMD_VOLUME 11
100 #define CMD_CLOSE 12
101 #define CMD_RESET 13
102 #define CMD_SET 14
103 #define CMD_STATUS 15
104 #define CMD_NEXT 16
105 #define CMD_PREV 17
106 #define CMD_REPLAY 18
107 #define CMD_CDDB 19
108 #define CMD_CDID 20
109 #define CMD_BLANK 21
110 #define CMD_CDRIP 22
111 #define CMD_CDPLAY 23
112 #define CMD_LOCK 24
113
114 struct cmdtab {
115 int command;
116 char *name;
117 int min;
118 char *args;
119 } cmdtab[] = {
120 { CMD_BLANK, "blank", 1, "" },
121 { CMD_CDDB, "cddbinfo", 2, "[n]" },
122 { CMD_CDID, "cdid", 3, "" },
123 { CMD_CDPLAY, "cdplay", 3, "[track1-trackN ...]" },
124 { CMD_CDRIP, "cdrip", 3, "[track1-trackN ...]" },
125 { CMD_CLOSE, "close", 1, "" },
126 { CMD_DEBUG, "debug", 3, "on | off" },
127 { CMD_DEVICE, "device", 1, "devname" },
128 { CMD_EJECT, "eject", 1, "" },
129 { CMD_QUIT, "exit", 2, "" },
130 { CMD_HELP, "?", 1, 0 },
131 { CMD_HELP, "help", 1, "" },
132 { CMD_INFO, "info", 1, "" },
133 { CMD_LOCK, "lock", 1, "" },
134 { CMD_NEXT, "next", 1, "" },
135 { CMD_PAUSE, "pause", 2, "" },
136 { CMD_PLAY, "play", 1, "[track1[.index1] [track2[.index2]]]" },
137 { CMD_PLAY, "play", 1, "[[tr1] m1:s1[.f1] [tr2] [m2:s2[.f2]]]" },
138 { CMD_PLAY, "play", 1, "[#block [len]]" },
139 { CMD_PREV, "previous", 2, "" },
140 { CMD_QUIT, "quit", 1, "" },
141 { CMD_REPLAY, "replay", 3, "" },
142 { CMD_RESET, "reset", 4, "" },
143 { CMD_RESUME, "resume", 1, "" },
144 { CMD_SET, "set", 2, "lba | msf" },
145 { CMD_STATUS, "status", 1, "" },
146 { CMD_STOP, "stop", 3, "" },
147 { CMD_VOLUME, "volume", 1, "left_channel right_channel" },
148 { CMD_VOLUME, "volume", 1, "left | right | mono | stereo | mute" },
149 { 0, 0, 0, 0}
150 };
151
152 struct cd_toc_entry *toc_buffer;
153
154 char *cdname;
155 int fd = -1;
156 int writeperm = 0;
157 u_int8_t mediacap[MMC_FEATURE_MAX / NBBY];
158 int verbose = 1;
159 int msf = 1;
160 const char *cddb_host;
161 char **track_names;
162
163 EditLine *el = NULL; /* line-editing structure */
164 History *hist = NULL; /* line-editing history */
165 void switch_el(void);
166
167 extern char *__progname;
168
169 int setvol(int, int);
170 int read_toc_entrys(int);
171 int play_msf(int, int, int, int, int, int);
172 int play_track(int, int, int, int);
173 int status(int *, int *, int *, int *);
174 int is_wave(int);
175 __dead void tao(int argc, char **argv);
176 int play(char *arg);
177 int info(char *arg);
178 int cddbinfo(char *arg);
179 int pstatus(char *arg);
180 int play_next(char *arg);
181 int play_prev(char *arg);
182 int play_same(char *arg);
183 char *input(int *);
184 char *prompt(void);
185 void prtrack(struct cd_toc_entry *e, int lastflag, char *name);
186 void lba2msf(unsigned long lba, u_char *m, u_char *s, u_char *f);
187 unsigned int msf2lba(u_char m, u_char s, u_char f);
188 int play_blocks(int blk, int len);
189 int run(int cmd, char *arg);
190 char *parse(char *buf, int *cmd);
191 void help(void);
192 void usage(void);
193 char *strstatus(int);
194 int cdid(void);
195 void addmsf(u_int *, u_int *, u_int *, u_char, u_char, u_char);
196 int cmpmsf(u_char, u_char, u_char, u_char, u_char, u_char);
197 void toc2msf(u_int, u_char *, u_char *, u_char *);
198
199 void
help(void)200 help(void)
201 {
202 struct cmdtab *c;
203 char *s, n;
204 int i;
205
206 for (c = cmdtab; c->name; ++c) {
207 if (!c->args)
208 continue;
209 printf("\t");
210 for (i = c->min, s = c->name; *s; s++, i--) {
211 if (i > 0)
212 n = toupper(*s);
213 else
214 n = *s;
215 putchar(n);
216 }
217 if (*c->args)
218 printf(" %s", c->args);
219 printf("\n");
220 }
221 printf("\n\tThe word \"play\" is not required for the play commands.\n");
222 printf("\tThe plain target address is taken as a synonym for play.\n");
223 }
224
225 void
usage(void)226 usage(void)
227 {
228 fprintf(stderr, "usage: %s [-sv] [-d host:port] [-f device] [command args ...]\n",
229 __progname);
230 exit(1);
231 }
232
233 int
main(int argc,char ** argv)234 main(int argc, char **argv)
235 {
236 int ch, cmd;
237 char *arg;
238
239 cdname = getenv("DISC");
240 if (!cdname)
241 cdname = getenv("CDROM");
242
243 cddb_host = getenv("CDDB");
244 if (!cddb_host)
245 cddb_host = "freedb.freedb.org";
246
247 while ((ch = getopt(argc, argv, "svd:f:")) != -1)
248 switch (ch) {
249 case 's':
250 verbose = 0;
251 break;
252 case 'v':
253 verbose++;
254 break;
255 case 'f':
256 cdname = optarg;
257 break;
258 case 'd':
259 cddb_host = optarg;
260 break;
261 default:
262 usage();
263 }
264
265 argc -= optind;
266 argv += optind;
267
268 if (argc > 0 && ! strcasecmp(*argv, "help"))
269 usage();
270
271 if (!cdname) {
272 cdname = DEFAULT_CD_DRIVE;
273 if (verbose > 1)
274 fprintf(stderr,
275 "No CD device name specified. Defaulting to %s.\n",
276 cdname);
277 }
278
279 if (argc > 0 && !strcasecmp(*argv, "tao")) {
280 tao(argc, argv);
281 /* NOTREACHED */
282 }
283 if (argc > 0) {
284 char buf[80], *p;
285 int len;
286
287 for (p=buf; argc-->0; ++argv) {
288 len = snprintf(p, buf + sizeof buf - p,
289 "%s%s", (p > buf) ? " " : "", *argv);
290
291 if (len == -1 || len >= buf + sizeof buf - p)
292 errx(1, "argument list too long.");
293
294 p += len;
295 }
296 arg = parse(buf, &cmd);
297 return (run(cmd, arg));
298 }
299
300 if (verbose == 1)
301 verbose = isatty(0);
302
303 if (verbose) {
304 printf("Compact Disc Control utility, version %s\n", VERSION);
305 printf("Type `?' for command list\n\n");
306 }
307
308 switch_el();
309
310 for (;;) {
311 arg = input(&cmd);
312 if (run(cmd, arg) < 0) {
313 if (verbose)
314 warn(NULL);
315 close(fd);
316 fd = -1;
317 }
318 fflush(stdout);
319 }
320 }
321
322 int
run(int cmd,char * arg)323 run(int cmd, char *arg)
324 {
325 int l, r, rc;
326 static char newcdname[MAXPATHLEN];
327
328 switch (cmd) {
329
330 case CMD_QUIT:
331 switch_el();
332 exit(0);
333
334 case CMD_INFO:
335 if (!open_cd(cdname, 0))
336 return (0);
337
338 return info(arg);
339
340 case CMD_CDDB:
341 if (!open_cd(cdname, 0))
342 return (0);
343
344 return cddbinfo(arg);
345
346 case CMD_CDID:
347 if (!open_cd(cdname, 0))
348 return (0);
349 return cdid();
350
351 case CMD_STATUS:
352 if (!open_cd(cdname, 0))
353 return (0);
354
355 return pstatus(arg);
356
357 case CMD_PAUSE:
358 if (!open_cd(cdname, 0))
359 return (0);
360
361 return ioctl(fd, CDIOCPAUSE);
362
363 case CMD_RESUME:
364 if (!open_cd(cdname, 0))
365 return (0);
366
367 return ioctl(fd, CDIOCRESUME);
368
369 case CMD_STOP:
370 if (!open_cd(cdname, 0))
371 return (0);
372
373 rc = ioctl(fd, CDIOCSTOP);
374
375 (void) ioctl(fd, CDIOCALLOW);
376
377 return (rc);
378
379 case CMD_RESET:
380 if (!open_cd(cdname, 0))
381 return (0);
382
383 rc = ioctl(fd, CDIOCRESET);
384 if (rc < 0)
385 return rc;
386 close(fd);
387 fd = -1;
388 return (0);
389
390 case CMD_DEBUG:
391 if (!open_cd(cdname, 0))
392 return (0);
393
394 if (!strcasecmp(arg, "on"))
395 return ioctl(fd, CDIOCSETDEBUG);
396
397 if (!strcasecmp(arg, "off"))
398 return ioctl(fd, CDIOCCLRDEBUG);
399
400 printf("%s: Invalid command arguments\n", __progname);
401
402 return (0);
403
404 case CMD_DEVICE:
405 /* close old device */
406 if (fd > -1) {
407 (void) ioctl(fd, CDIOCALLOW);
408 close(fd);
409 fd = -1;
410 }
411
412 if (strlen(arg) == 0) {
413 printf("%s: Invalid parameter\n", __progname);
414 return (0);
415 }
416
417 /* open new device */
418 if (!open_cd(arg, 0))
419 return (0);
420 (void) strlcpy(newcdname, arg, sizeof(newcdname));
421 cdname = newcdname;
422 return (1);
423
424 case CMD_EJECT:
425 if (!open_cd(cdname, 0))
426 return (0);
427
428 (void) ioctl(fd, CDIOCALLOW);
429 rc = ioctl(fd, CDIOCEJECT);
430 if (rc < 0)
431 return (rc);
432 #if defined(__OpenBSD__)
433 close(fd);
434 fd = -1;
435 #endif
436 if (track_names)
437 free_names(track_names);
438 track_names = NULL;
439 return (0);
440
441 case CMD_LOCK:
442 if (fd < 0 && ! open_cd(cdname, 0))
443 return (0);
444
445 rc = ioctl(fd, CDIOCPREVENT);
446 return (rc < 0 ? rc : 0);
447
448 case CMD_CLOSE:
449 #if defined(CDIOCCLOSE)
450 if (!open_cd(cdname, 0))
451 return (0);
452
453 (void) ioctl(fd, CDIOCALLOW);
454 rc = ioctl(fd, CDIOCCLOSE);
455 if (rc < 0)
456 return (rc);
457 close(fd);
458 fd = -1;
459 return (0);
460 #else
461 printf("%s: Command not yet supported\n", __progname);
462 return (0);
463 #endif
464
465 case CMD_PLAY:
466 if (!open_cd(cdname, 0))
467 return (0);
468
469 while (isspace(*arg))
470 arg++;
471
472 return play(arg);
473
474 case CMD_SET:
475 if (!strcasecmp(arg, "msf"))
476 msf = 1;
477 else if (!strcasecmp(arg, "lba"))
478 msf = 0;
479 else
480 printf("%s: Invalid command arguments\n", __progname);
481 return (0);
482
483 case CMD_VOLUME:
484 if (!open_cd(cdname, 0))
485 return (0);
486
487 if (!strncasecmp(arg, "left", strlen(arg)))
488 return ioctl(fd, CDIOCSETLEFT);
489
490 if (!strncasecmp(arg, "right", strlen(arg)))
491 return ioctl(fd, CDIOCSETRIGHT);
492
493 if (!strncasecmp(arg, "mono", strlen(arg)))
494 return ioctl(fd, CDIOCSETMONO);
495
496 if (!strncasecmp(arg, "stereo", strlen(arg)))
497 return ioctl(fd, CDIOCSETSTEREO);
498
499 if (!strncasecmp(arg, "mute", strlen(arg)))
500 return ioctl(fd, CDIOCSETMUTE);
501
502 if (2 != sscanf(arg, "%d%d", &l, &r)) {
503 printf("%s: Invalid command arguments\n", __progname);
504 return (0);
505 }
506
507 return setvol(l, r);
508
509 case CMD_NEXT:
510 if (!open_cd(cdname, 0))
511 return (0);
512
513 return play_next(arg);
514
515 case CMD_PREV:
516 if (!open_cd(cdname, 0))
517 return (0);
518
519 return play_prev(arg);
520
521 case CMD_REPLAY:
522 if (!open_cd(cdname, 0))
523 return 0;
524
525 return play_same(arg);
526 case CMD_BLANK:
527 if (!open_cd(cdname, 1))
528 return 0;
529
530 if (get_media_capabilities(mediacap, 1) == -1) {
531 warnx("Can't determine media type");
532 return (0);
533 }
534 if (isset(mediacap, MMC_FEATURE_CDRW_WRITE) == 0 &&
535 get_media_type() != MEDIATYPE_CDRW) {
536 warnx("The media doesn't support blanking");
537 return (0);
538 }
539
540 return blank();
541 case CMD_CDRIP:
542 if (!open_cd(cdname, 0))
543 return (0);
544
545 while (isspace(*arg))
546 arg++;
547
548 return cdrip(arg);
549 case CMD_CDPLAY:
550 if (!open_cd(cdname, 0))
551 return (0);
552
553 while (isspace(*arg))
554 arg++;
555
556 return cdplay(arg);
557 default:
558 case CMD_HELP:
559 help();
560 return (0);
561
562 }
563 }
564
565 /*
566 * Check if audio file has RIFF WAVE format. If not, we assume it's just PCM.
567 */
568 int
is_wave(int fd)569 is_wave(int fd)
570 {
571 char buf[WAVHDRLEN];
572 int rv;
573
574 rv = 0;
575 if (read(fd, buf, sizeof(buf)) == sizeof(buf)) {
576 if (memcmp(buf, "RIFF", 4) == 0 &&
577 memcmp(buf + 8, "WAVE", 4) == 0)
578 rv = 1;
579 }
580
581 return (rv);
582 }
583
584 __dead void
tao(int argc,char ** argv)585 tao(int argc, char **argv)
586 {
587 struct stat sb;
588 struct track_info *cur_track;
589 struct track_info *tr;
590 off_t availblk, needblk = 0;
591 u_int blklen;
592 u_int ntracks = 0;
593 char type;
594 int ch, speed;
595 const char *errstr;
596
597 if (argc == 1)
598 usage();
599
600 SLIST_INIT(&tracks);
601 type = 'd';
602 speed = DRIVE_SPEED_OPTIMAL;
603 blklen = 2048;
604 while (argc > 1) {
605 tr = malloc(sizeof(struct track_info));
606 if (tr == NULL)
607 err(1, "tao");
608
609 optreset = 1;
610 optind = 1;
611 while ((ch = getopt(argc, argv, "ads:")) != -1) {
612 switch (ch) {
613 case 'a':
614 type = 'a';
615 blklen = 2352;
616 break;
617 case 'd':
618 type = 'd';
619 blklen = 2048;
620 break;
621 case 's':
622 if (strcmp(optarg, "auto") == 0) {
623 speed = DRIVE_SPEED_OPTIMAL;
624 } else if (strcmp(optarg, "max") == 0) {
625 speed = DRIVE_SPEED_MAX;
626 } else {
627 speed = (int)strtonum(optarg, 1,
628 CD_MAX_SPEED, &errstr);
629 if (errstr != NULL) {
630 errx(1,
631 "incorrect speed value");
632 }
633 }
634 break;
635 default:
636 usage();
637 /* NOTREACHED */
638 }
639 }
640
641 if (speed != DRIVE_SPEED_OPTIMAL && speed != DRIVE_SPEED_MAX)
642 tr->speed = CD_SPEED_TO_KBPS(speed, blklen);
643 else
644 tr->speed = speed;
645
646 tr->type = type;
647 tr->blklen = blklen;
648 argc -= optind;
649 argv += optind;
650 if (argv[0] == NULL)
651 usage();
652 tr->file = argv[0];
653 tr->fd = open(tr->file, O_RDONLY, 0640);
654 if (tr->fd == -1)
655 err(1, "cannot open file %s", tr->file);
656 if (fstat(tr->fd, &sb) == -1)
657 err(1, "cannot stat file %s", tr->file);
658 tr->sz = sb.st_size;
659 tr->off = 0;
660 if (tr->type == 'a') {
661 if (is_wave(tr->fd)) {
662 tr->sz -= WAVHDRLEN;
663 tr->off = WAVHDRLEN;
664 }
665 }
666 if (SLIST_EMPTY(&tracks))
667 SLIST_INSERT_HEAD(&tracks, tr, track_list);
668 else
669 SLIST_INSERT_AFTER(cur_track, tr, track_list);
670 cur_track = tr;
671 }
672
673 if (!open_cd(cdname, 1))
674 exit(1);
675 if (get_media_capabilities(mediacap, 1) == -1)
676 errx(1, "Can't determine media type");
677 if (isset(mediacap, MMC_FEATURE_CD_TAO) == 0)
678 errx(1, "The media can't be written in TAO mode");
679
680 get_disc_size(&availblk);
681 SLIST_FOREACH(tr, &tracks, track_list) {
682 needblk += tr->sz/tr->blklen;
683 ntracks++;
684 }
685 needblk += (ntracks - 1) * 150; /* transition area between tracks */
686 if (needblk > availblk)
687 errx(1, "Only %llu of the required %llu blocks available",
688 availblk, needblk);
689 if (writetao(&tracks) != 0)
690 exit(1);
691 else
692 exit(0);
693 }
694
695 int
play(char * arg)696 play(char *arg)
697 {
698 struct ioc_toc_header h;
699 unsigned char tm, ts, tf;
700 unsigned int tr1, tr2, m1, m2, s1, s2, f1, f2, i1, i2;
701 unsigned int blk, len, n;
702 char c;
703 int rc;
704
705 rc = ioctl(fd, CDIOREADTOCHEADER, &h);
706
707 if (rc < 0)
708 return (rc);
709
710 if (h.starting_track > h.ending_track) {
711 printf("TOC starting_track > TOC ending_track\n");
712 return (0);
713 }
714
715 n = h.ending_track - h.starting_track + 1;
716 rc = read_toc_entrys((n + 1) * sizeof (struct cd_toc_entry));
717
718 if (rc < 0)
719 return (rc);
720
721 /*
722 * Truncate trailing white space. Then by adding %c to the end of the
723 * sscanf() formats we catch any errant trailing characters.
724 */
725 rc = strlen(arg) - 1;
726 while (rc >= 0 && isspace(arg[rc])) {
727 arg[rc] = '\0';
728 rc--;
729 }
730
731 if (!arg || ! *arg) {
732 /* Play the whole disc */
733 return (play_track(h.starting_track, 1, h.ending_track, 1));
734 }
735
736 if (strchr(arg, '#')) {
737 /* Play block #blk [ len ] */
738 if (2 != sscanf(arg, "#%u%u%c", &blk, &len, &c) &&
739 1 != sscanf(arg, "#%u%c", &blk, &c)) {
740 printf("%s: Invalid command arguments\n", __progname);
741 return (0);
742 }
743
744 if (len == 0) {
745 if (msf)
746 len = msf2lba(toc_buffer[n].addr.msf.minute,
747 toc_buffer[n].addr.msf.second,
748 toc_buffer[n].addr.msf.frame) - blk;
749 else
750 len = toc_buffer[n].addr.lba - blk;
751 }
752 return play_blocks(blk, len);
753 }
754
755 if (strchr(arg, ':') == NULL) {
756 /*
757 * Play track tr1[.i1] [tr2[.i2]]
758 */
759 if (4 == sscanf(arg, "%u.%u%u.%u%c", &tr1, &i1, &tr2, &i2, &c))
760 goto play_track;
761
762 i2 = 1;
763 if (3 == sscanf(arg, "%u.%u%u%c", &tr1, &i1, &tr2, &c))
764 goto play_track;
765
766 i1 = 1;
767 if (3 == sscanf(arg, "%u%u.%u%c", &tr1, &tr2, &i2, &c))
768 goto play_track;
769
770 tr2 = 0;
771 i2 = 1;
772 if (2 == sscanf(arg, "%u.%u%c", &tr1, &i1, &c))
773 goto play_track;
774
775 i1 = i2 = 1;
776 if (2 == sscanf(arg, "%u%u%c", &tr1, &tr2, &c))
777 goto play_track;
778
779 i1 = i2 = 1;
780 tr2 = 0;
781 if (1 == sscanf(arg, "%u%c", &tr1, &c))
782 goto play_track;
783
784 printf("%s: Invalid command arguments\n", __progname);
785 return (0);
786
787 play_track:
788 if (tr1 > n || tr2 > n) {
789 printf("Track number must be between 0 and %u\n", n);
790 return (0);
791 } else if (tr2 == 0)
792 tr2 = h.ending_track;
793
794 if (tr1 > tr2) {
795 printf("starting_track > ending_track\n");
796 return (0);
797 }
798
799 return (play_track(tr1, i1, tr2, i2));
800 }
801
802 /*
803 * Play MSF [tr1] m1:s1[.f1] [tr2] [m2:s2[.f2]]
804 *
805 * Start Time End Time
806 * ---------- --------
807 * tr1 m1:s1.f1 tr2 m2:s2.f2
808 * tr1 m1:s1 tr2 m2:s2.f2
809 * tr1 m1:s1.f1 tr2 m2:s2
810 * tr1 m1:s1 tr2 m2:s2
811 * m1:s1.f1 tr2 m2:s2.f2
812 * m1:s1 tr2 m2:s2.f2
813 * m1:s1.f1 tr2 m2:s2
814 * m1:s1 tr2 m2:s2
815 * tr1 m1:s1.f1 m2:s2.f2
816 * tr1 m1:s1 m2:s2.f2
817 * tr1 m1:s1.f1 m2:s2
818 * tr1 m1:s1 m2:s2
819 * m1:s1.f1 m2:s2.f2
820 * m1:s1 m2:s2.f2
821 * m1:s1.f1 m2:s2
822 * m1:s1 m2:s2
823 * tr1 m1:s1.f1 tr2
824 * tr1 m1:s1 tr2
825 * m1:s1.f1 tr2
826 * m1:s1 tr2
827 * tr1 m1:s1.f1 <end of disc>
828 * tr1 m1:s1 <end of disc>
829 * m1:s1.f1 <end of disc>
830 * m1:s1 <end of disc>
831 */
832
833 /* tr1 m1:s1.f1 tr2 m2:s2.f2 */
834 if (8 == sscanf(arg, "%u%u:%u.%u%u%u:%u.%u%c",
835 &tr1, &m1, &s1, &f1, &tr2, &m2, &s2, &f2, &c))
836 goto play_msf;
837
838 /* tr1 m1:s1 tr2 m2:s2.f2 */
839 f1 = 0;
840 if (7 == sscanf(arg, "%u%u:%u%u%u:%u.%u%c",
841 &tr1, &m1, &s1, &tr2, &m2, &s2, &f2, &c))
842 goto play_msf;
843
844 /* tr1 m1:s1.f1 tr2 m2:s2 */
845 f2 =0;
846 if (7 == sscanf(arg, "%u%u:%u.%u%u%u:%u%c",
847 &tr1, &m1, &s1, &f1, &tr2, &m2, &s2, &c))
848 goto play_msf;
849
850 /* m1:s1.f1 tr2 m2:s2.f2 */
851 tr1 = 0;
852 if (7 == sscanf(arg, "%u:%u.%u%u%u:%u.%u%c",
853 &m1, &s1, &f1, &tr2, &m2, &s2, &f2, &c))
854 goto play_msf;
855
856 /* tr1 m1:s1.f1 m2:s2.f2 */
857 tr2 = 0;
858 if (7 == sscanf(arg, "%u%u:%u.%u%u:%u.%u%c",
859 &tr1, &m1, &s1, &f1, &m2, &s2, &f2, &c))
860 goto play_msf;
861
862 /* m1:s1 tr2 m2:s2.f2 */
863 tr1 = f1 = 0;
864 if (6 == sscanf(arg, "%u:%u%u%u:%u.%u%c",
865 &m1, &s1, &tr2, &m2, &s2, &f2, &c))
866 goto play_msf;
867
868 /* m1:s1.f1 tr2 m2:s2 */
869 tr1 = f2 = 0;
870 if (6 == sscanf(arg, "%u:%u.%u%u%u:%u%c",
871 &m1, &s1, &f1, &tr2, &m2, &s2, &c))
872 goto play_msf;
873
874 /* m1:s1.f1 m2:s2.f2 */
875 tr1 = tr2 = 0;
876 if (6 == sscanf(arg, "%u:%u.%u%u:%u.%u%c",
877 &m1, &s1, &f1, &m2, &s2, &f2, &c))
878 goto play_msf;
879
880 /* tr1 m1:s1.f1 m2:s2 */
881 tr2 = f2 = 0;
882 if (6 == sscanf(arg, "%u%u:%u.%u%u:%u%c",
883 &tr1, &m1, &s1, &f1, &m2, &s2, &c))
884 goto play_msf;
885
886 /* tr1 m1:s1 m2:s2.f2 */
887 tr2 = f1 = 0;
888 if (6 == sscanf(arg, "%u%u:%u%u:%u.%u%c",
889 &tr1, &m1, &s1, &m2, &s2, &f2, &c))
890 goto play_msf;
891
892 /* tr1 m1:s1 tr2 m2:s2 */
893 f1 = f2 = 0;
894 if (6 == sscanf(arg, "%u%u:%u%u%u:%u%c",
895 &tr1, &m1, &s1, &tr2, &m2, &s2, &c))
896 goto play_msf;
897
898 /* m1:s1 tr2 m2:s2 */
899 tr1 = f1 = f2 = 0;
900 if (5 == sscanf(arg, "%u:%u%u%u:%u%c", &m1, &s1, &tr2, &m2, &s2, &c))
901 goto play_msf;
902
903 /* tr1 m1:s1 m2:s2 */
904 f1 = tr2 = f2 = 0;
905 if (5 == sscanf(arg, "%u%u:%u%u:%u%c", &tr1, &m1, &s1, &m2, &s2, &c))
906 goto play_msf;
907
908 /* m1:s1 m2:s2.f2 */
909 tr1 = f1 = tr2 = 0;
910 if (5 == sscanf(arg, "%u:%u%u:%u.%u%c", &m1, &s1, &m2, &s2, &f2, &c))
911 goto play_msf;
912
913 /* m1:s1.f1 m2:s2 */
914 tr1 = tr2 = f2 = 0;
915 if (5 == sscanf(arg, "%u:%u.%u%u:%u%c", &m1, &s1, &f1, &m2, &s2, &c))
916 goto play_msf;
917
918 /* tr1 m1:s1.f1 tr2 */
919 m2 = s2 = f2 = 0;
920 if (5 == sscanf(arg, "%u%u:%u.%u%u%c", &tr1, &m1, &s1, &f1, &tr2, &c))
921 goto play_msf;
922
923 /* m1:s1 m2:s2 */
924 tr1 = f1 = tr2 = f2 = 0;
925 if (4 == sscanf(arg, "%u:%u%u:%u%c", &m1, &s1, &m2, &s2, &c))
926 goto play_msf;
927
928 /* tr1 m1:s1.f1 <end of disc> */
929 tr2 = m2 = s2 = f2 = 0;
930 if (4 == sscanf(arg, "%u%u:%u.%u%c", &tr1, &m1, &s1, &f1, &c))
931 goto play_msf;
932
933 /* tr1 m1:s1 tr2 */
934 f1 = m2 = s2 = f2 = 0;
935 if (4 == sscanf(arg, "%u%u:%u%u%c", &tr1, &m1, &s1, &tr2, &c))
936 goto play_msf;
937
938 /* m1:s1.f1 tr2 */
939 tr1 = m2 = s2 = f2 = 0;
940 if (4 == sscanf(arg, "%u%u:%u%u%c", &m1, &s1, &f1, &tr2, &c))
941 goto play_msf;
942
943 /* m1:s1.f1 <end of disc> */
944 tr1 = tr2 = m2 = s2 = f2 = 0;
945 if (3 == sscanf(arg, "%u:%u.%u%c", &m1, &s1, &f1, &c))
946 goto play_msf;
947
948 /* tr1 m1:s1 <end of disc> */
949 f1 = tr2 = m2 = s2 = f2 = 0;
950 if (3 == sscanf(arg, "%u%u:%u%c", &tr1, &m1, &s1, &c))
951 goto play_msf;
952
953 /* m1:s1 tr2 */
954 tr1 = f1 = m2 = s2 = f2 = 0;
955 if (3 == sscanf(arg, "%u:%u%u%c", &m1, &s1, &tr2, &c))
956 goto play_msf;
957
958 /* m1:s1 <end of disc> */
959 tr1 = f1 = tr2 = m2 = s2 = f2 = 0;
960 if (2 == sscanf(arg, "%u:%u%c", &m1, &s1, &c))
961 goto play_msf;
962
963 printf("%s: Invalid command arguments\n", __progname);
964 return (0);
965
966 play_msf:
967 if (tr1 > n || tr2 > n) {
968 printf("Track number must be between 0 and %u\n", n);
969 return (0);
970 } else if (m1 > 99 || m2 > 99) {
971 printf("Minutes must be between 0 and 99\n");
972 return (0);
973 } else if (s1 > 59 || s2 > 59) {
974 printf("Seconds must be between 0 and 59\n");
975 return (0);
976 } if (f1 > 74 || f2 > 74) {
977 printf("Frames number must be between 0 and 74\n");
978 return (0);
979 }
980
981 if (tr1 > 0) {
982 /*
983 * Start time is relative to tr1, Add start time of tr1
984 * to (m1,s1,f1) to yield absolute start time.
985 */
986 toc2msf(tr1, &tm, &ts, &tf);
987 addmsf(&m1, &s1, &f1, tm, ts, tf);
988
989 /* Compare (m1,s1,f1) to start time of next track. */
990 toc2msf(tr1+1, &tm, &ts, &tf);
991 if (cmpmsf(m1, s1, f1, tm, ts, tf) == 1) {
992 printf("Track %u is not that long.\n", tr1);
993 return (0);
994 }
995 }
996
997 toc2msf(n+1, &tm, &ts, &tf);
998 if (cmpmsf(m1, s1, f1, tm, ts, tf) == 1) {
999 printf("Start time is after end of disc.\n");
1000 return (0);
1001 }
1002
1003 if (tr2 > 0) {
1004 /*
1005 * End time is relative to tr2, Add start time of tr2
1006 * to (m2,s2,f2) to yield absolute end time.
1007 */
1008 toc2msf(tr2, &tm, &ts, &tf);
1009 addmsf(&m2, &s2, &f2, tm, ts, tf);
1010
1011 /* Compare (m2,s2,f2) to start time of next track. */
1012 toc2msf(tr2+1, &tm, &ts, &tf);
1013 if (cmpmsf(m2, s2, f2, tm, ts, tf) == 1) {
1014 printf("Track %u is not that long.\n", tr2);
1015 return (0);
1016 }
1017 }
1018
1019 toc2msf(n+1, &tm, &ts, &tf);
1020
1021 if (!(tr2 || m2 || s2 || f2)) {
1022 /* Play to end of disc. */
1023 m2 = tm;
1024 s2 = ts;
1025 f2 = tf;
1026 } else if (cmpmsf(m2, s2, f2, tm, ts, tf) == 1) {
1027 printf("End time is after end of disc.\n");
1028 return (0);
1029 }
1030
1031 if (cmpmsf(m1, s1, f1, m2, s2, f2) == 1) {
1032 printf("Start time is after end time.\n");
1033 return (0);
1034 }
1035
1036 return play_msf(m1, s1, f1, m2, s2, f2);
1037 }
1038
1039 /* ARGSUSED */
1040 int
play_prev(char * arg)1041 play_prev(char *arg)
1042 {
1043 int trk, min, sec, frm, rc;
1044 struct ioc_toc_header h;
1045
1046 if (status(&trk, &min, &sec, &frm) >= 0) {
1047 trk--;
1048
1049 rc = ioctl(fd, CDIOREADTOCHEADER, &h);
1050 if (rc < 0) {
1051 warn("getting toc header");
1052 return (rc);
1053 }
1054
1055 if (trk < h.starting_track)
1056 return play_track(h.starting_track, 1,
1057 h.ending_track + 1, 1);
1058 return play_track(trk, 1, h.ending_track, 1);
1059 }
1060
1061 return (0);
1062 }
1063
1064 /* ARGSUSED */
1065 int
play_same(char * arg)1066 play_same(char *arg)
1067 {
1068 int trk, min, sec, frm, rc;
1069 struct ioc_toc_header h;
1070
1071 if (status (&trk, &min, &sec, &frm) >= 0) {
1072 rc = ioctl(fd, CDIOREADTOCHEADER, &h);
1073 if (rc < 0) {
1074 warn("getting toc header");
1075 return (rc);
1076 }
1077
1078 return play_track(trk, 1, h.ending_track, 1);
1079 }
1080
1081 return (0);
1082 }
1083
1084 /* ARGSUSED */
1085 int
play_next(char * arg)1086 play_next(char *arg)
1087 {
1088 int trk, min, sec, frm, rc;
1089 struct ioc_toc_header h;
1090
1091 if (status(&trk, &min, &sec, &frm) >= 0) {
1092 trk++;
1093 rc = ioctl(fd, CDIOREADTOCHEADER, &h);
1094 if (rc < 0) {
1095 warn("getting toc header");
1096 return (rc);
1097 }
1098
1099 if (trk > h.ending_track) {
1100 printf("%s: end of CD\n", __progname);
1101
1102 rc = ioctl(fd, CDIOCSTOP);
1103
1104 (void) ioctl(fd, CDIOCALLOW);
1105
1106 return (rc);
1107 }
1108
1109 return play_track(trk, 1, h.ending_track, 1);
1110 }
1111
1112 return (0);
1113 }
1114
1115 char *
strstatus(int sts)1116 strstatus(int sts)
1117 {
1118 switch (sts) {
1119 case ASTS_INVALID:
1120 return ("invalid");
1121 case ASTS_PLAYING:
1122 return ("playing");
1123 case ASTS_PAUSED:
1124 return ("paused");
1125 case ASTS_COMPLETED:
1126 return ("completed");
1127 case ASTS_ERROR:
1128 return ("error");
1129 case ASTS_VOID:
1130 return ("void");
1131 default:
1132 return ("??");
1133 }
1134 }
1135
1136 /* ARGSUSED */
1137 int
pstatus(char * arg)1138 pstatus(char *arg)
1139 {
1140 struct ioc_vol v;
1141 struct ioc_read_subchannel ss;
1142 struct cd_sub_channel_info data;
1143 int rc, trk, m, s, f;
1144 char vis_catalog[1 + 4 * 15];
1145
1146 rc = status(&trk, &m, &s, &f);
1147 if (rc >= 0) {
1148 if (verbose) {
1149 if (track_names)
1150 printf("Audio status = %d<%s>, "
1151 "current track = %d (%s)\n"
1152 "\tcurrent position = %d:%02d.%02d\n",
1153 rc, strstatus(rc), trk,
1154 trk ? track_names[trk-1] : "", m, s, f);
1155 else
1156 printf("Audio status = %d<%s>, "
1157 "current track = %d, "
1158 "current position = %d:%02d.%02d\n",
1159 rc, strstatus(rc), trk, m, s, f);
1160 } else
1161 printf("%d %d %d:%02d.%02d\n", rc, trk, m, s, f);
1162 } else
1163 printf("No current status info available\n");
1164
1165 bzero(&ss, sizeof (ss));
1166 ss.data = &data;
1167 ss.data_len = sizeof (data);
1168 ss.address_format = msf ? CD_MSF_FORMAT : CD_LBA_FORMAT;
1169 ss.data_format = CD_MEDIA_CATALOG;
1170 rc = ioctl(fd, CDIOCREADSUBCHANNEL, (char *) &ss);
1171 if (rc >= 0) {
1172 printf("Media catalog is %sactive",
1173 ss.data->what.media_catalog.mc_valid ? "": "in");
1174 if (ss.data->what.media_catalog.mc_valid &&
1175 ss.data->what.media_catalog.mc_number[0]) {
1176 strvisx(vis_catalog,
1177 (char *)ss.data->what.media_catalog.mc_number,
1178 15, VIS_SAFE);
1179 printf(", number \"%.15s\"", vis_catalog);
1180 }
1181 putchar('\n');
1182 } else
1183 printf("No media catalog info available\n");
1184
1185 rc = ioctl(fd, CDIOCGETVOL, &v);
1186 if (rc >= 0) {
1187 if (verbose)
1188 printf("Left volume = %d, right volume = %d\n",
1189 v.vol[0], v.vol[1]);
1190 else
1191 printf("%d %d\n", v.vol[0], v.vol[1]);
1192 } else
1193 printf("No volume level info available\n");
1194 return(0);
1195 }
1196
1197 int
cdid(void)1198 cdid(void)
1199 {
1200 unsigned long id;
1201 struct ioc_toc_header h;
1202 int rc, n;
1203
1204 rc = ioctl(fd, CDIOREADTOCHEADER, &h);
1205 if (rc == -1) {
1206 warn("getting toc header");
1207 return (rc);
1208 }
1209
1210 n = h.ending_track - h.starting_track + 1;
1211 rc = read_toc_entrys((n + 1) * sizeof (struct cd_toc_entry));
1212 if (rc < 0)
1213 return (rc);
1214
1215 id = cddb_discid(n, toc_buffer);
1216 if (id) {
1217 if (verbose)
1218 printf("CDID=");
1219 printf("%08lx\n", id);
1220 }
1221 return id ? 0 : 1;
1222 }
1223
1224 /* ARGSUSED */
1225 int
info(char * arg)1226 info(char *arg)
1227 {
1228 struct ioc_toc_header h;
1229 int rc, i, n;
1230
1231 if (get_media_capabilities(mediacap, 1) == -1)
1232 errx(1, "Can't determine media type");
1233
1234 rc = ioctl(fd, CDIOREADTOCHEADER, &h);
1235 if (rc >= 0) {
1236 if (verbose)
1237 printf("Starting track = %d, ending track = %d, TOC size = %d bytes\n",
1238 h.starting_track, h.ending_track, h.len);
1239 else
1240 printf("%d %d %d\n", h.starting_track,
1241 h.ending_track, h.len);
1242 } else {
1243 warn("getting toc header");
1244 return (rc);
1245 }
1246
1247 n = h.ending_track - h.starting_track + 1;
1248 rc = read_toc_entrys((n + 1) * sizeof (struct cd_toc_entry));
1249 if (rc < 0)
1250 return (rc);
1251
1252 if (verbose) {
1253 printf("track start duration block length type\n");
1254 printf("-------------------------------------------------\n");
1255 }
1256
1257 for (i = 0; i < n; i++) {
1258 printf("%5d ", toc_buffer[i].track);
1259 prtrack(toc_buffer + i, 0, NULL);
1260 }
1261 printf("%5d ", toc_buffer[n].track);
1262 prtrack(toc_buffer + n, 1, NULL);
1263 return (0);
1264 }
1265
1266 int
cddbinfo(char * arg)1267 cddbinfo(char *arg)
1268 {
1269 struct ioc_toc_header h;
1270 int rc, i, n;
1271
1272 rc = ioctl(fd, CDIOREADTOCHEADER, &h);
1273 if (rc == -1) {
1274 warn("getting toc header");
1275 return (rc);
1276 }
1277
1278 n = h.ending_track - h.starting_track + 1;
1279 rc = read_toc_entrys((n + 1) * sizeof (struct cd_toc_entry));
1280 if (rc < 0)
1281 return (rc);
1282
1283 if (track_names)
1284 free_names(track_names);
1285 track_names = NULL;
1286
1287 track_names = cddb(cddb_host, n, toc_buffer, arg);
1288 if (!track_names)
1289 return(0);
1290
1291 printf("-------------------------------------------------\n");
1292
1293 for (i = 0; i < n; i++) {
1294 printf("%5d ", toc_buffer[i].track);
1295 prtrack(toc_buffer + i, 0, track_names[i]);
1296 }
1297 printf("%5d ", toc_buffer[n].track);
1298 prtrack(toc_buffer + n, 1, "");
1299 return (0);
1300 }
1301
1302 void
lba2msf(unsigned long lba,u_char * m,u_char * s,u_char * f)1303 lba2msf(unsigned long lba, u_char *m, u_char *s, u_char *f)
1304 {
1305 lba += 150; /* block start offset */
1306 lba &= 0xffffff; /* negative lbas use only 24 bits */
1307 *m = lba / (60 * 75);
1308 lba %= (60 * 75);
1309 *s = lba / 75;
1310 *f = lba % 75;
1311 }
1312
1313 unsigned int
msf2lba(u_char m,u_char s,u_char f)1314 msf2lba(u_char m, u_char s, u_char f)
1315 {
1316 return (((m * 60) + s) * 75 + f) - 150;
1317 }
1318
1319 unsigned long
entry2time(struct cd_toc_entry * e)1320 entry2time(struct cd_toc_entry *e)
1321 {
1322 int block;
1323 u_char m, s, f;
1324
1325 if (msf) {
1326 return (e->addr.msf.minute * 60 + e->addr.msf.second);
1327 } else {
1328 block = e->addr.lba;
1329 lba2msf(block, &m, &s, &f);
1330 return (m*60+s);
1331 }
1332 }
1333
1334 unsigned long
entry2frames(struct cd_toc_entry * e)1335 entry2frames(struct cd_toc_entry *e)
1336 {
1337 int block;
1338 unsigned char m, s, f;
1339
1340 if (msf) {
1341 return e->addr.msf.frame + e->addr.msf.second * 75 +
1342 e->addr.msf.minute * 60 * 75;
1343 } else {
1344 block = e->addr.lba;
1345 lba2msf(block, &m, &s, &f);
1346 return f + s * 75 + m * 60 * 75;
1347 }
1348 }
1349
1350 void
prtrack(struct cd_toc_entry * e,int lastflag,char * name)1351 prtrack(struct cd_toc_entry *e, int lastflag, char *name)
1352 {
1353 int block, next, len;
1354 u_char m, s, f;
1355
1356 if (msf) {
1357 if (!name || lastflag)
1358 /* Print track start */
1359 printf("%2d:%02d.%02d ", e->addr.msf.minute,
1360 e->addr.msf.second, e->addr.msf.frame);
1361
1362 block = msf2lba(e->addr.msf.minute, e->addr.msf.second,
1363 e->addr.msf.frame);
1364 } else {
1365 block = e->addr.lba;
1366 if (!name || lastflag) {
1367 lba2msf(block, &m, &s, &f);
1368 /* Print track start */
1369 printf("%2d:%02d.%02d ", m, s, f);
1370 }
1371 }
1372 if (lastflag) {
1373 if (!name)
1374 /* Last track -- print block */
1375 printf(" - %6d - -\n", block);
1376 else
1377 printf("\n");
1378 return;
1379 }
1380
1381 if (msf)
1382 next = msf2lba(e[1].addr.msf.minute, e[1].addr.msf.second,
1383 e[1].addr.msf.frame);
1384 else
1385 next = e[1].addr.lba;
1386 len = next - block;
1387 lba2msf(len - 150, &m, &s, &f);
1388
1389 if (name)
1390 printf("%2d:%02d.%02d %s\n", m, s, f, name);
1391 /* Print duration, block, length, type */
1392 else
1393 printf("%2d:%02d.%02d %6d %6d %5s\n", m, s, f, block, len,
1394 (e->control & 4) ? "data" : "audio");
1395 }
1396
1397 int
play_track(int tstart,int istart,int tend,int iend)1398 play_track(int tstart, int istart, int tend, int iend)
1399 {
1400 struct ioc_play_track t;
1401
1402 t.start_track = tstart;
1403 t.start_index = istart;
1404 t.end_track = tend;
1405 t.end_index = iend;
1406
1407 return ioctl(fd, CDIOCPLAYTRACKS, &t);
1408 }
1409
1410 int
play_blocks(int blk,int len)1411 play_blocks(int blk, int len)
1412 {
1413 struct ioc_play_blocks t;
1414
1415 t.blk = blk;
1416 t.len = len;
1417
1418 return ioctl(fd, CDIOCPLAYBLOCKS, &t);
1419 }
1420
1421 int
setvol(int left,int right)1422 setvol(int left, int right)
1423 {
1424 struct ioc_vol v;
1425
1426 v.vol[0] = left;
1427 v.vol[1] = right;
1428 v.vol[2] = 0;
1429 v.vol[3] = 0;
1430
1431 return ioctl(fd, CDIOCSETVOL, &v);
1432 }
1433
1434 int
read_toc_entrys(int len)1435 read_toc_entrys(int len)
1436 {
1437 struct ioc_read_toc_entry t;
1438
1439 if (toc_buffer) {
1440 free(toc_buffer);
1441 toc_buffer = 0;
1442 }
1443
1444 toc_buffer = malloc(len);
1445
1446 if (!toc_buffer) {
1447 errno = ENOMEM;
1448 return (-1);
1449 }
1450
1451 t.address_format = msf ? CD_MSF_FORMAT : CD_LBA_FORMAT;
1452 t.starting_track = 0;
1453 t.data_len = len;
1454 t.data = toc_buffer;
1455
1456 return (ioctl(fd, CDIOREADTOCENTRYS, (char *) &t));
1457 }
1458
1459 int
play_msf(int start_m,int start_s,int start_f,int end_m,int end_s,int end_f)1460 play_msf(int start_m, int start_s, int start_f, int end_m, int end_s, int end_f)
1461 {
1462 struct ioc_play_msf a;
1463
1464 a.start_m = start_m;
1465 a.start_s = start_s;
1466 a.start_f = start_f;
1467 a.end_m = end_m;
1468 a.end_s = end_s;
1469 a.end_f = end_f;
1470
1471 return ioctl(fd, CDIOCPLAYMSF, (char *) &a);
1472 }
1473
1474 int
status(int * trk,int * min,int * sec,int * frame)1475 status(int *trk, int *min, int *sec, int *frame)
1476 {
1477 struct ioc_read_subchannel s;
1478 struct cd_sub_channel_info data;
1479 u_char mm, ss, ff;
1480
1481 bzero(&s, sizeof (s));
1482 s.data = &data;
1483 s.data_len = sizeof (data);
1484 s.address_format = msf ? CD_MSF_FORMAT : CD_LBA_FORMAT;
1485 s.data_format = CD_CURRENT_POSITION;
1486
1487 if (ioctl(fd, CDIOCREADSUBCHANNEL, (char *) &s) < 0)
1488 return -1;
1489
1490 *trk = s.data->what.position.track_number;
1491 if (msf) {
1492 *min = s.data->what.position.reladdr.msf.minute;
1493 *sec = s.data->what.position.reladdr.msf.second;
1494 *frame = s.data->what.position.reladdr.msf.frame;
1495 } else {
1496 /*
1497 * NOTE: CDIOCREADSUBCHANNEL does not put the lba info into
1498 * host order like CDIOREADTOCENTRYS does.
1499 */
1500 lba2msf(betoh32(s.data->what.position.reladdr.lba), &mm, &ss,
1501 &ff);
1502 *min = mm;
1503 *sec = ss;
1504 *frame = ff;
1505 }
1506
1507 return s.data->header.audio_status;
1508 }
1509
1510 char *
input(int * cmd)1511 input(int *cmd)
1512 {
1513 char *buf;
1514 int siz = 0;
1515 char *p;
1516 HistEvent hev;
1517
1518 do {
1519 if ((buf = (char *) el_gets(el, &siz)) == NULL || !siz) {
1520 *cmd = CMD_QUIT;
1521 fprintf(stderr, "\r\n");
1522 return (0);
1523 }
1524 if (strlen(buf) > 1)
1525 history(hist, &hev, H_ENTER, buf);
1526 p = parse(buf, cmd);
1527 } while (!p);
1528 return (p);
1529 }
1530
1531 char *
parse(char * buf,int * cmd)1532 parse(char *buf, int *cmd)
1533 {
1534 struct cmdtab *c;
1535 char *p;
1536 size_t len;
1537
1538 for (p=buf; isspace(*p); p++)
1539 continue;
1540
1541 if (isdigit(*p) || (p[0] == '#' && isdigit(p[1]))) {
1542 *cmd = CMD_PLAY;
1543 return (p);
1544 }
1545
1546 for (buf = p; *p && ! isspace(*p); p++)
1547 continue;
1548
1549 len = p - buf;
1550 if (!len)
1551 return (0);
1552
1553 if (*p) { /* It must be a spacing character! */
1554 char *q;
1555
1556 *p++ = 0;
1557 for (q=p; *q && *q != '\n' && *q != '\r'; q++)
1558 continue;
1559 *q = 0;
1560 }
1561
1562 *cmd = -1;
1563 for (c=cmdtab; c->name; ++c) {
1564 /* Is it an exact match? */
1565 if (!strcasecmp(buf, c->name)) {
1566 *cmd = c->command;
1567 break;
1568 }
1569
1570 /* Try short hand forms then... */
1571 if (len >= c->min && ! strncasecmp(buf, c->name, len)) {
1572 if (*cmd != -1 && *cmd != c->command) {
1573 fprintf(stderr, "Ambiguous command\n");
1574 return (0);
1575 }
1576 *cmd = c->command;
1577 }
1578 }
1579
1580 if (*cmd == -1) {
1581 fprintf(stderr, "%s: Invalid command, enter ``help'' for commands.\n",
1582 __progname);
1583 return (0);
1584 }
1585
1586 while (isspace(*p))
1587 p++;
1588 return p;
1589 }
1590
1591 int
open_cd(char * dev,int needwrite)1592 open_cd(char *dev, int needwrite)
1593 {
1594 char *realdev;
1595 int tries;
1596
1597 if (fd > -1) {
1598 if (needwrite && !writeperm) {
1599 close(fd);
1600 fd = -1;
1601 } else
1602 return (1);
1603 }
1604
1605 for (tries = 0; fd < 0 && tries < 10; tries++) {
1606 if (needwrite)
1607 fd = opendev(dev, O_RDWR, OPENDEV_PART, &realdev);
1608 else
1609 fd = opendev(dev, O_RDONLY, OPENDEV_PART, &realdev);
1610 if (fd < 0) {
1611 if (errno == ENXIO) {
1612 /* ENXIO has an overloaded meaning here.
1613 * The original "Device not configured" should
1614 * be interpreted as "No disc in drive %s". */
1615 warnx("No disc in drive %s.", realdev);
1616 return (0);
1617 } else if (errno != EIO) {
1618 /* EIO may simply mean the device is not ready
1619 * yet which is common with CD changers. */
1620 warn("Can't open %s", realdev);
1621 return (0);
1622 }
1623 }
1624 sleep(1);
1625 }
1626 if (fd < 0) {
1627 warn("Can't open %s", realdev);
1628 return (0);
1629 }
1630 writeperm = needwrite;
1631 return (1);
1632 }
1633
1634 char *
prompt(void)1635 prompt(void)
1636 {
1637 return (verbose ? "cdio> " : "");
1638 }
1639
1640 void
switch_el(void)1641 switch_el(void)
1642 {
1643 HistEvent hev;
1644
1645 if (el == NULL && hist == NULL) {
1646 el = el_init(__progname, stdin, stdout, stderr);
1647 hist = history_init();
1648 history(hist, &hev, H_SETSIZE, 100);
1649 el_set(el, EL_HIST, history, hist);
1650 el_set(el, EL_EDITOR, "emacs");
1651 el_set(el, EL_PROMPT, prompt);
1652 el_set(el, EL_SIGNAL, 1);
1653 el_source(el, NULL);
1654
1655 } else {
1656 if (hist != NULL) {
1657 history_end(hist);
1658 hist = NULL;
1659 }
1660 if (el != NULL) {
1661 el_end(el);
1662 el = NULL;
1663 }
1664 }
1665 }
1666
1667 void
addmsf(u_int * m,u_int * s,u_int * f,u_char m_inc,u_char s_inc,u_char f_inc)1668 addmsf(u_int *m, u_int *s, u_int *f, u_char m_inc, u_char s_inc, u_char f_inc)
1669 {
1670 *f += f_inc;
1671 if (*f > 75) {
1672 *s += *f / 75;
1673 *f %= 75;
1674 }
1675
1676 *s += s_inc;
1677 if (*s > 60) {
1678 *m += *s / 60;
1679 *s %= 60;
1680 }
1681
1682 *m += m_inc;
1683 }
1684
1685 int
cmpmsf(u_char m1,u_char s1,u_char f1,u_char m2,u_char s2,u_char f2)1686 cmpmsf(u_char m1, u_char s1, u_char f1, u_char m2, u_char s2, u_char f2)
1687 {
1688 if (m1 > m2)
1689 return (1);
1690 else if (m1 < m2)
1691 return (-1);
1692
1693 if (s1 > s2)
1694 return (1);
1695 else if (s1 < s2)
1696 return (-1);
1697
1698 if (f1 > f2)
1699 return (1);
1700 else if (f1 < f2)
1701 return (-1);
1702
1703 return (0);
1704 }
1705
1706 void
toc2msf(u_int track,u_char * m,u_char * s,u_char * f)1707 toc2msf(u_int track, u_char *m, u_char *s, u_char *f)
1708 {
1709 struct cd_toc_entry *ctep;
1710
1711 ctep = &toc_buffer[track - 1];
1712
1713 if (msf) {
1714 *m = ctep->addr.msf.minute;
1715 *s = ctep->addr.msf.second;
1716 *f = ctep->addr.msf.frame;
1717 } else
1718 lba2msf(ctep->addr.lba, m, s, f);
1719 }
1720