struct parser_state *state = cntr->private_data;
struct container_header header;
enum code_id code_id;
- int i;
+ unsigned int i;
int err;
// Parse header. 4 bytes are enough to detect supported containers.
uint64_t *byte_count)
{
struct builder_state *status = cntr->private_data;
- int i;
+ unsigned int i;
for (i = 0; i < ARRAY_SIZE(format_maps); ++i) {
if (format_maps[i].format == *format)
#include <sys/stat.h>
#include <unistd.h>
-static int raw_builder_pre_process(struct container_context *cntr,
- snd_pcm_format_t *sample_format,
- unsigned int *samples_per_frame,
- unsigned int *frames_per_second,
+static int raw_builder_pre_process(struct container_context *,
+ snd_pcm_format_t *,
+ unsigned int *,
+ unsigned int *,
uint64_t *byte_count)
{
*byte_count = UINT64_MAX;
}
static int raw_parser_pre_process(struct container_context *cntr,
- snd_pcm_format_t *sample_format,
- unsigned int *samples_per_frame,
- unsigned int *frames_per_second,
+ snd_pcm_format_t *,
+ unsigned int *,
+ unsigned int *,
uint64_t *byte_count)
{
struct stat buf = {0};
struct parser_state *state = cntr->private_data;
int phys_width;
const struct format_map *map;
- int i;
+ unsigned int i;
int err;
err = parse_riff_wave_format(cntr);
map = &format_maps[i];
if (state->format != map->wformat)
continue;
- if (state->avail_bits_in_sample !=
+ if ((int)state->avail_bits_in_sample !=
snd_pcm_format_width(map->format))
continue;
if (phys_width != snd_pcm_format_physical_width(map->format))
uint64_t *byte_count)
{
struct builder_state *state = cntr->private_data;
- int i;
+ unsigned int i;
// Validate parameters.
for (i = 0; i < ARRAY_SIZE(format_maps); ++i) {
unsigned int samples_per_frame, uint16_t *code,
bool extended)
{
- int i;
+ unsigned int i;
// 16 bits are available for this purpose.
if (extended) {
unsigned int *frames_per_second,
bool extended)
{
- int i;
+ unsigned int i;
if (extended) {
if (samples_per_frame > 2)
static bool check_code_id(uint8_t code_id, unsigned int version)
{
- int i;
+ unsigned int i;
for (i = 0; i < ARRAY_SIZE(format_maps); ++i) {
if (code_id != format_maps[i].code_id)
uint64_t *byte_count)
{
struct parser_state *state = cntr->private_data;
- int i;
+ unsigned int i;
int err;
err = detect_container_version(cntr);
uint64_t *byte_count)
{
struct builder_state *state = cntr->private_data;
- int i;
+ unsigned int i;
// Validate parameters.
for (i = 0; i < ARRAY_SIZE(format_maps); ++i) {
[CONTAINER_FORMAT_RAW] = "",
};
-const char *const container_suffix_from_format(enum container_format format)
+const char * container_suffix_from_format(enum container_format format)
{
return suffixes[format];
}
const char *pos;
int i;
- for (i = 0; i < ARRAY_SIZE(suffixes); ++i) {
+ for (i = 0; i < (int)ARRAY_SIZE(suffixes); ++i) {
suffix = suffixes[i];
// Check last part of the string.
err = container_recursive_read(cntr, cntr->magic, sizeof(cntr->magic));
if (err < 0)
return err;
- for (i = 0; i < ARRAY_SIZE(parsers); ++i) {
+ for (i = 0; i < (int)ARRAY_SIZE(parsers); ++i) {
parser = parsers[i];
size = strlen(parser->magic);
if (size > 4)
uint64_t handled_byte_count;
};
-const char *const container_suffix_from_format(enum container_format format);
+const char *container_suffix_from_format(enum container_format format);
enum container_format container_format_from_path(const char *path);
int container_parser_init(struct container_context *cntr, int fd,
unsigned int verbose);
char **buf_ptrs = cache->buf_ptr;
unsigned int offset;
unsigned int size;
- int i;
+ unsigned int i;
cache->remained_count -= consumed_count;
} else {
char **bufs = calloc(samples_per_frame, sizeof(*bufs));
char **buf_ptrs = calloc(samples_per_frame, sizeof(*buf_ptrs));
- int i;
+ unsigned int i;
cache->buf = bufs;
cache->buf_ptr = buf_ptrs;
if (cache->access == SND_PCM_ACCESS_RW_NONINTERLEAVED) {
char **bufs = cache->buf;
if (bufs) {
- int i;
+ unsigned int i;
for (i = 0; i < cache->samples_per_frame; ++i)
free(bufs[i]);
}
return false;
// Original command system. For long options.
- for (i = 0; i < ARRAY_SIZE(long_opts); ++i) {
+ for (i = 0; i < (int)ARRAY_SIZE(long_opts); ++i) {
for (j = 0; j < argc; ++j) {
if (!strcmp(long_opts[i].name, argv[j])) {
*subcmd = long_opts[i].subcmd;
argv[i][1] == '-' || argv[i][1] == '\0')
continue;
for (pos = argv[i]; *pos != '\0'; ++pos) {
- for (j = 0; j < ARRAY_SIZE(short_opts); ++j) {
+ for (j = 0; j < (int)ARRAY_SIZE(short_opts); ++j) {
if (*pos == short_opts[j].c) {
*subcmd = short_opts[j].subcmd;
return true;
char *pos;
// Original command system. For long options.
- for (i = 0; i < ARRAY_SIZE(long_opts); ++i) {
+ for (i = 0; i < (int)ARRAY_SIZE(long_opts); ++i) {
for (j = 0; j < argc; ++j) {
if (!strcmp(long_opts[i].name, argv[j])) {
*direction = long_opts[i].direction;
argv[i][1] == '-' || argv[i][1] == '\0')
continue;
for (pos = argv[i]; *pos != '\0'; ++pos) {
- for (j = 0; j < ARRAY_SIZE(short_opts); ++j) {
+ for (j = 0; j < (int)ARRAY_SIZE(short_opts); ++j) {
if (*pos == short_opts[j].c) {
*direction = short_opts[j].direction;
return true;
}
// If not decided yet, judge according to command name.
- for (i = 0; i < ARRAY_SIZE(aliases); ++i) {
+ for (i = 0; i < (int)ARRAY_SIZE(aliases); ++i) {
for (pos = argv[0] + strlen(argv[0]); pos != argv[0]; --pos) {
if (strstr(pos, aliases[i]) != NULL) {
*direction = i;
if (argc < 2)
return false;
- for (i = 0; i < ARRAY_SIZE(subcmds); ++i) {
+ for (i = 0; i < (int)ARRAY_SIZE(subcmds); ++i) {
if (!strcmp(argv[1], subcmds[i])) {
*subcmd = i;
return true;
unsigned int dst_pos;
unsigned int src_pos;
struct container_context *cntr;
- int i, j;
+ unsigned int i, j;
// src: first channel in each of interleaved buffers in containers =>
// dst:interleaved.
unsigned int src_pos;
unsigned int dst_pos;
struct container_context *cntr;
- int i, j;
+ unsigned int i, j;
for (i = 0; i < cntr_count; ++i) {
dst = dst_bufs[i];
{
struct multiple_state *state = mapper->private_data;
struct container_context *cntr;
- int i;
+ unsigned int i;
// Additionally, format of samples in the containers should be the same
// as the format in PCM substream.
{
struct container_context *cntr;
char *src;
- int i;
+ unsigned int i;
int err = 0;
// TODO: arrangement for *frame_count.
static void multiple_post_process(struct mapper_context *mapper)
{
struct multiple_state *state = mapper->private_data;
- int i;
+ unsigned int i;
if (state->bufs) {
for (i = 0; i < state->cntr_count; ++i) {
char *dst;
unsigned int src_pos;
unsigned int dst_pos;
- int i, j;
+ unsigned int i, j;
// src: interleaved => dst: a set of interleaved buffers.
for (i = 0; i < samples_per_frame; ++i) {
char *src;
unsigned int dst_pos;
unsigned int src_pos;
- int i, j;
+ unsigned int i, j;
// src: a set of interleaved buffers => dst:interleaved.
for (i = 0; i < samples_per_frame; ++i) {
static int single_pre_process(struct mapper_context *mapper,
struct container_context *cntrs,
- unsigned int cntr_count)
+ unsigned int)
{
struct single_state *state = mapper->private_data;
unsigned int bytes_per_buffer;
void *frame_buf,
unsigned int *frame_count,
struct container_context *cntrs,
- unsigned int cntr_count)
+ unsigned int)
{
struct single_state *state = mapper->private_data;
void *src;
void *frame_buf,
unsigned int *frame_count,
struct container_context *cntrs,
- unsigned int cntr_count)
+ unsigned int)
{
struct single_state *state = mapper->private_data;
void *dst;
};
static int dump_device(snd_ctl_t *handle, const char *id, const char *name,
- snd_pcm_stream_t direction, snd_pcm_info_t *info)
+ snd_pcm_stream_t, snd_pcm_info_t *info)
{
- unsigned int count;
- int i;
+ unsigned int i, count;
int err;
printf("card %i: %s [%s], device %i: %s [%s]\n",
continue;
}
- printf(" Subdevice #%i: %s\n",
+ printf(" Subdevice #%u: %s\n",
i, snd_pcm_info_get_subdevice_name(info));
}
if (argc < 2)
return false;
- for (i = 0; i < ARRAY_SIZE(ops); ++i) {
+ for (i = 0; i < (int)ARRAY_SIZE(ops); ++i) {
if (!strcmp(argv[1], ops[i])) {
*op = i;
return true;
static void handle_unix_signal_for_finish(int sig)
{
- int i;
+ unsigned int i;
for (i = 0; i < ctx_ptr->cntr_count; ++i)
ctx_ptr->cntrs[i].interrupted = true;
ctx_ptr->interrupted = true;
}
-static void handle_unix_signal_for_suspend(int sig)
+static void handle_unix_signal_for_suspend(int)
{
sigset_t curr, prev;
struct sigaction sa = {0};
unsigned int samples_per_frame = 0;
unsigned int frames_per_second = 0;
unsigned int channels;
- int i;
+ unsigned int i;
int err;
err = xfer_context_pre_process(&ctx->xfer, &sample_format,
snd_pcm_format_t sample_format = SND_PCM_FORMAT_UNKNOWN;
unsigned int samples_per_frame = 0;
unsigned int frames_per_second = 0;
- int i;
+ unsigned int i;
int err;
// Prepare for containers.
{
bool verbose = ctx->xfer.verbose > 2;
unsigned int frame_count;
- int i;
+ unsigned int i;
int err = 0;
if (!ctx->xfer.quiet) {
}
static void context_post_process(struct context *ctx,
- uint64_t accumulated_frame_count)
+ uint64_t)
{
uint64_t total_frame_count;
- int i;
+ unsigned int i;
xfer_context_post_process(&ctx->xfer);
int subcmd_transfer(int argc, char *const *argv, snd_pcm_stream_t direction)
{
- struct context ctx = {0};
+ static struct context ctx = {0};
uint64_t expected_frame_count = 0;
uint64_t actual_frame_count = 0;
int err = 0;
if (state->epfd < 0)
return -errno;
- for (i = 0; i < waiter->pfd_count; ++i) {
+ for (i = 0; i < (int)waiter->pfd_count; ++i) {
struct epoll_event ev = {
.data.fd = waiter->pfds[i].fd,
.events = waiter->pfds[i].events,
if (ev_count > 0) {
// Reconstruct data of pollfd structure.
- for (i = 0; i < ev_count; ++i) {
+ for (i = 0; i < (int)ev_count; ++i) {
struct epoll_event *ev = &state->events[i];
- for (j = 0; j < waiter->pfd_count; ++j) {
+ for (j = 0; j < (int)waiter->pfd_count; ++j) {
if (waiter->pfds[i].fd == ev->data.fd) {
waiter->pfds[i].revents = ev->events;
break;
struct epoll_state *state = waiter->private_data;
int i;
- for (i = 0; i < waiter->pfd_count; ++i) {
+ for (i = 0; i < (int)waiter->pfd_count; ++i) {
int fd = waiter->pfds[i].fd;
epoll_ctl(state->epfd, EPOLL_CTL_DEL, fd, NULL);
}
#include <errno.h>
#include <poll.h>
-static int poll_prepare(struct waiter_context *waiter)
+static int poll_prepare(struct waiter_context *)
{
// Nothing to do because an instance of waiter has required data.
return 0;
return err;
}
-static void poll_release(struct waiter_context *waiter)
+static void poll_release(struct waiter_context *)
{
// Nothing to do because an instance of waiter has required data.
return;
fd_set rfds_ex;
};
-static int select_prepare(struct waiter_context *waiter)
+static int select_prepare(struct waiter_context *)
{
return 0;
}
FD_ZERO(&state->rfds_ex);
fd_max = 0;
- for (i = 0; i < waiter->pfd_count; ++i) {
+ for (i = 0; i < (int)waiter->pfd_count; ++i) {
pfd = &waiter->pfds[i];
if (pfd->events & POLLIN_SET)
if (err < 0)
return -errno;
- for (i = 0; i < waiter->pfd_count; ++i) {
+ for (i = 0; i < (int)waiter->pfd_count; ++i) {
pfd = &waiter->pfds[i];
pfd->revents = 0;
return err;
}
-static void select_release(struct waiter_context *waiter)
+static void select_release(struct waiter_context *)
{
return;
}
{
int i;
- for (i = 0; i < ARRAY_SIZE(waiter_type_labels); ++i) {
+ for (i = 0; i < (int)ARRAY_SIZE(waiter_type_labels); ++i) {
if (!strcmp(waiter_type_labels[i], label))
return i;
}
if (pfd_count == 0)
return -EINVAL;
- for (i = 0; i < ARRAY_SIZE(entries); ++i) {
+ for (i = 0; i < (int)ARRAY_SIZE(entries); ++i) {
if (entries[i].type == type)
break;
}
return err;
logging(state, "attributes for mapped page frame:\n");
- for (i = 0; i < layout->samples_per_frame; ++i) {
+ for (i = 0; i < (int)layout->samples_per_frame; ++i) {
const snd_pcm_channel_area_t *area = areas + i;
logging(state, " sample number: %d\n", i);
frame_buf = buf;
} else {
int i;
- for (i = 0; i < layout->samples_per_frame; ++i) {
+ for (i = 0; i < (int)layout->samples_per_frame; ++i) {
layout->vector[i] = areas[i].addr;
layout->vector[i] += snd_pcm_samples_to_bytes(
state->handle, frame_offset);
}
static int w_process_frames_nonblocking(struct libasound_state *state,
- snd_pcm_state_t status,
+ snd_pcm_state_t,
unsigned int *frame_count,
struct mapper_context *mapper,
struct container_context *cntrs)
return err;
logging(state, "attributes for mapped page frame:\n");
- for (i = 0; i < layout->samples_per_frame; ++i) {
+ for (i = 0; i < (int)layout->samples_per_frame; ++i) {
const snd_pcm_channel_area_t *area = areas + i;
logging(state, " sample number: %d\n", i);
frame_buf = buf;
} else {
int i;
- for (i = 0; i < layout->samples_per_frame; ++i) {
+ for (i = 0; i < (int)layout->samples_per_frame; ++i) {
layout->vector[i] = areas[i].addr;
layout->vector[i] += snd_pcm_samples_to_bytes(
state->handle, frame_offset);
avail = snd_pcm_avail(state->handle);
if (avail < 0)
return (int)avail;
- if (avail < planned_count) {
+ if (avail < (snd_pcm_sframes_t)planned_count) {
logging(state,
"Wake up but not enough space: %lu %lu %u\n",
planned_count, avail, timeout_msec);
};
static int xfer_libasound_init(struct xfer_context *xfer,
- snd_pcm_stream_t direction)
+ snd_pcm_stream_t)
{
struct libasound_state *state = xfer->private_data;
int err;
state->log = NULL;
}
-static void xfer_libasound_help(struct xfer_context *xfer)
+static void xfer_libasound_help(struct xfer_context *)
{
printf(
" [BASICS]\n"
unsigned int count)
{
bool stdio = false;
- int i;
+ unsigned int i;
if (count == 0) {
stdio = true;
xfer->path_count = count;
if (stdio) {
- xfer->paths[0] = strndup("-", PATH_MAX);
+ xfer->paths[0] = strdup("-");
if (xfer->paths[0] == NULL)
return -ENOMEM;
} else {
};
int i;
- for (i = 0; i < ARRAY_SIZE(entries); ++i) {
+ for (i = 0; i < (int)ARRAY_SIZE(entries); ++i) {
entry = &entries[i];
if (strcasecmp(xfer->cntr_format_literal, entry->literal))
continue;
{"cdr", 44100, 2, SND_PCM_FORMAT_S16_LE, SND_PCM_FORMAT_S16_BE},
{"dat", 48000, 2, SND_PCM_FORMAT_S16_LE, SND_PCM_FORMAT_S16_BE},
};
- int i;
+ unsigned int i;
xfer->sample_format = snd_pcm_format_value(xfer->sample_format_literal);
if (xfer->sample_format != SND_PCM_FORMAT_UNKNOWN)
static int generate_path_without_suffix(struct xfer_context *xfer,
const char *template,
- unsigned int index, const char *suffix)
+ unsigned int index, const char *)
{
static const char *const single_format = "%s";
static const char *const multiple_format = "%s-%i";
{
char *template;
const char *suffix;
- int i, j;
+ unsigned int i, j;
int err = 0;
// Can cause memory leak.
{
const char *suffix;
char *template;
- int i, j;
+ unsigned int i, j;
int err = 0;
suffix = container_suffix_from_format(xfer->cntr_format);
int xfer_options_fixup_paths(struct xfer_context *xfer)
{
- int i, j;
+ unsigned int i, j;
int err;
if (xfer->path_count == 1) {
-// SPDX-License-Identifier: GPL-2.0
+
//
// xfer.c - receiver/transmiter of data frames.
//
enum xfer_type xfer_type_from_label(const char *label)
{
- int i;
+ unsigned int i;
for (i = 0; i < ARRAY_SIZE(xfer_type_labels); ++i) {
if (!strcmp(xfer_type_labels[i], label))
{XFER_TYPE_LIBFFADO, &xfer_libffado},
#endif
};
- int i;
+ unsigned int i;
int err;
assert(xfer);
void xfer_context_destroy(struct xfer_context *xfer)
{
- int i;
+ unsigned int i;
assert(xfer);