1 /* 2 * Copyright (c) 2001 Cameron Grant <gandalf@vilnya.demon.co.uk> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD: src/sys/dev/sound/pcm/vchan.c,v 1.5.2.4 2003/02/11 15:54:16 orion Exp $ 27 * $DragonFly: src/sys/dev/sound/pcm/vchan.c,v 1.2 2003/06/17 04:28:31 dillon Exp $ 28 */ 29 30 #include <dev/sound/pcm/sound.h> 31 #include <dev/sound/pcm/vchan.h> 32 #include "feeder_if.h" 33 34 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pcm/vchan.c,v 1.2 2003/06/17 04:28:31 dillon Exp $"); 35 36 struct vchinfo { 37 u_int32_t spd, fmt, blksz, bps, run; 38 struct pcm_channel *channel, *parent; 39 struct pcmchan_caps caps; 40 }; 41 42 static u_int32_t vchan_fmt[] = { 43 AFMT_STEREO | AFMT_S16_LE, 44 0 45 }; 46 47 static int 48 vchan_mix_s16(int16_t *to, int16_t *tmp, unsigned int count) 49 { 50 /* 51 * to is the output buffer, tmp is the input buffer 52 * count is the number of 16bit samples to mix 53 */ 54 int i; 55 int x; 56 57 for(i = 0; i < count; i++) { 58 x = to[i]; 59 x += tmp[i]; 60 if (x < -32768) { 61 /* printf("%d + %d = %d (u)\n", to[i], tmp[i], x); */ 62 x = -32768; 63 } 64 if (x > 32767) { 65 /* printf("%d + %d = %d (o)\n", to[i], tmp[i], x); */ 66 x = 32767; 67 } 68 to[i] = x & 0x0000ffff; 69 } 70 return 0; 71 } 72 73 static int 74 feed_vchan_s16(struct pcm_feeder *f, struct pcm_channel *c, u_int8_t *b, u_int32_t count, void *source) 75 { 76 /* we're going to abuse things a bit */ 77 struct snd_dbuf *src = source; 78 struct pcmchan_children *cce; 79 struct pcm_channel *ch; 80 int16_t *tmp, *dst; 81 unsigned int cnt; 82 83 KASSERT(sndbuf_getsize(src) >= count, ("bad bufsize")); 84 count &= ~1; 85 bzero(b, count); 86 87 /* 88 * we are going to use our source as a temporary buffer since it's 89 * got no other purpose. we obtain our data by traversing the channel 90 * list of children and calling vchan_mix_* to mix count bytes from each 91 * into our destination buffer, b 92 */ 93 dst = (int16_t *)b; 94 tmp = (int16_t *)sndbuf_getbuf(src); 95 bzero(tmp, count); 96 SLIST_FOREACH(cce, &c->children, link) { 97 ch = cce->channel; 98 if (ch->flags & CHN_F_TRIGGERED) { 99 if (ch->flags & CHN_F_MAPPED) 100 sndbuf_acquire(ch->bufsoft, NULL, sndbuf_getfree(ch->bufsoft)); 101 cnt = FEEDER_FEED(ch->feeder, ch, (u_int8_t *)tmp, count, ch->bufsoft); 102 vchan_mix_s16(dst, tmp, cnt / 2); 103 } 104 } 105 106 return count; 107 } 108 109 static struct pcm_feederdesc feeder_vchan_s16_desc[] = { 110 {FEEDER_MIXER, AFMT_S16_LE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0}, 111 {0}, 112 }; 113 static kobj_method_t feeder_vchan_s16_methods[] = { 114 KOBJMETHOD(feeder_feed, feed_vchan_s16), 115 { 0, 0 } 116 }; 117 FEEDER_DECLARE(feeder_vchan_s16, 2, NULL); 118 119 /************************************************************/ 120 121 static void * 122 vchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir) 123 { 124 struct vchinfo *ch; 125 struct pcm_channel *parent = devinfo; 126 127 KASSERT(dir == PCMDIR_PLAY, ("vchan_init: bad direction")); 128 ch = malloc(sizeof(*ch), M_DEVBUF, M_WAITOK | M_ZERO); 129 ch->parent = parent; 130 ch->channel = c; 131 ch->fmt = AFMT_U8; 132 ch->spd = DSP_DEFAULT_SPEED; 133 ch->blksz = 2048; 134 135 c->flags |= CHN_F_VIRTUAL; 136 137 return ch; 138 } 139 140 static int 141 vchan_free(kobj_t obj, void *data) 142 { 143 return 0; 144 } 145 146 static int 147 vchan_setformat(kobj_t obj, void *data, u_int32_t format) 148 { 149 struct vchinfo *ch = data; 150 struct pcm_channel *parent = ch->parent; 151 152 ch->fmt = format; 153 ch->bps = 1; 154 ch->bps <<= (ch->fmt & AFMT_STEREO)? 1 : 0; 155 ch->bps <<= (ch->fmt & AFMT_16BIT)? 1 : 0; 156 ch->bps <<= (ch->fmt & AFMT_32BIT)? 2 : 0; 157 chn_notify(parent, CHN_N_FORMAT); 158 return 0; 159 } 160 161 static int 162 vchan_setspeed(kobj_t obj, void *data, u_int32_t speed) 163 { 164 struct vchinfo *ch = data; 165 struct pcm_channel *parent = ch->parent; 166 167 ch->spd = speed; 168 chn_notify(parent, CHN_N_RATE); 169 return speed; 170 } 171 172 static int 173 vchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize) 174 { 175 struct vchinfo *ch = data; 176 struct pcm_channel *parent = ch->parent; 177 int prate, crate; 178 179 ch->blksz = blocksize; 180 chn_notify(parent, CHN_N_BLOCKSIZE); 181 182 crate = ch->spd * ch->bps; 183 prate = sndbuf_getspd(parent->bufhard) * sndbuf_getbps(parent->bufhard); 184 blocksize = sndbuf_getblksz(parent->bufhard); 185 blocksize *= prate; 186 blocksize /= crate; 187 188 return blocksize; 189 } 190 191 static int 192 vchan_trigger(kobj_t obj, void *data, int go) 193 { 194 struct vchinfo *ch = data; 195 struct pcm_channel *parent = ch->parent; 196 197 if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD) 198 return 0; 199 200 ch->run = (go == PCMTRIG_START)? 1 : 0; 201 chn_notify(parent, CHN_N_TRIGGER); 202 203 return 0; 204 } 205 206 static struct pcmchan_caps * 207 vchan_getcaps(kobj_t obj, void *data) 208 { 209 struct vchinfo *ch = data; 210 211 ch->caps.minspeed = sndbuf_getspd(ch->parent->bufhard); 212 ch->caps.maxspeed = ch->caps.minspeed; 213 ch->caps.fmtlist = vchan_fmt; 214 ch->caps.caps = 0; 215 216 return &ch->caps; 217 } 218 219 static kobj_method_t vchan_methods[] = { 220 KOBJMETHOD(channel_init, vchan_init), 221 KOBJMETHOD(channel_free, vchan_free), 222 KOBJMETHOD(channel_setformat, vchan_setformat), 223 KOBJMETHOD(channel_setspeed, vchan_setspeed), 224 KOBJMETHOD(channel_setblocksize, vchan_setblocksize), 225 KOBJMETHOD(channel_trigger, vchan_trigger), 226 KOBJMETHOD(channel_getcaps, vchan_getcaps), 227 { 0, 0 } 228 }; 229 CHANNEL_DECLARE(vchan); 230 231 /* virtual channel interface */ 232 233 int 234 vchan_create(struct pcm_channel *parent) 235 { 236 struct snddev_info *d = parent->parentsnddev; 237 struct pcmchan_children *pce; 238 struct pcm_channel *child; 239 int err, first; 240 241 CHN_LOCK(parent); 242 if (!(parent->flags & CHN_F_BUSY)) { 243 CHN_UNLOCK(parent); 244 return EBUSY; 245 } 246 247 pce = malloc(sizeof(*pce), M_DEVBUF, M_WAITOK | M_ZERO); 248 if (!pce) { 249 CHN_UNLOCK(parent); 250 return ENOMEM; 251 } 252 253 /* create a new playback channel */ 254 child = pcm_chn_create(d, parent, &vchan_class, PCMDIR_VIRTUAL, parent); 255 if (!child) { 256 free(pce, M_DEVBUF); 257 CHN_UNLOCK(parent); 258 return ENODEV; 259 } 260 261 first = SLIST_EMPTY(&parent->children); 262 /* add us to our parent channel's children */ 263 pce->channel = child; 264 SLIST_INSERT_HEAD(&parent->children, pce, link); 265 CHN_UNLOCK(parent); 266 267 /* add us to our grandparent's channel list */ 268 err = pcm_chn_add(d, child, !first); 269 if (err) { 270 pcm_chn_destroy(child); 271 free(pce, M_DEVBUF); 272 } 273 274 /* XXX gross ugly hack, kill murder death */ 275 if (first && !err) { 276 err = chn_reset(parent, AFMT_STEREO | AFMT_S16_LE); 277 if (err) 278 printf("chn_reset: %d\n", err); 279 err = chn_setspeed(parent, 44100); 280 if (err) 281 printf("chn_setspeed: %d\n", err); 282 } 283 284 return err; 285 } 286 287 int 288 vchan_destroy(struct pcm_channel *c) 289 { 290 struct pcm_channel *parent = c->parentchannel; 291 struct snddev_info *d = parent->parentsnddev; 292 struct pcmchan_children *pce; 293 int err, last; 294 295 CHN_LOCK(parent); 296 if (!(parent->flags & CHN_F_BUSY)) { 297 CHN_UNLOCK(parent); 298 return EBUSY; 299 } 300 if (SLIST_EMPTY(&parent->children)) { 301 CHN_UNLOCK(parent); 302 return EINVAL; 303 } 304 305 /* remove us from our parent's children list */ 306 SLIST_FOREACH(pce, &parent->children, link) { 307 if (pce->channel == c) 308 goto gotch; 309 } 310 CHN_UNLOCK(parent); 311 return EINVAL; 312 gotch: 313 SLIST_REMOVE(&parent->children, pce, pcmchan_children, link); 314 free(pce, M_DEVBUF); 315 316 last = SLIST_EMPTY(&parent->children); 317 if (last) 318 parent->flags &= ~CHN_F_BUSY; 319 320 /* remove us from our grantparent's channel list */ 321 err = pcm_chn_remove(d, c, !last); 322 if (err) 323 return err; 324 325 CHN_UNLOCK(parent); 326 /* destroy ourselves */ 327 err = pcm_chn_destroy(c); 328 329 return err; 330 } 331 332 int 333 vchan_initsys(device_t dev) 334 { 335 #ifdef SND_DYNSYSCTL 336 struct snddev_info *d; 337 338 d = device_get_softc(dev); 339 SYSCTL_ADD_PROC(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)), 340 OID_AUTO, "vchans", CTLTYPE_INT | CTLFLAG_RW, d, sizeof(d), 341 sysctl_hw_snd_vchans, "I", "") 342 #endif 343 344 return 0; 345 } 346 347 348