Page MenuHomeFreeBSD
Differential D46399

lib/libc/aarch64/string: add optimized strpbrk & strsep implementations
ClosedPublic
Actions

Authored by getz on Aug 21 2024, 4:29 PM.
Tags
None
Referenced Files
F127258101: D46399.id149057.diff
Fri, Aug 29, 5:28 PM
Unknown Object (File)
Fri, Aug 22, 3:55 PM
Unknown Object (File)
Fri, Aug 15, 12:00 AM
Unknown Object (File)
Jul 27 2025, 11:14 PM
Unknown Object (File)
Jul 27 2025, 1:52 PM
Unknown Object (File)
Jul 27 2025, 7:45 AM
Unknown Object (File)
Jul 27 2025, 3:58 AM
Unknown Object (File)
Jul 25 2025, 5:37 PM
View All 85 Files
Subscribers
imp

Details

Reviewers
fuz
emaste
andrew
Commits
rG89b3872376cb: lib/libc/aarch64/string: add optimized strpbrk & strsep implementations
Summary

These are direct copies from the amd64 string functions using the
optimized strcspn from D46398

Test Plan

No regressions noticed

Diff Detail

Repository
rG FreeBSD src repository
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

getz created this revision.Aug 21 2024, 4:29 PM
Herald added a reviewer: andrew. · View Herald TranscriptAug 21 2024, 4:29 PM
Herald added a subscriber: imp. · View Herald Transcript
getz requested review of this revision.Aug 21 2024, 4:29 PM
Harbormaster completed remote builds in B59127: Diff 142312.Aug 21 2024, 4:29 PM
getz added a parent revision: D46398: lib/libc/aarch64/string: add strcspn optimized implementation.Aug 21 2024, 4:30 PM
fuz added a comment.Aug 21 2024, 10:00 PM

Ok.

lib/libc/aarch64/string/strsep.c
36
getz updated this revision to Diff 142338.Aug 22 2024, 8:34 AM
  • amd64 -> aarch64 :)
Harbormaster completed remote builds in B59138: Diff 142338.Aug 22 2024, 8:34 AM
andrew added a comment.Sep 22 2024, 6:17 PM

Could this be machine independent?

fuz added a comment.Sep 23 2024, 9:15 AM

@andrew If we don't have an assembly implementation for strcspn, it's generally faster to implement this function directly.

fuz accepted this revision.Nov 6 2024, 2:23 PM

exp-run says it's fine.

This revision is now accepted and ready to land.Nov 6 2024, 2:23 PM
Closed by commit rG89b3872376cb: lib/libc/aarch64/string: add optimized strpbrk & strsep implementations (authored by getz, committed by fuz). · Explain WhyJan 10 2025, 3:04 PM
This revision was automatically updated to reflect the committed changes.
fuz added a commit: rG89b3872376cb: lib/libc/aarch64/string: add optimized strpbrk & strsep implementations.

Revision Contents
Changeset List

PathSize
lib/
libc/
aarch64/
string/
4 lines
43 lines
57 lines

Diff 149057

View Options

