1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 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 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 /* feeder_volume, a long 'Lost Technology' rather than a new feature. */ 30 31 #ifdef _KERNEL 32 #ifdef HAVE_KERNEL_OPTION_HEADERS 33 #include "opt_snd.h" 34 #endif 35 #include <dev/sound/pcm/sound.h> 36 #include <dev/sound/pcm/pcm.h> 37 #include "feeder_if.h" 38 39 #define SND_USE_FXDIV 40 #include "snd_fxdiv_gen.h" 41 42 SND_DECLARE_FILE("$FreeBSD$"); 43 #endif 44 45 typedef void (*feed_volume_t)(int *, int *, uint32_t, uint8_t *, uint32_t); 46 47 #define FEEDVOLUME_CALC8(s, v) (SND_VOL_CALC_SAMPLE((intpcm_t) \ 48 (s) << 8, v) >> 8) 49 #define FEEDVOLUME_CALC16(s, v) SND_VOL_CALC_SAMPLE((intpcm_t)(s), v) 50 #define FEEDVOLUME_CALC24(s, v) SND_VOL_CALC_SAMPLE((intpcm64_t)(s), v) 51 #define FEEDVOLUME_CALC32(s, v) SND_VOL_CALC_SAMPLE((intpcm64_t)(s), v) 52 53 #define FEEDVOLUME_DECLARE(SIGN, BIT, ENDIAN) \ 54 static void \ 55 feed_volume_##SIGN##BIT##ENDIAN(int *vol, int *matrix, \ 56 uint32_t channels, uint8_t *dst, uint32_t count) \ 57 { \ 58 intpcm##BIT##_t v; \ 59 intpcm_t x; \ 60 uint32_t i; \ 61 \ 62 dst += count * PCM_##BIT##_BPS * channels; \ 63 do { \ 64 i = channels; \ 65 do { \ 66 dst -= PCM_##BIT##_BPS; \ 67 i--; \ 68 x = PCM_READ_##SIGN##BIT##_##ENDIAN(dst); \ 69 v = FEEDVOLUME_CALC##BIT(x, vol[matrix[i]]); \ 70 x = PCM_CLAMP_##SIGN##BIT(v); \ 71 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x); \ 72 } while (i != 0); \ 73 } while (--count != 0); \ 74 } 75 76 #if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 77 FEEDVOLUME_DECLARE(S, 16, LE) 78 FEEDVOLUME_DECLARE(S, 32, LE) 79 #endif 80 #if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 81 FEEDVOLUME_DECLARE(S, 16, BE) 82 FEEDVOLUME_DECLARE(S, 32, BE) 83 #endif 84 #ifdef SND_FEEDER_MULTIFORMAT 85 FEEDVOLUME_DECLARE(S, 8, NE) 86 FEEDVOLUME_DECLARE(S, 24, LE) 87 FEEDVOLUME_DECLARE(S, 24, BE) 88 FEEDVOLUME_DECLARE(U, 8, NE) 89 FEEDVOLUME_DECLARE(U, 16, LE) 90 FEEDVOLUME_DECLARE(U, 24, LE) 91 FEEDVOLUME_DECLARE(U, 32, LE) 92 FEEDVOLUME_DECLARE(U, 16, BE) 93 FEEDVOLUME_DECLARE(U, 24, BE) 94 FEEDVOLUME_DECLARE(U, 32, BE) 95 #endif 96 97 struct feed_volume_info { 98 uint32_t bps, channels; 99 feed_volume_t apply; 100 int volume_class; 101 int state; 102 int matrix[SND_CHN_MAX]; 103 }; 104 105 #define FEEDVOLUME_ENTRY(SIGN, BIT, ENDIAN) \ 106 { \ 107 AFMT_##SIGN##BIT##_##ENDIAN, \ 108 feed_volume_##SIGN##BIT##ENDIAN \ 109 } 110 111 static const struct { 112 uint32_t format; 113 feed_volume_t apply; 114 } feed_volume_info_tab[] = { 115 #if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 116 FEEDVOLUME_ENTRY(S, 16, LE), 117 FEEDVOLUME_ENTRY(S, 32, LE), 118 #endif 119 #if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) 120 FEEDVOLUME_ENTRY(S, 16, BE), 121 FEEDVOLUME_ENTRY(S, 32, BE), 122 #endif 123 #ifdef SND_FEEDER_MULTIFORMAT 124 FEEDVOLUME_ENTRY(S, 8, NE), 125 FEEDVOLUME_ENTRY(S, 24, LE), 126 FEEDVOLUME_ENTRY(S, 24, BE), 127 FEEDVOLUME_ENTRY(U, 8, NE), 128 FEEDVOLUME_ENTRY(U, 16, LE), 129 FEEDVOLUME_ENTRY(U, 24, LE), 130 FEEDVOLUME_ENTRY(U, 32, LE), 131 FEEDVOLUME_ENTRY(U, 16, BE), 132 FEEDVOLUME_ENTRY(U, 24, BE), 133 FEEDVOLUME_ENTRY(U, 32, BE) 134 #endif 135 }; 136 137 #define FEEDVOLUME_TAB_SIZE ((int32_t) \ 138 (sizeof(feed_volume_info_tab) / \ 139 sizeof(feed_volume_info_tab[0]))) 140 141 static int 142 feed_volume_init(struct pcm_feeder *f) 143 { 144 struct feed_volume_info *info; 145 struct pcmchan_matrix *m; 146 uint32_t i; 147 int ret; 148 149 if (f->desc->in != f->desc->out || 150 AFMT_CHANNEL(f->desc->in) > SND_CHN_MAX) 151 return (EINVAL); 152 153 for (i = 0; i < FEEDVOLUME_TAB_SIZE; i++) { 154 if (AFMT_ENCODING(f->desc->in) == 155 feed_volume_info_tab[i].format) { 156 info = malloc(sizeof(*info), M_DEVBUF, 157 M_NOWAIT | M_ZERO); 158 if (info == NULL) 159 return (ENOMEM); 160 161 info->bps = AFMT_BPS(f->desc->in); 162 info->channels = AFMT_CHANNEL(f->desc->in); 163 info->apply = feed_volume_info_tab[i].apply; 164 info->volume_class = SND_VOL_C_PCM; 165 info->state = FEEDVOLUME_ENABLE; 166 167 f->data = info; 168 m = feeder_matrix_default_channel_map(info->channels); 169 if (m == NULL) { 170 free(info, M_DEVBUF); 171 return (EINVAL); 172 } 173 174 ret = feeder_volume_apply_matrix(f, m); 175 if (ret != 0) 176 free(info, M_DEVBUF); 177 178 return (ret); 179 } 180 } 181 182 return (EINVAL); 183 } 184 185 static int 186 feed_volume_free(struct pcm_feeder *f) 187 { 188 struct feed_volume_info *info; 189 190 info = f->data; 191 if (info != NULL) 192 free(info, M_DEVBUF); 193 194 f->data = NULL; 195 196 return (0); 197 } 198 199 static int 200 feed_volume_set(struct pcm_feeder *f, int what, int value) 201 { 202 struct feed_volume_info *info; 203 struct pcmchan_matrix *m; 204 int ret; 205 206 info = f->data; 207 ret = 0; 208 209 switch (what) { 210 case FEEDVOLUME_CLASS: 211 if (value < SND_VOL_C_BEGIN || value > SND_VOL_C_END) 212 return (EINVAL); 213 info->volume_class = value; 214 break; 215 case FEEDVOLUME_CHANNELS: 216 if (value < SND_CHN_MIN || value > SND_CHN_MAX) 217 return (EINVAL); 218 m = feeder_matrix_default_channel_map(value); 219 if (m == NULL) 220 return (EINVAL); 221 ret = feeder_volume_apply_matrix(f, m); 222 break; 223 case FEEDVOLUME_STATE: 224 if (!(value == FEEDVOLUME_ENABLE || value == FEEDVOLUME_BYPASS)) 225 return (EINVAL); 226 info->state = value; 227 break; 228 default: 229 return (EINVAL); 230 break; 231 } 232 233 return (ret); 234 } 235 236 static int 237 feed_volume_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b, 238 uint32_t count, void *source) 239 { 240 struct feed_volume_info *info; 241 uint32_t j, align; 242 int i, *vol, *matrix; 243 uint8_t *dst; 244 245 /* 246 * Fetch filter data operation. 247 */ 248 info = f->data; 249 250 if (info->state == FEEDVOLUME_BYPASS) 251 return (FEEDER_FEED(f->source, c, b, count, source)); 252 253 vol = c->volume[SND_VOL_C_VAL(info->volume_class)]; 254 matrix = info->matrix; 255 256 /* 257 * First, let see if we really need to apply gain at all. 258 */ 259 j = 0; 260 i = info->channels; 261 do { 262 if (vol[matrix[--i]] != SND_VOL_FLAT) { 263 j = 1; 264 break; 265 } 266 } while (i != 0); 267 268 /* Nope, just bypass entirely. */ 269 if (j == 0) 270 return (FEEDER_FEED(f->source, c, b, count, source)); 271 272 dst = b; 273 align = info->bps * info->channels; 274 275 do { 276 if (count < align) 277 break; 278 279 j = SND_FXDIV(FEEDER_FEED(f->source, c, dst, count, source), 280 align); 281 if (j == 0) 282 break; 283 284 info->apply(vol, matrix, info->channels, dst, j); 285 286 j *= align; 287 dst += j; 288 count -= j; 289 290 } while (count != 0); 291 292 return (dst - b); 293 } 294 295 static struct pcm_feederdesc feeder_volume_desc[] = { 296 { FEEDER_VOLUME, 0, 0, 0, 0 }, 297 { 0, 0, 0, 0, 0 } 298 }; 299 300 static kobj_method_t feeder_volume_methods[] = { 301 KOBJMETHOD(feeder_init, feed_volume_init), 302 KOBJMETHOD(feeder_free, feed_volume_free), 303 KOBJMETHOD(feeder_set, feed_volume_set), 304 KOBJMETHOD(feeder_feed, feed_volume_feed), 305 KOBJMETHOD_END 306 }; 307 308 FEEDER_DECLARE(feeder_volume, NULL); 309 310 /* Extern */ 311 312 /* 313 * feeder_volume_apply_matrix(): For given matrix map, apply its configuration 314 * to feeder_volume matrix structure. There are 315 * possibilites that feeder_volume be inserted 316 * before or after feeder_matrix, which in this 317 * case feeder_volume must be in a good terms 318 * with _current_ matrix. 319 */ 320 int 321 feeder_volume_apply_matrix(struct pcm_feeder *f, struct pcmchan_matrix *m) 322 { 323 struct feed_volume_info *info; 324 uint32_t i; 325 326 if (f == NULL || f->desc == NULL || f->desc->type != FEEDER_VOLUME || 327 f->data == NULL || m == NULL || m->channels < SND_CHN_MIN || 328 m->channels > SND_CHN_MAX) 329 return (EINVAL); 330 331 info = f->data; 332 333 for (i = 0; i < (sizeof(info->matrix) / sizeof(info->matrix[0])); i++) { 334 if (i < m->channels) 335 info->matrix[i] = m->map[i].type; 336 else 337 info->matrix[i] = SND_CHN_T_FL; 338 } 339 340 info->channels = m->channels; 341 342 return (0); 343 } 344