asgardius/alsa-utils
1
0
Fork 0
mirror of https://github.com/alsa-project/alsa-utils synced 2024-11-10 00:25:43 +01:00
Code Issues Projects Releases Packages Wiki Activity
alsa-utils/axfer/test/container-test.c
Khem Raj 4e3843d0ed aplay,axfer: Replace off64_t with off_t 
Also replace lseek64 with lseek.

_FILE_OFFSET_BITS=64 is passed to needed platforms since configure uses
AC_SYS_LARGEFILE macro. Therefore off_t is already 64-bit and lseek is
same as lseek64.

Additionally this fixes buils with latest musl where these lfs64
functions are moved out from _GNU_SOURCE and under _LARGEFILE64_SOURCE
macro alone. This makes the builds fail on 32-bit platforms even though
default off_t on musl is 64-bit always.

Fixes: https://github.com/alsa-project/alsa-utils/pull/183
Reviewed-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Khem Raj <raj.khem@gmail.com>
Signed-off-by: Jaroslav Kysela <perex@perex.cz>
2023-01-23 19:04:07 +01:00

324 lines
8.5 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0
//
// container-io.c - a unit test for parser/builder of supported containers.
//
// Copyright (c) 2018 Takashi Sakamoto <o-takashi@sakamocchi.jp>
//
// Licensed under the terms of the GNU General Public License, version 2.
#include <aconfig.h>
#ifdef HAVE_MEMFD_CREATE
#define _GNU_SOURCE
#endif
#include "../container.h"
#include "../misc.h"
#include "generator.h"
#ifdef HAVE_MEMFD_CREATE
#include <sys/mman.h>
#endif
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#include <assert.h>
struct container_trial {
enum container_format format;
struct container_context cntr;
bool verbose;
};
static void test_builder(struct container_context *cntr, int fd,
enum container_format format,
snd_pcm_access_t access,
snd_pcm_format_t sample_format,
unsigned int samples_per_frame,
unsigned int frames_per_second,
void *frame_buffer, unsigned int frame_count,
bool verbose)
{
snd_pcm_format_t sample;
unsigned int channels;
unsigned int rate;
uint64_t max_frame_count;
unsigned int handled_frame_count;
uint64_t total_frame_count;
int err;
err = container_builder_init(cntr, fd, format, verbose);
assert(err == 0);
sample = sample_format;
channels = samples_per_frame;
rate = frames_per_second;
max_frame_count = 0;
err = container_context_pre_process(cntr, &sample, &channels, &rate,
&max_frame_count);
assert(err == 0);
assert(sample == sample_format);
assert(channels == samples_per_frame);
assert(rate == frames_per_second);
assert(max_frame_count > 0);
handled_frame_count = frame_count;
err = container_context_process_frames(cntr, frame_buffer,
&handled_frame_count);
assert(err == 0);
assert(handled_frame_count > 0);
assert(handled_frame_count <= frame_count);
total_frame_count = 0;
err = container_context_post_process(cntr, &total_frame_count);
assert(err == 0);
assert(total_frame_count == frame_count);
container_context_destroy(cntr);
}
static void test_parser(struct container_context *cntr, int fd,
enum container_format format,
snd_pcm_access_t access, snd_pcm_format_t sample_format,
unsigned int samples_per_frame,
unsigned int frames_per_second,
void *frame_buffer, unsigned int frame_count,
bool verbose)
{
snd_pcm_format_t sample;
unsigned int channels;
unsigned int rate;
uint64_t total_frame_count;
unsigned int handled_frame_count;
int err;
err = container_parser_init(cntr, fd, verbose);
assert(err == 0);
sample = sample_format;
channels = samples_per_frame;
rate = frames_per_second;
total_frame_count = 0;
err = container_context_pre_process(cntr, &sample, &channels, &rate,
&total_frame_count);
assert(err == 0);
assert(sample == sample_format);
assert(channels == samples_per_frame);
assert(rate == frames_per_second);
assert(total_frame_count == frame_count);
handled_frame_count = total_frame_count;
err = container_context_process_frames(cntr, frame_buffer,
&handled_frame_count);
assert(err == 0);
assert(handled_frame_count == frame_count);
total_frame_count = 0;
err = container_context_post_process(cntr, &total_frame_count);
assert(err == 0);
assert(total_frame_count == handled_frame_count);
container_context_destroy(cntr);
}
static int callback(struct test_generator *gen, snd_pcm_access_t access,
snd_pcm_format_t sample_format,
unsigned int samples_per_frame, void *frame_buffer,
unsigned int frame_count)
{
static const unsigned int entries[] = {
[0] = 44100,
[1] = 48000,
[2] = 88200,
[3] = 96000,
[4] = 176400,
[5] = 192000,
};
struct container_trial *trial = gen->private_data;
unsigned int frames_per_second;
const char *const name = "hoge";
unsigned int size;
void *buf;
int i;
int err = 0;
size = frame_count * samples_per_frame *
snd_pcm_format_physical_width(sample_format) / 8;
buf = malloc(size);
if (buf == NULL)
return -ENOMEM;
for (i = 0; i < ARRAY_SIZE(entries); ++i) {
int fd;
off_t pos;
frames_per_second = entries[i];
#ifdef HAVE_MEMFD_CREATE
fd = memfd_create(name, 0);
#else
fd = open(name, O_RDWR | O_CREAT | O_TRUNC, 0644);
#endif
if (fd < 0) {
err = -errno;
break;
}
test_builder(&trial->cntr, fd, trial->format, access,
sample_format, samples_per_frame,
frames_per_second, frame_buffer, frame_count,
trial->verbose);
pos = lseek(fd, 0, SEEK_SET);
if (pos < 0) {
err = -errno;
break;
}
test_parser(&trial->cntr, fd, trial->format, access,
sample_format, samples_per_frame, frames_per_second,
buf, frame_count, trial->verbose);
err = memcmp(buf, frame_buffer, size);
assert(err == 0);
close(fd);
}
free(buf);
return err;
}
int main(int argc, const char *argv[])
{
static const uint64_t sample_format_masks[] = {
[CONTAINER_FORMAT_RIFF_WAVE] =
(1ull << SND_PCM_FORMAT_U8) |
(1ull << SND_PCM_FORMAT_S16_LE) |
(1ull << SND_PCM_FORMAT_S16_BE) |
(1ull << SND_PCM_FORMAT_S24_LE) |
(1ull << SND_PCM_FORMAT_S24_BE) |
(1ull << SND_PCM_FORMAT_S32_LE) |
(1ull << SND_PCM_FORMAT_S32_BE) |
(1ull << SND_PCM_FORMAT_FLOAT_LE) |
(1ull << SND_PCM_FORMAT_FLOAT_BE) |
(1ull << SND_PCM_FORMAT_FLOAT64_LE) |
(1ull << SND_PCM_FORMAT_FLOAT64_BE) |
(1ull << SND_PCM_FORMAT_MU_LAW) |
(1ull << SND_PCM_FORMAT_A_LAW) |
(1ull << SND_PCM_FORMAT_S24_3LE) |
(1ull << SND_PCM_FORMAT_S24_3BE) |
(1ull << SND_PCM_FORMAT_S20_3LE) |
(1ull << SND_PCM_FORMAT_S20_3BE) |
(1ull << SND_PCM_FORMAT_S18_3LE) |
(1ull << SND_PCM_FORMAT_S18_3BE),
[CONTAINER_FORMAT_AU] =
(1ull << SND_PCM_FORMAT_S8) |
(1ull << SND_PCM_FORMAT_S16_BE) |
(1ull << SND_PCM_FORMAT_S32_BE) |
(1ull << SND_PCM_FORMAT_FLOAT_BE) |
(1ull << SND_PCM_FORMAT_FLOAT64_BE) |
(1ull << SND_PCM_FORMAT_MU_LAW) |
(1ull << SND_PCM_FORMAT_A_LAW),
[CONTAINER_FORMAT_VOC] =
(1ull << SND_PCM_FORMAT_U8) |
(1ull << SND_PCM_FORMAT_S16_LE) |
(1ull << SND_PCM_FORMAT_MU_LAW) |
(1ull << SND_PCM_FORMAT_A_LAW),
[CONTAINER_FORMAT_RAW] =
(1ull << SND_PCM_FORMAT_S8) |
(1ull << SND_PCM_FORMAT_U8) |
(1ull << SND_PCM_FORMAT_S16_LE) |
(1ull << SND_PCM_FORMAT_S16_BE) |
(1ull << SND_PCM_FORMAT_U16_LE) |
(1ull << SND_PCM_FORMAT_U16_BE) |
(1ull << SND_PCM_FORMAT_S24_LE) |
(1ull << SND_PCM_FORMAT_S24_BE) |
(1ull << SND_PCM_FORMAT_U24_LE) |
(1ull << SND_PCM_FORMAT_U24_BE) |
(1ull << SND_PCM_FORMAT_S32_LE) |
(1ull << SND_PCM_FORMAT_S32_BE) |
(1ull << SND_PCM_FORMAT_U32_LE) |
(1ull << SND_PCM_FORMAT_U32_BE) |
(1ull << SND_PCM_FORMAT_FLOAT_LE) |
(1ull << SND_PCM_FORMAT_FLOAT_BE) |
(1ull << SND_PCM_FORMAT_FLOAT64_LE) |
(1ull << SND_PCM_FORMAT_FLOAT64_BE) |
(1ull << SND_PCM_FORMAT_IEC958_SUBFRAME_LE) |
(1ull << SND_PCM_FORMAT_IEC958_SUBFRAME_BE) |
(1ull << SND_PCM_FORMAT_MU_LAW) |
(1ull << SND_PCM_FORMAT_A_LAW) |
(1ull << SND_PCM_FORMAT_S24_3LE) |
(1ull << SND_PCM_FORMAT_S24_3BE) |
(1ull << SND_PCM_FORMAT_U24_3LE) |
(1ull << SND_PCM_FORMAT_U24_3BE) |
(1ull << SND_PCM_FORMAT_S20_3LE) |
(1ull << SND_PCM_FORMAT_S20_3BE) |
(1ull << SND_PCM_FORMAT_U20_3LE) |
(1ull << SND_PCM_FORMAT_U20_3BE) |
(1ull << SND_PCM_FORMAT_S18_3LE) |
(1ull << SND_PCM_FORMAT_S18_3BE) |
(1ull << SND_PCM_FORMAT_U18_3LE) |
(1ull << SND_PCM_FORMAT_U18_3BE) |
(1ull << SND_PCM_FORMAT_DSD_U8) |
(1ull << SND_PCM_FORMAT_DSD_U16_LE) |
(1ull << SND_PCM_FORMAT_DSD_U32_LE) |
(1ull << SND_PCM_FORMAT_DSD_U16_BE) |
(1ull << SND_PCM_FORMAT_DSD_U32_BE),
};
static const uint64_t access_mask =
(1ull << SND_PCM_ACCESS_MMAP_INTERLEAVED) |
(1ull << SND_PCM_ACCESS_RW_INTERLEAVED);
struct test_generator gen = {0};
struct container_trial *trial;
int i;
int begin;
int end;
bool verbose;
int err;
if (argc > 1) {
char *term;
begin = strtol(argv[1], &term, 10);
if (errno || *term != '\0')
return EXIT_FAILURE;
if (begin < CONTAINER_FORMAT_RIFF_WAVE &&
begin > CONTAINER_FORMAT_RAW)
return -EXIT_FAILURE;
end = begin + 1;
verbose = true;
} else {
begin = CONTAINER_FORMAT_RIFF_WAVE;
end = CONTAINER_FORMAT_RAW + 1;
verbose = false;
}
for (i = begin; i < end; ++i) {
err = generator_context_init(&gen, access_mask,
sample_format_masks[i],
1, 32, 23, 3000, 512,
sizeof(struct container_trial));
if (err >= 0) {
trial = gen.private_data;
trial->format = i;
trial->verbose = verbose;
err = generator_context_run(&gen, callback);
}
generator_context_destroy(&gen);
if (err < 0)
break;
}
if (err < 0) {
printf("%s\n", strerror(-err));
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
Reference in a new issue View git blame Copy permalink