lib/libc/aarch64/string/Makefile.inc

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
#include "snd_fxdiv_gen.h" #include "snd_fxdiv_gen.h"
#endif #endif
#define FEEDMATRIX_RESERVOIR (SND_CHN_MAX * PCM_32_BPS) #define FEEDMATRIX_RESERVOIR (SND_CHN_MAX * PCM_32_BPS)
#define SND_CHN_T_EOF 0x00e0fe0f #define SND_CHN_T_EOF 0x00e0fe0f
#define SND_CHN_T_NULL 0x0e0e0e0e #define SND_CHN_T_NULL 0x0e0e0e0e
struct feed_matrix_info;
typedef void (*feed_matrix_t)(struct feed_matrix_info *, uint8_t *,
uint8_t *, uint32_t);
struct feed_matrix_info { struct feed_matrix_info {
uint32_t fmt;
uint32_t bps; uint32_t bps;
uint32_t ialign, oalign; uint32_t ialign, oalign;
uint32_t in, out; uint32_t in, out;
feed_matrix_t apply;
struct { struct {
int chn[SND_CHN_T_MAX + 1]; int chn[SND_CHN_T_MAX + 1];
int mul, shift; int mul, shift;
} matrix[SND_CHN_T_MAX + 1]; } matrix[SND_CHN_T_MAX + 1];
uint8_t reservoir[FEEDMATRIX_RESERVOIR]; uint8_t reservoir[FEEDMATRIX_RESERVOIR];
}; };
static struct pcmchan_matrix feeder_matrix_maps[SND_CHN_MATRIX_MAX] = { static struct pcmchan_matrix feeder_matrix_maps[SND_CHN_MATRIX_MAX] = {
Show All 29 Lines
#else #else
#define FEEDMATRIX_CLIP_CHECK(v, BIT) do { \ #define FEEDMATRIX_CLIP_CHECK(v, BIT) do { \
if ((v) < PCM_S##BIT##_MIN || (v) > PCM_S##BIT##_MAX) \ if ((v) < PCM_S##BIT##_MIN || (v) > PCM_S##BIT##_MAX) \
errx(1, "\n\n%s(): Sample clipping: %jd\n", \ errx(1, "\n\n%s(): Sample clipping: %jd\n", \
__func__, (intmax_t)(v)); \ __func__, (intmax_t)(v)); \
} while (0) } while (0)
#endif #endif
#define FEEDMATRIX_DECLARE(SIGN, BIT, ENDIAN) \ __always_inline static void
static void \ feed_matrix_apply(struct feed_matrix_info *info, uint8_t *src, uint8_t *dst,
feed_matrix_##SIGN##BIT##ENDIAN(struct feed_matrix_info *info, \ uint32_t count, const uint32_t fmt)
uint8_t *src, uint8_t *dst, uint32_t count) \ {
{ \ intpcm64_t accum;
intpcm64_t accum; \ intpcm_t v;
intpcm_t v; \ int i, j;
int i, j; \
\ do {
do { \ for (i = 0; info->matrix[i].chn[0] != SND_CHN_T_EOF; i++) {
for (i = 0; info->matrix[i].chn[0] != SND_CHN_T_EOF; \ if (info->matrix[i].chn[0] == SND_CHN_T_NULL) {
i++) { \ pcm_sample_write(dst, 0, fmt);
if (info->matrix[i].chn[0] == SND_CHN_T_NULL) { \ dst += info->bps;
pcm_sample_write(dst, 0, \ continue;
AFMT_##SIGN##BIT##_##ENDIAN); \ } else if (info->matrix[i].chn[1] == SND_CHN_T_EOF) {
dst += PCM_##BIT##_BPS; \ v = pcm_sample_read(src +
continue; \ info->matrix[i].chn[0], fmt);
} else if (info->matrix[i].chn[1] == \ pcm_sample_write(dst, v, fmt);
SND_CHN_T_EOF) { \ dst += info->bps;
v = pcm_sample_read( \ continue;
src + info->matrix[i].chn[0], \
AFMT_##SIGN##BIT##_##ENDIAN); \
pcm_sample_write(dst, v, \
AFMT_##SIGN##BIT##_##ENDIAN); \
dst += PCM_##BIT##_BPS; \
continue; \
} \
\
accum = 0; \
for (j = 0; \
info->matrix[i].chn[j] != SND_CHN_T_EOF; \
j++) { \
v = pcm_sample_read( \
src + info->matrix[i].chn[j], \
AFMT_##SIGN##BIT##_##ENDIAN); \
accum += v; \
} \
\
accum = (accum * info->matrix[i].mul) >> \
info->matrix[i].shift; \
\
FEEDMATRIX_CLIP_CHECK(accum, BIT); \
\
v = (accum > PCM_S##BIT##_MAX) ? \
PCM_S##BIT##_MAX : \
((accum < PCM_S##BIT##_MIN) ? \
PCM_S##BIT##_MIN : \
accum); \
pcm_sample_write(dst, v, \
AFMT_##SIGN##BIT##_##ENDIAN); \
dst += PCM_##BIT##_BPS; \
} \
src += info->ialign; \
} while (--count != 0); \
} }
#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) accum = 0;
FEEDMATRIX_DECLARE(S, 16, LE) for (j = 0; info->matrix[i].chn[j] != SND_CHN_T_EOF;
FEEDMATRIX_DECLARE(S, 32, LE) j++) {
#endif v = pcm_sample_read(src +
#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) info->matrix[i].chn[j], fmt);
FEEDMATRIX_DECLARE(S, 16, BE) accum += v;
FEEDMATRIX_DECLARE(S, 32, BE)
#endif
#ifdef SND_FEEDER_MULTIFORMAT
FEEDMATRIX_DECLARE(S, 8, NE)
FEEDMATRIX_DECLARE(S, 24, LE)
FEEDMATRIX_DECLARE(S, 24, BE)
FEEDMATRIX_DECLARE(U, 8, NE)
FEEDMATRIX_DECLARE(U, 16, LE)
FEEDMATRIX_DECLARE(U, 24, LE)
FEEDMATRIX_DECLARE(U, 32, LE)
FEEDMATRIX_DECLARE(U, 16, BE)
FEEDMATRIX_DECLARE(U, 24, BE)
FEEDMATRIX_DECLARE(U, 32, BE)
#endif
#define FEEDMATRIX_ENTRY(SIGN, BIT, ENDIAN) \
{ \
AFMT_##SIGN##BIT##_##ENDIAN, \
feed_matrix_##SIGN##BIT##ENDIAN \
} }
static const struct { accum = (accum * info->matrix[i].mul) >>
uint32_t format; info->matrix[i].shift;
feed_matrix_t apply;
} feed_matrix_tab[] = {
#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
FEEDMATRIX_ENTRY(S, 16, LE),
FEEDMATRIX_ENTRY(S, 32, LE),
#endif
#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
FEEDMATRIX_ENTRY(S, 16, BE),
FEEDMATRIX_ENTRY(S, 32, BE),
#endif
#ifdef SND_FEEDER_MULTIFORMAT
FEEDMATRIX_ENTRY(S, 8, NE),
FEEDMATRIX_ENTRY(S, 24, LE),
FEEDMATRIX_ENTRY(S, 24, BE),
FEEDMATRIX_ENTRY(U, 8, NE),
FEEDMATRIX_ENTRY(U, 16, LE),
FEEDMATRIX_ENTRY(U, 24, LE),
FEEDMATRIX_ENTRY(U, 32, LE),
FEEDMATRIX_ENTRY(U, 16, BE),
FEEDMATRIX_ENTRY(U, 24, BE),
FEEDMATRIX_ENTRY(U, 32, BE)
#endif
};
FEEDMATRIX_CLIP_CHECK(accum, AFMT_BIT(fmt));
v = pcm_clamp(accum, fmt);
pcm_sample_write(dst, v, fmt);
dst += info->bps;
}
src += info->ialign;
} while (--count != 0);
}
static void static void
feed_matrix_reset(struct feed_matrix_info *info) feed_matrix_reset(struct feed_matrix_info *info)
{ {
uint32_t i, j; uint32_t i, j;
for (i = 0; i < nitems(info->matrix); i++) { for (i = 0; i < nitems(info->matrix); i++) {
for (j = 0; for (j = 0;
j < (sizeof(info->matrix[i].chn) / j < (sizeof(info->matrix[i].chn) /
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines#endif
return (0); return (0);
} }
static int static int
feed_matrix_init(struct pcm_feeder *f) feed_matrix_init(struct pcm_feeder *f)
{ {
struct feed_matrix_info *info; struct feed_matrix_info *info;
struct pcmchan_matrix *m_in, *m_out; struct pcmchan_matrix *m_in, *m_out;
uint32_t i;
int ret; int ret;
if (AFMT_ENCODING(f->desc->in) != AFMT_ENCODING(f->desc->out)) if (AFMT_ENCODING(f->desc->in) != AFMT_ENCODING(f->desc->out))
return (EINVAL); return (EINVAL);
info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO); info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO);
if (info == NULL) if (info == NULL)
return (ENOMEM); return (ENOMEM);
info->in = f->desc->in; info->in = f->desc->in;
info->out = f->desc->out; info->out = f->desc->out;
info->fmt = AFMT_ENCODING(info->in);
info->bps = AFMT_BPS(info->in); info->bps = AFMT_BPS(info->in);
info->ialign = AFMT_ALIGN(info->in); info->ialign = AFMT_ALIGN(info->in);
info->oalign = AFMT_ALIGN(info->out); info->oalign = AFMT_ALIGN(info->out);
info->apply = NULL;
for (i = 0; info->apply == NULL &&
i < (sizeof(feed_matrix_tab) / sizeof(feed_matrix_tab[0])); i++) {
if (AFMT_ENCODING(info->in) == feed_matrix_tab[i].format)
info->apply = feed_matrix_tab[i].apply;
}
if (info->apply == NULL) {
#ifdef FEEDMATRIX_GENERIC
info->apply = feed_matrix_apply_generic;
#else
free(info, M_DEVBUF);
return (EINVAL);
#endif
}
m_in = feeder_matrix_format_map(info->in); m_in = feeder_matrix_format_map(info->in);
m_out = feeder_matrix_format_map(info->out); m_out = feeder_matrix_format_map(info->out);
ret = feed_matrix_setup(info, m_in, m_out); ret = feed_matrix_setup(info, m_in, m_out);
if (ret != 0) { if (ret != 0) {
free(info, M_DEVBUF); free(info, M_DEVBUF);
return (ret); return (ret);
} }
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines if (count < inmax) {
src = dst + count - j; src = dst + count - j;
} }
j = SND_FXDIV(FEEDER_FEED(f->source, c, src, j, source), j = SND_FXDIV(FEEDER_FEED(f->source, c, src, j, source),
info->ialign); info->ialign);
if (j == 0) if (j == 0)
break; break;
info->apply(info, src, dst, j); /* Optimize some common formats. */
switch (info->fmt) {
case AFMT_S16_NE:
feed_matrix_apply(info, src, dst, j, AFMT_S16_NE);
break;
case AFMT_S24_NE:
feed_matrix_apply(info, src, dst, j, AFMT_S24_NE);
break;
case AFMT_S32_NE:
feed_matrix_apply(info, src, dst, j, AFMT_S32_NE);
break;
default:
feed_matrix_apply(info, src, dst, j, info->fmt);
break;
}
markjUnsubmitted
Not Done
Inline Actions

Why can't this entire switch statement just be feed_matrix_apply(info, src, dst, j, info->fmt);?

markj: Why can't this entire switch statement just be `feed_matrix_apply(info, src, dst, j, info->fmt)…
christosAuthorUnsubmitted
Done
Inline Actions

There is related discussion in D48032

christos: There is related discussion in D48032
j *= info->oalign; j *= info->oalign;
dst += j; dst += j;
count -= j; count -= j;
} while (count != 0); } while (count != 0);
return (dst - b); return (dst - b);
▲ Show 20 Lines • Show All 305 Lines • Show Last 20 Lines
View Options

lib/libc/aarch64/string/strpbrk.c

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
#include "snd_fxdiv_gen.h" #include "snd_fxdiv_gen.h"
#endif #endif
#define FEEDMATRIX_RESERVOIR (SND_CHN_MAX * PCM_32_BPS) #define FEEDMATRIX_RESERVOIR (SND_CHN_MAX * PCM_32_BPS)
#define SND_CHN_T_EOF 0x00e0fe0f #define SND_CHN_T_EOF 0x00e0fe0f
#define SND_CHN_T_NULL 0x0e0e0e0e #define SND_CHN_T_NULL 0x0e0e0e0e
struct feed_matrix_info;
typedef void (*feed_matrix_t)(struct feed_matrix_info *, uint8_t *,
uint8_t *, uint32_t);
struct feed_matrix_info { struct feed_matrix_info {
uint32_t fmt;
uint32_t bps; uint32_t bps;
uint32_t ialign, oalign; uint32_t ialign, oalign;
uint32_t in, out; uint32_t in, out;
feed_matrix_t apply;
struct { struct {
int chn[SND_CHN_T_MAX + 1]; int chn[SND_CHN_T_MAX + 1];
int mul, shift; int mul, shift;
} matrix[SND_CHN_T_MAX + 1]; } matrix[SND_CHN_T_MAX + 1];
uint8_t reservoir[FEEDMATRIX_RESERVOIR]; uint8_t reservoir[FEEDMATRIX_RESERVOIR];
}; };
static struct pcmchan_matrix feeder_matrix_maps[SND_CHN_MATRIX_MAX] = { static struct pcmchan_matrix feeder_matrix_maps[SND_CHN_MATRIX_MAX] = {
Show All 29 Lines
#else #else
#define FEEDMATRIX_CLIP_CHECK(v, BIT) do { \ #define FEEDMATRIX_CLIP_CHECK(v, BIT) do { \
if ((v) < PCM_S##BIT##_MIN || (v) > PCM_S##BIT##_MAX) \ if ((v) < PCM_S##BIT##_MIN || (v) > PCM_S##BIT##_MAX) \
errx(1, "\n\n%s(): Sample clipping: %jd\n", \ errx(1, "\n\n%s(): Sample clipping: %jd\n", \
__func__, (intmax_t)(v)); \ __func__, (intmax_t)(v)); \
} while (0) } while (0)
#endif #endif
#define FEEDMATRIX_DECLARE(SIGN, BIT, ENDIAN) \ __always_inline static void
static void \ feed_matrix_apply(struct feed_matrix_info *info, uint8_t *src, uint8_t *dst,
feed_matrix_##SIGN##BIT##ENDIAN(struct feed_matrix_info *info, \ uint32_t count, const uint32_t fmt)
uint8_t *src, uint8_t *dst, uint32_t count) \ {
{ \ intpcm64_t accum;
intpcm64_t accum; \ intpcm_t v;
intpcm_t v; \ int i, j;
int i, j; \
\ do {
do { \ for (i = 0; info->matrix[i].chn[0] != SND_CHN_T_EOF; i++) {
for (i = 0; info->matrix[i].chn[0] != SND_CHN_T_EOF; \ if (info->matrix[i].chn[0] == SND_CHN_T_NULL) {
i++) { \ pcm_sample_write(dst, 0, fmt);
if (info->matrix[i].chn[0] == SND_CHN_T_NULL) { \ dst += info->bps;
pcm_sample_write(dst, 0, \ continue;
AFMT_##SIGN##BIT##_##ENDIAN); \ } else if (info->matrix[i].chn[1] == SND_CHN_T_EOF) {
dst += PCM_##BIT##_BPS; \ v = pcm_sample_read(src +
continue; \ info->matrix[i].chn[0], fmt);
} else if (info->matrix[i].chn[1] == \ pcm_sample_write(dst, v, fmt);
SND_CHN_T_EOF) { \ dst += info->bps;
v = pcm_sample_read( \ continue;
src + info->matrix[i].chn[0], \
AFMT_##SIGN##BIT##_##ENDIAN); \
pcm_sample_write(dst, v, \
AFMT_##SIGN##BIT##_##ENDIAN); \
dst += PCM_##BIT##_BPS; \
continue; \
} \
\
accum = 0; \
for (j = 0; \
info->matrix[i].chn[j] != SND_CHN_T_EOF; \
j++) { \
v = pcm_sample_read( \
src + info->matrix[i].chn[j], \
AFMT_##SIGN##BIT##_##ENDIAN); \
accum += v; \
} \
\
accum = (accum * info->matrix[i].mul) >> \
info->matrix[i].shift; \
\
FEEDMATRIX_CLIP_CHECK(accum, BIT); \
\
v = (accum > PCM_S##BIT##_MAX) ? \
PCM_S##BIT##_MAX : \
((accum < PCM_S##BIT##_MIN) ? \
PCM_S##BIT##_MIN : \
accum); \
pcm_sample_write(dst, v, \
AFMT_##SIGN##BIT##_##ENDIAN); \
dst += PCM_##BIT##_BPS; \
} \
src += info->ialign; \
} while (--count != 0); \
} }
#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) accum = 0;
FEEDMATRIX_DECLARE(S, 16, LE) for (j = 0; info->matrix[i].chn[j] != SND_CHN_T_EOF;
FEEDMATRIX_DECLARE(S, 32, LE) j++) {
#endif v = pcm_sample_read(src +
#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) info->matrix[i].chn[j], fmt);
FEEDMATRIX_DECLARE(S, 16, BE) accum += v;
FEEDMATRIX_DECLARE(S, 32, BE)
#endif
#ifdef SND_FEEDER_MULTIFORMAT
FEEDMATRIX_DECLARE(S, 8, NE)
FEEDMATRIX_DECLARE(S, 24, LE)
FEEDMATRIX_DECLARE(S, 24, BE)
FEEDMATRIX_DECLARE(U, 8, NE)
FEEDMATRIX_DECLARE(U, 16, LE)
FEEDMATRIX_DECLARE(U, 24, LE)
FEEDMATRIX_DECLARE(U, 32, LE)
FEEDMATRIX_DECLARE(U, 16, BE)
FEEDMATRIX_DECLARE(U, 24, BE)
FEEDMATRIX_DECLARE(U, 32, BE)
#endif
#define FEEDMATRIX_ENTRY(SIGN, BIT, ENDIAN) \
{ \
AFMT_##SIGN##BIT##_##ENDIAN, \
feed_matrix_##SIGN##BIT##ENDIAN \
} }
static const struct { accum = (accum * info->matrix[i].mul) >>
uint32_t format; info->matrix[i].shift;
feed_matrix_t apply;
} feed_matrix_tab[] = {
#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
FEEDMATRIX_ENTRY(S, 16, LE),
FEEDMATRIX_ENTRY(S, 32, LE),
#endif
#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
FEEDMATRIX_ENTRY(S, 16, BE),
FEEDMATRIX_ENTRY(S, 32, BE),
#endif
#ifdef SND_FEEDER_MULTIFORMAT
FEEDMATRIX_ENTRY(S, 8, NE),
FEEDMATRIX_ENTRY(S, 24, LE),
FEEDMATRIX_ENTRY(S, 24, BE),
FEEDMATRIX_ENTRY(U, 8, NE),
FEEDMATRIX_ENTRY(U, 16, LE),
FEEDMATRIX_ENTRY(U, 24, LE),
FEEDMATRIX_ENTRY(U, 32, LE),
FEEDMATRIX_ENTRY(U, 16, BE),
FEEDMATRIX_ENTRY(U, 24, BE),
FEEDMATRIX_ENTRY(U, 32, BE)
#endif
};
FEEDMATRIX_CLIP_CHECK(accum, AFMT_BIT(fmt));
v = pcm_clamp(accum, fmt);
pcm_sample_write(dst, v, fmt);
dst += info->bps;
}
src += info->ialign;
} while (--count != 0);
}
static void static void
feed_matrix_reset(struct feed_matrix_info *info) feed_matrix_reset(struct feed_matrix_info *info)
{ {
uint32_t i, j; uint32_t i, j;
for (i = 0; i < nitems(info->matrix); i++) { for (i = 0; i < nitems(info->matrix); i++) {
for (j = 0; for (j = 0;
j < (sizeof(info->matrix[i].chn) / j < (sizeof(info->matrix[i].chn) /
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines#endif
return (0); return (0);
} }
static int static int
feed_matrix_init(struct pcm_feeder *f) feed_matrix_init(struct pcm_feeder *f)
{ {
struct feed_matrix_info *info; struct feed_matrix_info *info;
struct pcmchan_matrix *m_in, *m_out; struct pcmchan_matrix *m_in, *m_out;
uint32_t i;
int ret; int ret;
if (AFMT_ENCODING(f->desc->in) != AFMT_ENCODING(f->desc->out)) if (AFMT_ENCODING(f->desc->in) != AFMT_ENCODING(f->desc->out))
return (EINVAL); return (EINVAL);
info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO); info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO);
if (info == NULL) if (info == NULL)
return (ENOMEM); return (ENOMEM);
info->in = f->desc->in; info->in = f->desc->in;
info->out = f->desc->out; info->out = f->desc->out;
info->fmt = AFMT_ENCODING(info->in);
info->bps = AFMT_BPS(info->in); info->bps = AFMT_BPS(info->in);
info->ialign = AFMT_ALIGN(info->in); info->ialign = AFMT_ALIGN(info->in);
info->oalign = AFMT_ALIGN(info->out); info->oalign = AFMT_ALIGN(info->out);
info->apply = NULL;
for (i = 0; info->apply == NULL &&
i < (sizeof(feed_matrix_tab) / sizeof(feed_matrix_tab[0])); i++) {
if (AFMT_ENCODING(info->in) == feed_matrix_tab[i].format)
info->apply = feed_matrix_tab[i].apply;
}
if (info->apply == NULL) {
#ifdef FEEDMATRIX_GENERIC
info->apply = feed_matrix_apply_generic;
#else
free(info, M_DEVBUF);
return (EINVAL);
#endif
}
m_in = feeder_matrix_format_map(info->in); m_in = feeder_matrix_format_map(info->in);
m_out = feeder_matrix_format_map(info->out); m_out = feeder_matrix_format_map(info->out);
ret = feed_matrix_setup(info, m_in, m_out); ret = feed_matrix_setup(info, m_in, m_out);
if (ret != 0) { if (ret != 0) {
free(info, M_DEVBUF); free(info, M_DEVBUF);
return (ret); return (ret);
} }
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines if (count < inmax) {
src = dst + count - j; src = dst + count - j;
} }
j = SND_FXDIV(FEEDER_FEED(f->source, c, src, j, source), j = SND_FXDIV(FEEDER_FEED(f->source, c, src, j, source),
info->ialign); info->ialign);
if (j == 0) if (j == 0)
break; break;
info->apply(info, src, dst, j); /* Optimize some common formats. */
switch (info->fmt) {
case AFMT_S16_NE:
feed_matrix_apply(info, src, dst, j, AFMT_S16_NE);
break;
case AFMT_S24_NE:
feed_matrix_apply(info, src, dst, j, AFMT_S24_NE);
break;
case AFMT_S32_NE:
feed_matrix_apply(info, src, dst, j, AFMT_S32_NE);
break;
default:
feed_matrix_apply(info, src, dst, j, info->fmt);
break;
}
markjUnsubmitted
Not Done
Inline Actions

Why can't this entire switch statement just be feed_matrix_apply(info, src, dst, j, info->fmt);?

markj: Why can't this entire switch statement just be `feed_matrix_apply(info, src, dst, j, info->fmt)…
christosAuthorUnsubmitted
Done
Inline Actions

There is related discussion in D48032

christos: There is related discussion in D48032
j *= info->oalign; j *= info->oalign;
dst += j; dst += j;
count -= j; count -= j;
} while (count != 0); } while (count != 0);
return (dst - b); return (dst - b);
▲ Show 20 Lines • Show All 305 Lines • Show Last 20 Lines
View Options

lib/libc/aarch64/string/strsep.c

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
#include "snd_fxdiv_gen.h" #include "snd_fxdiv_gen.h"
#endif #endif
#define FEEDMATRIX_RESERVOIR (SND_CHN_MAX * PCM_32_BPS) #define FEEDMATRIX_RESERVOIR (SND_CHN_MAX * PCM_32_BPS)
#define SND_CHN_T_EOF 0x00e0fe0f #define SND_CHN_T_EOF 0x00e0fe0f
#define SND_CHN_T_NULL 0x0e0e0e0e #define SND_CHN_T_NULL 0x0e0e0e0e
struct feed_matrix_info;
typedef void (*feed_matrix_t)(struct feed_matrix_info *, uint8_t *,
uint8_t *, uint32_t);
struct feed_matrix_info { struct feed_matrix_info {
uint32_t fmt;
uint32_t bps; uint32_t bps;
uint32_t ialign, oalign; uint32_t ialign, oalign;
uint32_t in, out; uint32_t in, out;
feed_matrix_t apply;
struct { struct {
int chn[SND_CHN_T_MAX + 1]; int chn[SND_CHN_T_MAX + 1];
int mul, shift; int mul, shift;
} matrix[SND_CHN_T_MAX + 1]; } matrix[SND_CHN_T_MAX + 1];
uint8_t reservoir[FEEDMATRIX_RESERVOIR]; uint8_t reservoir[FEEDMATRIX_RESERVOIR];
}; };
static struct pcmchan_matrix feeder_matrix_maps[SND_CHN_MATRIX_MAX] = { static struct pcmchan_matrix feeder_matrix_maps[SND_CHN_MATRIX_MAX] = {
Show All 29 Lines
#else #else
#define FEEDMATRIX_CLIP_CHECK(v, BIT) do { \ #define FEEDMATRIX_CLIP_CHECK(v, BIT) do { \
if ((v) < PCM_S##BIT##_MIN || (v) > PCM_S##BIT##_MAX) \ if ((v) < PCM_S##BIT##_MIN || (v) > PCM_S##BIT##_MAX) \
errx(1, "\n\n%s(): Sample clipping: %jd\n", \ errx(1, "\n\n%s(): Sample clipping: %jd\n", \
__func__, (intmax_t)(v)); \ __func__, (intmax_t)(v)); \
} while (0) } while (0)
#endif #endif
#define FEEDMATRIX_DECLARE(SIGN, BIT, ENDIAN) \ __always_inline static void
static void \ feed_matrix_apply(struct feed_matrix_info *info, uint8_t *src, uint8_t *dst,
feed_matrix_##SIGN##BIT##ENDIAN(struct feed_matrix_info *info, \ uint32_t count, const uint32_t fmt)
uint8_t *src, uint8_t *dst, uint32_t count) \ {
{ \ intpcm64_t accum;
intpcm64_t accum; \ intpcm_t v;
intpcm_t v; \ int i, j;
int i, j; \
\ do {
do { \ for (i = 0; info->matrix[i].chn[0] != SND_CHN_T_EOF; i++) {
for (i = 0; info->matrix[i].chn[0] != SND_CHN_T_EOF; \ if (info->matrix[i].chn[0] == SND_CHN_T_NULL) {
i++) { \ pcm_sample_write(dst, 0, fmt);
if (info->matrix[i].chn[0] == SND_CHN_T_NULL) { \ dst += info->bps;
pcm_sample_write(dst, 0, \ continue;
AFMT_##SIGN##BIT##_##ENDIAN); \ } else if (info->matrix[i].chn[1] == SND_CHN_T_EOF) {
dst += PCM_##BIT##_BPS; \ v = pcm_sample_read(src +
continue; \ info->matrix[i].chn[0], fmt);
} else if (info->matrix[i].chn[1] == \ pcm_sample_write(dst, v, fmt);
SND_CHN_T_EOF) { \ dst += info->bps;
v = pcm_sample_read( \ continue;
src + info->matrix[i].chn[0], \
AFMT_##SIGN##BIT##_##ENDIAN); \
pcm_sample_write(dst, v, \
AFMT_##SIGN##BIT##_##ENDIAN); \
dst += PCM_##BIT##_BPS; \
continue; \
} \
\
accum = 0; \
for (j = 0; \
info->matrix[i].chn[j] != SND_CHN_T_EOF; \
j++) { \
v = pcm_sample_read( \
src + info->matrix[i].chn[j], \
AFMT_##SIGN##BIT##_##ENDIAN); \
accum += v; \
} \
\
accum = (accum * info->matrix[i].mul) >> \
info->matrix[i].shift; \
\
FEEDMATRIX_CLIP_CHECK(accum, BIT); \
\
v = (accum > PCM_S##BIT##_MAX) ? \
PCM_S##BIT##_MAX : \
((accum < PCM_S##BIT##_MIN) ? \
PCM_S##BIT##_MIN : \
accum); \
pcm_sample_write(dst, v, \
AFMT_##SIGN##BIT##_##ENDIAN); \
dst += PCM_##BIT##_BPS; \
} \
src += info->ialign; \
} while (--count != 0); \
} }
#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) accum = 0;
FEEDMATRIX_DECLARE(S, 16, LE) for (j = 0; info->matrix[i].chn[j] != SND_CHN_T_EOF;
FEEDMATRIX_DECLARE(S, 32, LE) j++) {
#endif v = pcm_sample_read(src +
#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT) info->matrix[i].chn[j], fmt);
FEEDMATRIX_DECLARE(S, 16, BE) accum += v;
FEEDMATRIX_DECLARE(S, 32, BE)
#endif
#ifdef SND_FEEDER_MULTIFORMAT
FEEDMATRIX_DECLARE(S, 8, NE)
FEEDMATRIX_DECLARE(S, 24, LE)
FEEDMATRIX_DECLARE(S, 24, BE)
FEEDMATRIX_DECLARE(U, 8, NE)
FEEDMATRIX_DECLARE(U, 16, LE)
FEEDMATRIX_DECLARE(U, 24, LE)
FEEDMATRIX_DECLARE(U, 32, LE)
FEEDMATRIX_DECLARE(U, 16, BE)
FEEDMATRIX_DECLARE(U, 24, BE)
FEEDMATRIX_DECLARE(U, 32, BE)
#endif
#define FEEDMATRIX_ENTRY(SIGN, BIT, ENDIAN) \
{ \
AFMT_##SIGN##BIT##_##ENDIAN, \
feed_matrix_##SIGN##BIT##ENDIAN \
} }
static const struct { accum = (accum * info->matrix[i].mul) >>
uint32_t format; info->matrix[i].shift;
feed_matrix_t apply;
} feed_matrix_tab[] = {
#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
FEEDMATRIX_ENTRY(S, 16, LE),
FEEDMATRIX_ENTRY(S, 32, LE),
#endif
#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
FEEDMATRIX_ENTRY(S, 16, BE),
FEEDMATRIX_ENTRY(S, 32, BE),
#endif
#ifdef SND_FEEDER_MULTIFORMAT
FEEDMATRIX_ENTRY(S, 8, NE),
FEEDMATRIX_ENTRY(S, 24, LE),
FEEDMATRIX_ENTRY(S, 24, BE),
FEEDMATRIX_ENTRY(U, 8, NE),
FEEDMATRIX_ENTRY(U, 16, LE),
FEEDMATRIX_ENTRY(U, 24, LE),
FEEDMATRIX_ENTRY(U, 32, LE),
FEEDMATRIX_ENTRY(U, 16, BE),
FEEDMATRIX_ENTRY(U, 24, BE),
FEEDMATRIX_ENTRY(U, 32, BE)
#endif
};
FEEDMATRIX_CLIP_CHECK(accum, AFMT_BIT(fmt));
v = pcm_clamp(accum, fmt);
pcm_sample_write(dst, v, fmt);
dst += info->bps;
}
src += info->ialign;
} while (--count != 0);
}
static void static void
feed_matrix_reset(struct feed_matrix_info *info) feed_matrix_reset(struct feed_matrix_info *info)
{ {
uint32_t i, j; uint32_t i, j;
for (i = 0; i < nitems(info->matrix); i++) { for (i = 0; i < nitems(info->matrix); i++) {
for (j = 0; for (j = 0;
j < (sizeof(info->matrix[i].chn) / j < (sizeof(info->matrix[i].chn) /
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines#endif
return (0); return (0);
} }
static int static int
feed_matrix_init(struct pcm_feeder *f) feed_matrix_init(struct pcm_feeder *f)
{ {
struct feed_matrix_info *info; struct feed_matrix_info *info;
struct pcmchan_matrix *m_in, *m_out; struct pcmchan_matrix *m_in, *m_out;
uint32_t i;
int ret; int ret;
if (AFMT_ENCODING(f->desc->in) != AFMT_ENCODING(f->desc->out)) if (AFMT_ENCODING(f->desc->in) != AFMT_ENCODING(f->desc->out))
return (EINVAL); return (EINVAL);
info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO); info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO);
if (info == NULL) if (info == NULL)
return (ENOMEM); return (ENOMEM);
info->in = f->desc->in; info->in = f->desc->in;
info->out = f->desc->out; info->out = f->desc->out;
info->fmt = AFMT_ENCODING(info->in);
info->bps = AFMT_BPS(info->in); info->bps = AFMT_BPS(info->in);
info->ialign = AFMT_ALIGN(info->in); info->ialign = AFMT_ALIGN(info->in);
info->oalign = AFMT_ALIGN(info->out); info->oalign = AFMT_ALIGN(info->out);
info->apply = NULL;
for (i = 0; info->apply == NULL &&
i < (sizeof(feed_matrix_tab) / sizeof(feed_matrix_tab[0])); i++) {
if (AFMT_ENCODING(info->in) == feed_matrix_tab[i].format)
info->apply = feed_matrix_tab[i].apply;
}
if (info->apply == NULL) {
#ifdef FEEDMATRIX_GENERIC
info->apply = feed_matrix_apply_generic;
#else
free(info, M_DEVBUF);
return (EINVAL);
#endif
}
m_in = feeder_matrix_format_map(info->in); m_in = feeder_matrix_format_map(info->in);
m_out = feeder_matrix_format_map(info->out); m_out = feeder_matrix_format_map(info->out);
ret = feed_matrix_setup(info, m_in, m_out); ret = feed_matrix_setup(info, m_in, m_out);
if (ret != 0) { if (ret != 0) {
free(info, M_DEVBUF); free(info, M_DEVBUF);
return (ret); return (ret);
} }
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines if (count < inmax) {
src = dst + count - j; src = dst + count - j;
} }
j = SND_FXDIV(FEEDER_FEED(f->source, c, src, j, source), j = SND_FXDIV(FEEDER_FEED(f->source, c, src, j, source),
info->ialign); info->ialign);
if (j == 0) if (j == 0)
break; break;
info->apply(info, src, dst, j); /* Optimize some common formats. */
switch (info->fmt) {
case AFMT_S16_NE:
feed_matrix_apply(info, src, dst, j, AFMT_S16_NE);
break;
case AFMT_S24_NE:
feed_matrix_apply(info, src, dst, j, AFMT_S24_NE);
break;
case AFMT_S32_NE:
feed_matrix_apply(info, src, dst, j, AFMT_S32_NE);
break;
default:
feed_matrix_apply(info, src, dst, j, info->fmt);
break;
}
markjUnsubmitted
Not Done
Inline Actions

Why can't this entire switch statement just be feed_matrix_apply(info, src, dst, j, info->fmt);?

markj: Why can't this entire switch statement just be `feed_matrix_apply(info, src, dst, j, info->fmt)…
christosAuthorUnsubmitted
Done
Inline Actions

There is related discussion in D48032

christos: There is related discussion in D48032
j *= info->oalign; j *= info->oalign;
dst += j; dst += j;
count -= j; count -= j;
} while (count != 0); } while (count != 0);
return (dst - b); return (dst - b);
▲ Show 20 Lines • Show All 305 Lines • Show Last 20 Lines