Lines Matching refs:track
66 * Terminology: "sample", "channel", "frame", "block", "track":
75 * +------:------:------:- -+------+ : +------+-.. | track
92 * - A "track" is single completed audio stream.
95 * track consists of 2.1(=3) channels 44.1kHz 16bit PCM,
175 * - track->lock. This is an atomic variable and is similar to the
176 * "interrupt lock". This is one for each track. If any thread context
178 * want to access some variables on this track, they must acquire this
179 * lock before. It protects track's consistency between hardware
409 audio_tracet(const char *funcname, audio_track_t *track, const char *fmt, ...)
414 snprintf(hdr, sizeof(hdr), "#%d ", track->id);
416 audio_vtrace(track->mixer->sc, funcname, hdr, fmt, ap);
466 audio_track_bufstat(audio_track_t *track, struct audio_track_debugbuf *buf)
472 track->outbuf.head, track->outbuf.used, track->outbuf.capacity);
473 if (track->freq.filter)
475 track->freq.srcbuf.head,
476 track->freq.srcbuf.used,
477 track->freq.srcbuf.capacity);
478 if (track->chmix.filter)
480 track->chmix.srcbuf.used);
481 if (track->chvol.filter)
483 track->chvol.srcbuf.used);
484 if (track->codec.filter)
486 track->codec.srcbuf.used);
488 track->usrbuf.head, track->usrbuf.used, track->usrbuf_usedhigh);
731 /* Return true if this track is a playback track. */
733 audio_track_is_playback(const audio_track_t *track)
736 return ((track->mode & AUMODE_PLAY) != 0);
740 /* Return true if this track is a recording track. */
742 audio_track_is_record(const audio_track_t *track)
745 return ((track->mode & AUMODE_RECORD) != 0);
1084 * Init track mixers. If at least one direction is available on
1695 audio_track_waitio(struct audio_softc *sc, audio_track_t *track,
1700 KASSERT(track);
1704 error = cv_timedwait_sig(&track->mixer->outcv, sc->sc_lock,
1709 TRACET(2, track, "timeout (suspending)");
1717 TRACET(2, track, "cv_timedwait_sig failed %d", error);
1719 audio_ring_t *usrbuf = &track->usrbuf;
1720 audio_ring_t *outbuf = &track->outbuf;
1723 mess, (int)track->seq,
1724 usrbuf->used, track->usrbuf_usedhigh,
1728 TRACET(3, track, "wakeup");
1734 * Try to acquire track lock.
1735 * It doesn't block if the track lock is already acquired.
1736 * Returns true if the track lock was acquired, or false if the track
1740 audio_track_lock_tryenter(audio_track_t *track)
1743 if (atomic_swap_uint(&track->lock, 1) != 0)
1750 * Acquire track lock.
1753 audio_track_lock_enter(audio_track_t *track)
1757 while (audio_track_lock_tryenter(track) == false)
1762 * Release track lock.
1765 audio_track_lock_exit(audio_track_t *track)
1768 atomic_store_release(&track->lock, 0);
1829 * - unplug track from the trackmixer (and unplug anything from softc),
2243 * - unplug track from the trackmixer if sc exist.
2379 TRACE(1, "record track already exists");
2388 TRACE(1, "play track already exists");
2634 * Since track here is not yet linked to sc_files,
2721 /* Call hw halt_output if this is the last playback track. */
2747 /* Call hw halt_input if this is the last recording track. */
2759 /* Call hw close if this is the last track. */
2785 audio_track_t *track;
2795 track = file->rtrack;
2796 if (track == NULL) {
2801 if (track->mmapped)
2804 TRACET(2, track, "resid=%zd ioflag=0x%x", uio->uio_resid, ioflag);
2819 usrbuf = &track->usrbuf;
2820 input = track->input;
2826 TRACET(3, track,
2836 audio_track_lock_enter(track);
2838 audio_track_lock_exit(track);
2847 TRACET(3, track, "sleep");
2848 error = audio_track_waitio(sc, track, "audio_read");
2856 audio_track_lock_enter(track);
2859 audio_track_record(track);
2867 audio_track_lock_exit(track);
2874 TRACET(3, track, "uiomove(len=%d) usrbuf=%d/%d/C%d",
2878 audio_track_lock_exit(track);
2887 * Clear file's playback and/or record track buffer immediately.
2906 audio_track_t *track;
2911 track = file->ptrack;
2912 if (track == NULL)
2916 if (track->mmapped)
2919 TRACET(2, track, "%sresid=%zd pid=%d.%d ioflag=0x%x",
2924 track->eofcounter++;
2944 usrbuf = &track->usrbuf;
2945 outbuf = &track->outbuf;
2946 track->pstate = AUDIO_STATE_RUNNING;
2952 TRACET(3, track, "while resid=%zd usrbuf=%d/%d/H%d",
2954 usrbuf->head, usrbuf->used, track->usrbuf_usedhigh);
2960 audio_track_lock_enter(track);
2961 full = (usrbuf->used >= track->usrbuf_usedhigh &&
2963 audio_track_lock_exit(track);
2973 TRACET(3, track, "sleep usrbuf=%d/H%d",
2974 usrbuf->used, track->usrbuf_usedhigh);
2975 error = audio_track_waitio(sc, track, "audio_write");
2983 audio_track_lock_enter(track);
2986 bytes = uimin(track->usrbuf_usedhigh - usrbuf->used,
2994 audio_track_lock_exit(track);
3001 TRACET(3, track, "uiomove(len=%d) usrbuf=%d/%d/C%d",
3008 while (usrbuf->used >= track->usrbuf_blksize &&
3010 audio_track_play(track);
3013 audio_track_lock_exit(track);
3017 TRACET(3, track, "done error=%d", error);
3030 audio_track_t *track;
3083 track = file->rtrack;
3084 if (track) {
3085 val = audio_track_readablebytes(track);
3087 TRACET(2, track, "pid=%d.%d FIONREAD bytes=%d",
3090 TRACEF(2, file, "pid=%d.%d FIONREAD no track",
3121 track = (cmd == AUDIO_PERROR) ? file->ptrack : file->rtrack;
3122 if (track) {
3123 val = frametobyte(&track->usrbuf.fmt,
3124 track->dropframes);
3126 TRACET(2, track, "%s bytes=%d", pre, val);
3128 TRACEF(2, file, "%s no track", pre);
3134 track = file->rtrack;
3135 if (track
3145 stamp = track->stamp;
3146 offset = auring_tail(track->input);
3151 ao->samples = stamp * track->usrbuf_blksize;
3152 ao->deltablks = stamp - track->last_stamp;
3153 ao->offset = audio_track_inputblk_as_usrbyte(track, offset);
3154 TRACET(2, track, "%s samples=%u deltablks=%u offset=%u",
3157 track->last_stamp = stamp;
3162 track = file->ptrack;
3163 if (track == NULL) {
3173 stamp = track->stamp;
3174 offset = track->usrbuf.head;
3179 ao->samples = stamp * track->usrbuf_blksize;
3180 ao->deltablks = stamp - track->last_stamp;
3182 TRACET(2, track, "%s samples=%u deltablks=%u offset=%u",
3185 track->last_stamp = stamp;
3189 track = file->ptrack;
3190 if (track) {
3191 val = track->usrbuf.used;
3193 TRACET(2, track, "%s bytes=%d", pre, val);
3233 track = file->ptrack;
3234 if (track) {
3235 TRACET(2, track, "%s", pre);
3237 error = audio_track_drain(sc, track);
3359 * This function is for recording track only.
3362 audio_track_inputblk_as_usrbyte(const audio_track_t *track, int n)
3367 * In the input buffer on recording track, these are the same.
3368 * input_fpb = frame_per_block(track->mixer, &track->input->fmt);
3370 input_fpb = track->mixer->frames_per_block;
3372 return (n / input_fpb) * track->usrbuf_blksize;
3379 audio_track_readablebytes(const audio_track_t *track)
3383 KASSERT(track);
3384 KASSERT(track->mode == AUMODE_RECORD);
3387 * For recording, track->input is the main block-unit buffer and
3388 * track->usrbuf holds less than one block of byte data ("fragment").
3397 bytes = audio_track_inputblk_as_usrbyte(track, track->input->used);
3398 if (track->input->used < track->input->capacity) {
3399 bytes += track->usrbuf.used;
3411 audio_track_t *track;
3431 track = file->rtrack;
3432 if (track) {
3435 used = audio_track_readablebytes(track);
3441 track = file->ptrack;
3442 if (track) {
3444 if (track->usrbuf.used <= track->usrbuf_usedlow)
3495 audio_track_t *track;
3498 track = file->rtrack;
3505 if (track == NULL) {
3511 kn->kn_data = audio_track_readablebytes(track);
3542 audio_track_t *track;
3545 track = file->ptrack;
3552 if (track == NULL) {
3558 kn->kn_data = track->usrbuf_usedhigh - track->usrbuf.used;
3560 return (track->usrbuf.used < track->usrbuf_usedlow);
3605 audio_track_t *track;
3634 track = file->ptrack;
3636 track = file->rtrack;
3640 track = file->ptrack;
3642 if (track == NULL)
3646 if (track->mmapped)
3650 vsize = roundup2(MAX(track->usrbuf.capacity, PAGE_SIZE), PAGE_SIZE);
3687 audio_track_lock_enter(track);
3688 kmem_free(track->usrbuf.mem, track->usrbuf_allocsize);
3689 track->usrbuf.mem = (void *)vstart;
3690 track->usrbuf_allocsize = vsize;
3691 memset(track->usrbuf.mem, 0, vsize);
3692 track->mmapped = true;
3693 audio_track_lock_exit(track);
3784 audio_free_usrbuf(audio_track_t *track)
3789 if (track->usrbuf_allocsize != 0) {
3790 if (track->mmapped) {
3797 vstart = (vaddr_t)track->usrbuf.mem;
3798 vsize = track->usrbuf_allocsize;
3800 track->mmapped = false;
3802 kmem_free(track->usrbuf.mem, track->usrbuf_allocsize);
3805 track->usrbuf.mem = NULL;
3806 track->usrbuf.capacity = 0;
3807 track->usrbuf_allocsize = 0;
3812 * arg->context points track->ch_volume[].
3966 audio_track_t *track;
3981 track = arg->context;
3982 KASSERT(track);
3983 src = &track->freq.srcbuf;
3984 dst = track->freq.dst;
3991 KASSERTMSG(src->head % track->mixer->frames_per_block == 0,
3992 "src->head=%d track->mixer->frames_per_block=%d",
3993 src->head, track->mixer->frames_per_block);
4027 prev[ch] = track->freq_prev[ch];
4028 curr[ch] = track->freq_curr[ch];
4032 step = track->freq_step;
4033 t = track->freq_current;
4041 PRINTF("upstart step=%d leap=%d", step, track->freq_leap);
4083 t += track->freq_leap;
4085 track->freq_current = t;
4087 track->freq_prev[ch] = prev[ch];
4088 track->freq_curr[ch] = curr[ch];
4099 audio_track_t *track;
4110 track = arg->context;
4111 KASSERT(track);
4112 src = &track->freq.srcbuf;
4113 dst = track->freq.dst;
4121 KASSERTMSG(src->head % track->mixer->frames_per_block == 0,
4122 "src->head=%d track->mixer->frames_per_block=%d",
4123 src->head, track->mixer->frames_per_block);
4127 t = track->freq_current;
4128 step = track->freq_step;
4130 PRINTF("downstart step=%d leap=%d", step, track->freq_leap);
4146 t += track->freq_leap;
4150 track->freq_current = t % 65536;
4154 * Creates track and returns it.
4160 audio_track_t *track;
4163 track = kmem_zalloc(sizeof(*track), KM_SLEEP);
4165 track->id = newid++;
4166 track->mixer = mixer;
4167 track->mode = mixer->mode;
4170 TRACET(3, track, "for %s",
4174 track->volume = 256;
4177 track->ch_volume[i] = 256;
4180 return track;
4184 * Release all resources of the track and track itself.
4185 * track must not be NULL. Don't specify the track within the file
4189 audio_track_destroy(audio_track_t *track)
4192 KASSERT(track);
4194 audio_free_usrbuf(track);
4195 audio_free(track->codec.srcbuf.mem);
4196 audio_free(track->chvol.srcbuf.mem);
4197 audio_free(track->chmix.srcbuf.mem);
4198 audio_free(track->freq.srcbuf.mem);
4199 audio_free(track->outbuf.mem);
4201 kmem_free(track, sizeof(*track));
4210 audio_track_get_codec(audio_track_t *track, const audio_format2_t *src,
4232 TRACET(1, track, "unsupported %s stride %d",
4255 TRACET(1, track, "unsupported %s stride %d",
4262 TRACET(1, track, "unsupported encoding");
4268 TRACET(2, track, "src %s", buf);
4270 TRACET(2, track, "dst %s", buf);
4277 * Initialize the codec stage of this track as necessary.
4283 audio_track_init_codec(audio_track_t *track, audio_ring_t **last_dstp)
4293 KASSERT(track);
4297 srcfmt = &track->inputfmt;
4298 srcbuf = &track->codec.srcbuf;
4304 track->codec.dst = last_dst;
4311 track->codec.filter = audio_track_get_codec(track,
4313 if (track->codec.filter == NULL) {
4320 srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
4324 arg = &track->codec.arg;
4334 track->codec.filter = NULL;
4340 * Initialize the chvol stage of this track as necessary.
4346 audio_track_init_chvol(audio_track_t *track, audio_ring_t **last_dstp)
4356 KASSERT(track);
4360 srcfmt = &track->inputfmt;
4361 srcbuf = &track->chvol.srcbuf;
4367 if (track->ch_volume[ch] != 256) {
4374 track->chvol.dst = last_dst;
4375 track->chvol.filter = audio_track_chvol;
4382 srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
4386 arg = &track->chvol.arg;
4389 arg->context = track->ch_volume;
4395 track->chvol.filter = NULL;
4401 * Initialize the chmix stage of this track as necessary.
4407 audio_track_init_chmix(audio_track_t *track, audio_ring_t **last_dstp)
4419 KASSERT(track);
4423 srcfmt = &track->inputfmt;
4424 srcbuf = &track->chmix.srcbuf;
4430 track->chmix.dst = last_dst;
4433 track->chmix.filter = audio_track_chmix_mixLR;
4435 track->chmix.filter = audio_track_chmix_dupLR;
4437 track->chmix.filter = audio_track_chmix_shrink;
4439 track->chmix.filter = audio_track_chmix_expand;
4448 srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
4452 arg = &track->chmix.arg;
4461 track->chmix.filter = NULL;
4467 * Initialize the freq stage of this track as necessary.
4473 audio_track_init_freq(audio_track_t *track, audio_ring_t **last_dstp)
4487 KASSERT(track);
4491 srcfmt = &track->inputfmt;
4492 srcbuf = &track->freq.srcbuf;
4498 track->freq.dst = last_dst;
4500 memset(track->freq_prev, 0, sizeof(track->freq_prev));
4501 memset(track->freq_curr, 0, sizeof(track->freq_curr));
4504 track->freq_step = (uint64_t)srcfreq * 65536 / dstfreq;
4506 dst_capacity = frame_per_block(track->mixer, dstfmt);
4508 track->freq_leap = (mod * dst_capacity + dstfreq / 2) / dstfreq;
4510 if (track->freq_step < 65536) {
4511 track->freq.filter = audio_track_freq_up;
4513 track->freq_current = 65536;
4515 track->freq.filter = audio_track_freq_down;
4516 track->freq_current = 0;
4524 srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
4528 arg = &track->freq.arg;
4531 arg->context = track;
4537 track->freq.filter = NULL;
4556 * recording track. In this example, both have two conversion stages, codec
4559 * On playback track:
4597 * On recording track:
4638 * Set the userland format of this track.
4646 * It must be called with track lock held since it may release and reallocate
4650 audio_track_set_format(audio_track_t *track, audio_format2_t *usrfmt)
4659 KASSERT(track);
4661 is_playback = audio_track_is_playback(track);
4663 /* Once mmap is called, the track format cannot be changed. */
4664 if (track->mmapped)
4668 track->usrbuf.fmt = *usrfmt;
4672 * On the playback track, its capacity is less than or equal to 64KB
4676 * On the recording track, its capacity is one block.
4697 track->usrbuf_blksize = frametobyte(&track->usrbuf.fmt,
4698 frame_per_block(track->mixer, &track->usrbuf.fmt));
4699 track->usrbuf.head = 0;
4700 track->usrbuf.used = 0;
4702 newbufsize = track->usrbuf_blksize * AUMINNOBLK;
4704 newbufsize = rounddown(65536, track->usrbuf_blksize);
4707 newbufsize = track->usrbuf_blksize;
4708 newvsize = track->usrbuf_blksize;
4715 if (newvsize != track->usrbuf_allocsize) {
4716 if (track->usrbuf_allocsize != 0) {
4717 kmem_free(track->usrbuf.mem, track->usrbuf_allocsize);
4719 TRACET(2, track, "usrbuf_allocsize %d -> %d",
4720 track->usrbuf_allocsize, newvsize);
4721 track->usrbuf.mem = kmem_alloc(newvsize, KM_SLEEP);
4722 track->usrbuf_allocsize = newvsize;
4724 track->usrbuf.capacity = newbufsize;
4729 track->usrbuf_usedhigh = track->usrbuf.capacity;
4730 track->usrbuf_usedlow = track->usrbuf.capacity * 3 / 4;
4733 track->usrbuf_usedhigh = track->usrbuf.capacity;
4734 track->usrbuf_usedlow = 0;
4738 last_dst = &track->outbuf;
4741 track->inputfmt = *usrfmt;
4742 track->outbuf.fmt = track->mixer->track_fmt;
4744 if ((error = audio_track_init_freq(track, &last_dst)) != 0)
4746 if ((error = audio_track_init_chmix(track, &last_dst)) != 0)
4748 if ((error = audio_track_init_chvol(track, &last_dst)) != 0)
4750 if ((error = audio_track_init_codec(track, &last_dst)) != 0)
4754 track->inputfmt = track->mixer->track_fmt;
4755 track->outbuf.fmt = *usrfmt;
4757 if ((error = audio_track_init_codec(track, &last_dst)) != 0)
4759 if ((error = audio_track_init_chvol(track, &last_dst)) != 0)
4761 if ((error = audio_track_init_chmix(track, &last_dst)) != 0)
4763 if ((error = audio_track_init_freq(track, &last_dst)) != 0)
4769 if (track->freq.filter) {
4771 &track->freq.srcbuf.fmt);
4773 &track->freq.dst->fmt);
4775 if (track->chmix.filter) {
4777 &track->chmix.srcbuf.fmt);
4779 &track->chmix.dst->fmt);
4781 if (track->chvol.filter) {
4783 &track->chvol.srcbuf.fmt);
4785 &track->chvol.dst->fmt);
4787 if (track->codec.filter) {
4789 &track->codec.srcbuf.fmt);
4791 &track->codec.dst->fmt);
4797 track->input = last_dst;
4801 * On the playback track, its capacity is NBLKOUT blocks.
4802 * On the recording track, its capacity is 1 block.
4804 track->outbuf.head = 0;
4805 track->outbuf.used = 0;
4806 track->outbuf.capacity = frame_per_block(track->mixer,
4807 &track->outbuf.fmt);
4809 track->outbuf.capacity *= NBLKOUT;
4810 len = auring_bytelen(&track->outbuf);
4811 track->outbuf.mem = audio_realloc(track->outbuf.mem, len);
4814 * On the recording track, expand the input stage buffer, which is
4821 input_fpb = frame_per_block(track->mixer, &track->input->fmt);
4822 track->input->capacity = input_fpb * NBLKIN;
4823 len = auring_bytelen(track->input);
4824 track->input->mem = audio_realloc(track->input->mem, len);
4833 track->outbuf.capacity * frametobyte(&track->outbuf.fmt,1));
4834 if (track->freq.filter)
4836 track->freq.srcbuf.capacity *
4837 frametobyte(&track->freq.srcbuf.fmt, 1));
4838 if (track->chmix.filter)
4840 track->chmix.srcbuf.capacity *
4841 frametobyte(&track->chmix.srcbuf.fmt, 1));
4842 if (track->chvol.filter)
4844 track->chvol.srcbuf.capacity *
4845 frametobyte(&track->chvol.srcbuf.fmt, 1));
4846 if (track->codec.filter)
4848 track->codec.srcbuf.capacity *
4849 frametobyte(&track->codec.srcbuf.fmt, 1));
4851 " usr=%d", track->usrbuf.capacity);
4854 TRACET(0, track, "bufsize%s%s%s%s%s%s",
4858 TRACET(0, track, "bufsize%s%s%s%s%s%s",
4867 audio_free_usrbuf(track);
4868 audio_free(track->codec.srcbuf.mem);
4869 audio_free(track->chvol.srcbuf.mem);
4870 audio_free(track->chmix.srcbuf.mem);
4871 audio_free(track->freq.srcbuf.mem);
4872 audio_free(track->outbuf.mem);
4882 audio_append_silence(audio_track_t *track, audio_ring_t *ring)
4887 KASSERT(track);
4896 fpb = frame_per_block(track->mixer, &ring->fmt);
4923 audio_apply_stage(audio_track_t *track, audio_stage_t *stage, bool isfreq)
4930 KASSERT(track);
4938 count = uimin(dstcount, track->mixer->frames_per_block);
4964 audio_track_play(audio_track_t *track)
4972 KASSERT(track);
4973 KASSERT(track->lock);
4974 TRACET(4, track, "start pstate=%d", track->pstate);
4977 KASSERT(track->usrbuf.used > 0);
4979 count = auring_get_contig_free(&track->outbuf);
4980 KASSERTMSG(count >= frame_per_block(track->mixer, &track->outbuf.fmt),
4982 count, frame_per_block(track->mixer, &track->outbuf.fmt));
4984 usrbuf = &track->usrbuf;
4985 input = track->input;
5003 count = uimin(usrbuf->used, track->usrbuf_blksize) / framesize;
5034 if (track->codec.filter)
5035 audio_apply_stage(track, &track->codec, false);
5038 if (track->chvol.filter)
5039 audio_apply_stage(track, &track->chvol, false);
5042 if (track->chmix.filter)
5043 audio_apply_stage(track, &track->chmix, false);
5050 if (track->freq.filter) {
5052 n = audio_append_silence(track, &track->freq.srcbuf);
5054 TRACET(4, track,
5057 track->freq.srcbuf.head,
5058 track->freq.srcbuf.used,
5059 track->freq.srcbuf.capacity);
5061 if (track->freq.srcbuf.used > 0) {
5062 audio_apply_stage(track, &track
5066 if (bytes < track->usrbuf_blksize) {
5075 TRACET(4, track, "reset stage");
5076 if (track->codec.filter) {
5077 KASSERT(track->codec.srcbuf.used == 0);
5078 track->codec.srcbuf.head = 0;
5080 if (track->chvol.filter) {
5081 KASSERT(track->chvol.srcbuf.used == 0);
5082 track->chvol.srcbuf.head = 0;
5084 if (track->chmix.filter) {
5085 KASSERT(track->chmix.srcbuf.used == 0);
5086 track->chmix.srcbuf.head = 0;
5088 if (track->freq.filter) {
5089 KASSERT(track->freq.srcbuf.used == 0);
5090 track->freq.srcbuf.head = 0;
5094 track->stamp++;
5099 audio_track_bufstat(track, &m);
5100 TRACET(0, track, "end%s%s%s%s%s%s",
5110 audio_track_record(audio_track_t *track)
5118 KASSERT(track);
5119 KASSERT(track->lock);
5121 if (auring_get_contig_used(track->input) == 0) {
5122 TRACET(4, track, "input->used == 0");
5127 if (track->freq.filter) {
5128 if (track->freq.srcbuf.used > 0) {
5129 audio_apply_stage(track, &track->freq, true);
5135 if (track->chmix.filter)
5136 audio_apply_stage(track, &track->chmix, false);
5139 if (track->chvol.filter)
5140 audio_apply_stage(track, &track->chvol, false);
5143 if (track->codec.filter)
5144 audio_apply_stage(track, &track->codec, false);
5147 outbuf = &track->outbuf;
5148 usrbuf = &track->usrbuf;
5162 count = uimin(count, track->usrbuf_blksize / framesize);
5194 audio_track_bufstat(track, &m);
5195 TRACET(0, track, "end%s%s%s%s%s%s",
5539 * track track ...
5569 * Performs track mixing and converts it to hwbuf.
5598 audio_track_t *track = f->ptrack;
5600 if (track == NULL)
5603 if (track->is_pause) {
5604 TRACET(4, track, "skip; paused");
5608 /* Skip if the track is used by process context. */
5609 if (audio_track_lock_tryenter(track) == false) {
5610 TRACET(4, track, "skip; in use");
5614 /* Emulate mmap'ped track */
5615 if (track->mmapped) {
5616 auring_push(&track->usrbuf, track->usrbuf_blksize);
5617 TRACET(4, track, "mmap; usr=%d/%d/C%d",
5618 track->usrbuf.head,
5619 track->usrbuf.used,
5620 track->usrbuf.capacity);
5623 if (track->outbuf.used < mixer->frames_per_block &&
5624 track->usrbuf.used > 0) {
5625 TRACET(4, track, "process");
5626 audio_track_play(track);
5629 if (track->outbuf.used > 0) {
5630 mixed = audio_pmixer_mix_track(mixer, track, mixed);
5632 TRACET(4, track, "skip; empty");
5635 audio_track_lock_exit(track);
5770 * Mix one track.
5773 * mixed + 1 if this track is mixed.
5776 audio_pmixer_mix_track(audio_trackmixer_t *mixer, audio_track_t *track,
5787 if (mixer->mixseq < track->seq)
5790 count = auring_get_contig_used(&track->outbuf);
5793 s = auring_headptr_aint(&track->outbuf);
5797 * Apply track volume with double-sized integer and perform
5800 * XXX If you limit the track volume to 1.0 or less (<= 256),
5801 * it would be better to do this in the track conversion stage
5808 /* If this is the first track, assignment can be used. */
5810 if (track->volume != 256) {
5814 *d++ = AUDIO_SCALEDOWN(v * track->volume, 8)
5823 /* Fill silence if the first track is not filled. */
5829 if (track->volume != 256) {
5833 *d++ += AUDIO_SCALEDOWN(v * track->volume, 8);
5844 auring_take(&track->outbuf, count);
5851 auring_push(&track->outbuf, remain);
5852 auring_take(&track->outbuf, remain);
5856 * Update track sequence.
5859 track->seq = mixer->mixseq + 1;
6034 * track track ...
6041 * track track ...
6137 audio_track_t *track = f->rtrack;
6140 if (track == NULL)
6143 if (track->is_pause) {
6144 TRACET(4, track, "skip; paused");
6148 if (audio_track_lock_tryenter(track) == false) {
6149 TRACET(4, track, "skip; in use");
6154 * If the track buffer has less than one block of free space,
6157 input = track->input;
6161 track->dropframes += drops;
6162 TRACET(4, track, "drop %d frames: inp=%d/%d/%d",
6176 track->stamp++;
6178 audio_track_lock_exit(track);
6345 * Flush this track.
6350 audio_track_clear(struct audio_softc *sc, audio_track_t *track)
6353 KASSERT(track);
6354 TRACET(3, track, "clear");
6356 audio_track_lock_enter(track);
6359 track->usrbuf.used = 0;
6360 track->usrbuf.head = 0;
6361 if (track->codec.filter) {
6362 track->codec.srcbuf.used = 0;
6363 track->codec.srcbuf.head = 0;
6365 if (track->chvol.filter) {
6366 track->chvol.srcbuf.used = 0;
6367 track->chvol.srcbuf.head = 0;
6369 if (track->chmix.filter) {
6370 track->chmix.srcbuf.used = 0;
6371 track->chmix.srcbuf.head = 0;
6373 if (track->freq.filter) {
6374 track->freq.srcbuf.used = 0;
6375 track->freq.srcbuf.head = 0;
6376 if (track->freq_step < 65536)
6377 track->freq_current = 65536;
6379 track->freq_current = 0;
6380 memset(track->freq_prev, 0, sizeof(track->freq_prev));
6381 memset(track->freq_curr, 0, sizeof(track->freq_curr));
6384 track->outbuf.used = 0;
6387 track->stamp = 0;
6388 track->last_stamp = 0;
6389 track->dropframes = 0;
6391 audio_track_lock_exit(track);
6395 * Drain the track.
6396 * track must be present and for playback.
6401 audio_track_drain(struct audio_softc *sc, audio_track_t *track)
6407 KASSERT(track);
6408 TRACET(3, track, "start");
6409 mixer = track->mixer;
6413 if (track->is_pause) {
6414 TRACET(3, track, "pause -> clear");
6415 track->pstate = AUDIO_STATE_CLEAR;
6417 /* Terminate early here if there is no data in the track. */
6418 if (track->pstate == AUDIO_STATE_CLEAR) {
6419 TRACET(3, track, "no need to drain");
6422 track->pstate = AUDIO_STATE_DRAINING;
6426 TRACET(3, track, "pid=%d.%d trkseq=%d hwseq=%d out=%d/%d/%d",
6428 (int)track->seq, (int)mixer->hwseq,
6429 track->outbuf.head, track->outbuf.used,
6430 track->outbuf.capacity);
6433 audio_track_lock_enter(track);
6434 done = (track->usrbuf.used < frametobyte(&track->inputfmt, 1) &&
6435 track->outbuf.used == 0 &&
6436 track->seq <= mixer->hwseq);
6437 audio_track_lock_exit(track);
6441 TRACET(3, track, "sleep");
6442 error = audio_track_waitio(sc, track, "audio_drain");
6449 track->pstate = AUDIO_STATE_CLEAR;
6450 TRACET(3, track, "done");
6500 audio_track_t *track = f->rtrack;
6502 if (track == NULL)
6505 TRACET(4, track, "broadcast; inp=%d/%d/%d",
6506 track->input->head,
6507 track->input->used,
6508 track->input->capacity);
6548 audio_track_t *track = f->ptrack;
6550 if (track == NULL)
6553 TRACET(4, track, "broadcast; trkseq=%d out=%d/%d/%d",
6554 (int)track->seq,
6555 track->outbuf.head,
6556 track->outbuf.used,
6557 track->outbuf.capacity);
6563 if (track->usrbuf.used <= track->usrbuf_usedlow &&
6564 !track->is_pause) {
6970 * Set track mixer's format depending on ai->mode.
7134 * Ignore members within an inactive track.
7144 * track. The unit is block.
7162 * Non-zero means the track is paused.
7209 * state of this track.
7211 * regardless of this track's pause state.
7212 * 3. Even a pause of the last playback track doesn't stop pmixer.
7217 * pause state of this track.
7218 * 2. Even a pause of the last track doesn't stop rmixer.
7223 * Set both track's parameters within a file depending on ai.
7328 * track.
7358 * AUMODE_PLAY_ALL flag and track->mode in both track does
7400 * both track must be halted.
7414 DPRINTF(1, "audio track#%s play mode: %s\n",
7424 DPRINTF(1, "audio track#%s rec mode: %s\n",
7438 * Set to track and update sticky parameters.
7516 * Note that track can be NULL here.
7522 audio_track_setinfo_check(audio_track_t *track,
7554 if (track) {
7555 hwfmt = &track->mixer->hwbuf.fmt;
7561 * If track == NULL, channels should be <= 2.
7579 * Change water marks for playback track if specified.
7582 audio_track_setinfo_water(audio_track_t *track, const struct audio_info *ai)
7588 KASSERT(audio_track_is_playback(track));
7590 blksize = track->usrbuf_blksize;
7591 maxblks = track->usrbuf.capacity / blksize;
7599 track->usrbuf_usedhigh = blks * blksize;
7605 track->usrbuf_usedlow = blks * blksize;
7608 if (track->usrbuf_usedlow > track->usrbuf_usedhigh - blksize) {
7609 track->usrbuf_usedlow = track->usrbuf_usedhigh -
7805 audio_track_t *track;
7826 /* Use sticky parameters if the track is not available. */
7840 /* Use sticky parameters if the track is not available. */
7881 track = ptrack ? ptrack : rtrack;
7882 if (track) {
7883 ai->blocksize = track->usrbuf_blksize;
7884 ai->hiwat = track->usrbuf_usedhigh / track->usrbuf_blksize;
7885 ai->lowat = track->usrbuf_usedlow / track->usrbuf_blksize;
8098 /* re-init track mixer */
Indexes created Tue Oct 21 05:10:09 GMT 2025