int main(int argc, char *argv[]) {
pa_mempool *pool;
pa_sample_spec a, b;
pa_cvolume v;
pa_log_set_level(PA_LOG_DEBUG);
pa_assert_se(pool = pa_mempool_new(FALSE, 0));
a.channels = b.channels = 1;
a.rate = b.rate = 44100;
v.channels = a.channels;
v.values[0] = pa_sw_volume_from_linear(0.5);
for (a.format = 0; a.format < PA_SAMPLE_MAX; a.format ++) {
for (b.format = 0; b.format < PA_SAMPLE_MAX; b.format ++) {
pa_resampler *forth, *back;
pa_memchunk i, j, k;
printf("=== %s -> %s -> %s -> /2\n",
pa_sample_format_to_string(a.format),
pa_sample_format_to_string(b.format),
pa_sample_format_to_string(a.format));
pa_assert_se(forth = pa_resampler_new(pool, &a, NULL, &b, NULL, PA_RESAMPLER_AUTO, 0));
pa_assert_se(back = pa_resampler_new(pool, &b, NULL, &a, NULL, PA_RESAMPLER_AUTO, 0));
i.memblock = generate_block(pool, &a);
i.length = pa_memblock_get_length(i.memblock);
i.index = 0;
pa_resampler_run(forth, &i, &j);
pa_resampler_run(back, &j, &k);
printf("before: ");
dump_block(&a, &i);
printf("after : ");
dump_block(&b, &j);
printf("reverse: ");
dump_block(&a, &k);
pa_memblock_unref(j.memblock);
pa_memblock_unref(k.memblock);
pa_volume_memchunk(&i, &a, &v);
printf("volume: ");
dump_block(&a, &i);
pa_memblock_unref(i.memblock);
pa_resampler_free(forth);
pa_resampler_free(back);
}
}
pa_mempool_free(pool);
return 0;
}
int main(int argc, char *argv[]) {
static const pa_channel_map maps[] = {
{ 1, { PA_CHANNEL_POSITION_MONO } },
{ 2, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT } },
{ 3, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT, PA_CHANNEL_POSITION_CENTER } },
{ 3, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT, PA_CHANNEL_POSITION_LFE } },
{ 3, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT, PA_CHANNEL_POSITION_REAR_CENTER } },
{ 4, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT, PA_CHANNEL_POSITION_CENTER, PA_CHANNEL_POSITION_LFE } },
{ 4, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT, PA_CHANNEL_POSITION_CENTER, PA_CHANNEL_POSITION_REAR_CENTER } },
{ 4, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT, PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT } },
{ 5, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT, PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT, PA_CHANNEL_POSITION_CENTER } },
{ 5, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT, PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT, PA_CHANNEL_POSITION_LFE } },
{ 6, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT, PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT, PA_CHANNEL_POSITION_LFE, PA_CHANNEL_POSITION_CENTER } },
{ 8, { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT, PA_CHANNEL_POSITION_REAR_LEFT, PA_CHANNEL_POSITION_REAR_RIGHT, PA_CHANNEL_POSITION_LFE, PA_CHANNEL_POSITION_CENTER, PA_CHANNEL_POSITION_SIDE_LEFT, PA_CHANNEL_POSITION_SIDE_RIGHT } },
{ 0, { 0 } }
};
unsigned i, j;
pa_mempool *pool;
pa_log_set_level(PA_LOG_DEBUG);
pa_assert_se(pool = pa_mempool_new(false, 0));
for (i = 0; maps[i].channels > 0; i++)
for (j = 0; maps[j].channels > 0; j++) {
char a[PA_CHANNEL_MAP_SNPRINT_MAX], b[PA_CHANNEL_MAP_SNPRINT_MAX];
pa_resampler *r;
pa_sample_spec ss1, ss2;
pa_log_info("Converting from '%s' to '%s'.\n", pa_channel_map_snprint(a, sizeof(a), &maps[i]), pa_channel_map_snprint(b, sizeof(b), &maps[j]));
ss1.channels = maps[i].channels;
ss2.channels = maps[j].channels;
ss1.rate = ss2.rate = 44100;
ss1.format = ss2.format = PA_SAMPLE_S16NE;
r = pa_resampler_new(pool, &ss1, &maps[i], &ss2, &maps[j], PA_RESAMPLER_AUTO, 0);
/* We don't really care for the resampler. We just want to
* see the remixing debug output. */
pa_resampler_free(r);
}
pa_mempool_free(pool);
return 0;
}
static void context_free(pa_context *c) {
pa_assert(c);
context_unlink(c);
#ifdef HAVE_DBUS
if (c->system_bus) {
if (c->filter_added)
dbus_connection_remove_filter(pa_dbus_wrap_connection_get(c->system_bus), filter_cb, c);
pa_dbus_wrap_connection_free(c->system_bus);
}
if (c->session_bus) {
if (c->filter_added)
dbus_connection_remove_filter(pa_dbus_wrap_connection_get(c->session_bus), filter_cb, c);
pa_dbus_wrap_connection_free(c->session_bus);
}
#endif
if (c->record_streams)
pa_hashmap_free(c->record_streams, NULL, NULL);
if (c->playback_streams)
pa_hashmap_free(c->playback_streams, NULL, NULL);
if (c->mempool)
pa_mempool_free(c->mempool);
if (c->conf)
pa_client_conf_free(c->conf);
pa_strlist_free(c->server_list);
if (c->proplist)
pa_proplist_free(c->proplist);
pa_xfree(c->server);
pa_xfree(c);
}
int main(int argc, char *argv[]) {
pa_mempool *pool_a, *pool_b, *pool_c;
unsigned id_a, id_b, id_c;
pa_memexport *export_a, *export_b;
pa_memimport *import_b, *import_c;
pa_memblock *mb_a, *mb_b, *mb_c;
int r, i;
pa_memblock* blocks[5];
uint32_t id, shm_id;
size_t offset, size;
char *x;
const char txt[] = "This is a test!";
pool_a = pa_mempool_new(1);
pool_b = pa_mempool_new(1);
pool_c = pa_mempool_new(1);
pa_mempool_get_shm_id(pool_a, &id_a);
pa_mempool_get_shm_id(pool_b, &id_b);
pa_mempool_get_shm_id(pool_c, &id_c);
pa_assert(pool_a && pool_b && pool_c);
blocks[0] = pa_memblock_new_fixed(pool_a, (void*) txt, sizeof(txt), 1);
blocks[1] = pa_memblock_new(pool_a, sizeof(txt));
x = pa_memblock_acquire(blocks[1]);
snprintf(x, pa_memblock_get_length(blocks[1]), "%s", txt);
pa_memblock_release(blocks[1]);
blocks[2] = pa_memblock_new_pool(pool_a, sizeof(txt));
x = pa_memblock_acquire(blocks[2]);
snprintf(x, pa_memblock_get_length(blocks[2]), "%s", txt);
pa_memblock_release(blocks[2]);
blocks[3] = pa_memblock_new_malloced(pool_a, pa_xstrdup(txt), sizeof(txt));
blocks[4] = NULL;
for (i = 0; blocks[i]; i++) {
printf("Memory block %u\n", i);
mb_a = blocks[i];
pa_assert(mb_a);
export_a = pa_memexport_new(pool_a, revoke_cb, (void*) "A");
export_b = pa_memexport_new(pool_b, revoke_cb, (void*) "B");
pa_assert(export_a && export_b);
import_b = pa_memimport_new(pool_b, release_cb, (void*) "B");
import_c = pa_memimport_new(pool_c, release_cb, (void*) "C");
pa_assert(import_b && import_c);
r = pa_memexport_put(export_a, mb_a, &id, &shm_id, &offset, &size);
pa_assert(r >= 0);
pa_assert(shm_id == id_a);
printf("A: Memory block exported as %u\n", id);
mb_b = pa_memimport_get(import_b, id, shm_id, offset, size);
pa_assert(mb_b);
r = pa_memexport_put(export_b, mb_b, &id, &shm_id, &offset, &size);
pa_assert(r >= 0);
pa_assert(shm_id == id_a || shm_id == id_b);
pa_memblock_unref(mb_b);
printf("B: Memory block exported as %u\n", id);
mb_c = pa_memimport_get(import_c, id, shm_id, offset, size);
pa_assert(mb_c);
x = pa_memblock_acquire(mb_c);
printf("1 data=%s\n", x);
pa_memblock_release(mb_c);
print_stats(pool_a, "A");
print_stats(pool_b, "B");
print_stats(pool_c, "C");
pa_memexport_free(export_b);
x = pa_memblock_acquire(mb_c);
printf("2 data=%s\n", x);
pa_memblock_release(mb_c);
pa_memblock_unref(mb_c);
pa_memimport_free(import_b);
pa_memblock_unref(mb_a);
pa_memimport_free(import_c);
pa_memexport_free(export_a);
}
printf("vaccuuming...\n");
pa_mempool_vacuum(pool_a);
pa_mempool_vacuum(pool_b);
pa_mempool_vacuum(pool_c);
printf("vaccuuming done...\n");
pa_mempool_free(pool_a);
pa_mempool_free(pool_b);
pa_mempool_free(pool_c);
return 0;
}
int main(int argc, char *argv[]) {
pa_mempool *pool = NULL;
pa_sample_spec a, b;
int ret = 1, c;
bool all_formats = true;
pa_resample_method_t method;
int seconds;
unsigned crossover_freq = 120;
static const struct option long_options[] = {
{"help", 0, NULL, 'h'},
{"verbose", 0, NULL, 'v'},
{"version", 0, NULL, ARG_VERSION},
{"from-rate", 1, NULL, ARG_FROM_SAMPLERATE},
{"from-format", 1, NULL, ARG_FROM_SAMPLEFORMAT},
{"from-channels", 1, NULL, ARG_FROM_CHANNELS},
{"to-rate", 1, NULL, ARG_TO_SAMPLERATE},
{"to-format", 1, NULL, ARG_TO_SAMPLEFORMAT},
{"to-channels", 1, NULL, ARG_TO_CHANNELS},
{"seconds", 1, NULL, ARG_SECONDS},
{"resample-method", 1, NULL, ARG_RESAMPLE_METHOD},
{"dump-resample-methods", 0, NULL, ARG_DUMP_RESAMPLE_METHODS},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, PULSE_LOCALEDIR);
#endif
pa_log_set_level(PA_LOG_WARN);
if (!getenv("MAKE_CHECK"))
pa_log_set_level(PA_LOG_INFO);
pa_assert_se(pool = pa_mempool_new(false, 0));
a.channels = b.channels = 1;
a.rate = b.rate = 44100;
a.format = b.format = PA_SAMPLE_S16LE;
method = PA_RESAMPLER_AUTO;
seconds = 60;
while ((c = getopt_long(argc, argv, "hv", long_options, NULL)) != -1) {
switch (c) {
case 'h' :
help(argv[0]);
ret = 0;
goto quit;
case 'v':
pa_log_set_level(PA_LOG_DEBUG);
break;
case ARG_VERSION:
printf(_("%s %s\n"), argv[0], PACKAGE_VERSION);
ret = 0;
goto quit;
case ARG_DUMP_RESAMPLE_METHODS:
dump_resample_methods();
ret = 0;
goto quit;
case ARG_FROM_CHANNELS:
a.channels = (uint8_t) atoi(optarg);
break;
case ARG_FROM_SAMPLEFORMAT:
a.format = pa_parse_sample_format(optarg);
all_formats = false;
break;
case ARG_FROM_SAMPLERATE:
a.rate = (uint32_t) atoi(optarg);
break;
case ARG_TO_CHANNELS:
b.channels = (uint8_t) atoi(optarg);
break;
case ARG_TO_SAMPLEFORMAT:
b.format = pa_parse_sample_format(optarg);
all_formats = false;
break;
case ARG_TO_SAMPLERATE:
b.rate = (uint32_t) atoi(optarg);
break;
case ARG_SECONDS:
seconds = atoi(optarg);
break;
case ARG_RESAMPLE_METHOD:
if (*optarg == '\0' || pa_streq(optarg, "help")) {
dump_resample_methods();
ret = 0;
goto quit;
}
method = pa_parse_resample_method(optarg);
break;
default:
goto quit;
}
}
ret = 0;
pa_assert_se(pool = pa_mempool_new(false, 0));
if (!all_formats) {
pa_resampler *resampler;
pa_memchunk i, j;
pa_usec_t ts;
pa_log_debug("Compilation CFLAGS: %s", PA_CFLAGS);
pa_log_debug("=== %d seconds: %d Hz %d ch (%s) -> %d Hz %d ch (%s)", seconds,
a.rate, a.channels, pa_sample_format_to_string(a.format),
b.rate, b.channels, pa_sample_format_to_string(b.format));
ts = pa_rtclock_now();
pa_assert_se(resampler = pa_resampler_new(pool, &a, NULL, &b, NULL, crossover_freq, method, 0));
pa_log_info("init: %llu", (long long unsigned)(pa_rtclock_now() - ts));
i.memblock = pa_memblock_new(pool, pa_usec_to_bytes(1*PA_USEC_PER_SEC, &a));
ts = pa_rtclock_now();
i.length = pa_memblock_get_length(i.memblock);
i.index = 0;
while (seconds--) {
pa_resampler_run(resampler, &i, &j);
if (j.memblock)
pa_memblock_unref(j.memblock);
}
pa_log_info("resampling: %llu", (long long unsigned)(pa_rtclock_now() - ts));
pa_memblock_unref(i.memblock);
pa_resampler_free(resampler);
goto quit;
}
for (a.format = 0; a.format < PA_SAMPLE_MAX; a.format ++) {
for (b.format = 0; b.format < PA_SAMPLE_MAX; b.format ++) {
pa_resampler *forth, *back;
pa_memchunk i, j, k;
pa_log_debug("=== %s -> %s -> %s -> /2",
pa_sample_format_to_string(a.format),
pa_sample_format_to_string(b.format),
pa_sample_format_to_string(a.format));
pa_assert_se(forth = pa_resampler_new(pool, &a, NULL, &b, NULL, crossover_freq, method, 0));
pa_assert_se(back = pa_resampler_new(pool, &b, NULL, &a, NULL, crossover_freq, method, 0));
i.memblock = generate_block(pool, &a);
i.length = pa_memblock_get_length(i.memblock);
i.index = 0;
pa_resampler_run(forth, &i, &j);
pa_resampler_run(back, &j, &k);
dump_block("before", &a, &i);
dump_block("after", &b, &j);
dump_block("reverse", &a, &k);
pa_memblock_unref(i.memblock);
pa_memblock_unref(j.memblock);
pa_memblock_unref(k.memblock);
pa_resampler_free(forth);
pa_resampler_free(back);
}
}
quit:
if (pool)
pa_mempool_free(pool);
return ret;
}
int main(int argc, char *argv[]) {
int ret;
pa_mempool *p;
pa_memblockq *bq;
pa_memchunk chunk1, chunk2, chunk3, chunk4;
pa_memchunk silence;
pa_sample_spec ss = {
.format = PA_SAMPLE_S16LE,
.rate = 48000,
.channels = 1
};
pa_log_set_level(PA_LOG_DEBUG);
p = pa_mempool_new(FALSE, 0);
pa_assert_se(silence.memblock = pa_memblock_new_fixed(p, (char*) "__", 2, 1));
silence.index = 0;
silence.length = pa_memblock_get_length(silence.memblock);
pa_assert_se(bq = pa_memblockq_new("test memblockq", 0, 200, 10, &ss, 4, 4, 40, &silence));
pa_assert_se(chunk1.memblock = pa_memblock_new_fixed(p, (char*) "11", 2, 1));
chunk1.index = 0;
chunk1.length = 2;
pa_assert_se(chunk2.memblock = pa_memblock_new_fixed(p, (char*) "XX22", 4, 1));
chunk2.index = 2;
chunk2.length = 2;
pa_assert_se(chunk3.memblock = pa_memblock_new_fixed(p, (char*) "3333", 4, 1));
chunk3.index = 0;
chunk3.length = 4;
pa_assert_se(chunk4.memblock = pa_memblock_new_fixed(p, (char*) "44444444", 8, 1));
chunk4.index = 0;
chunk4.length = 8;
ret = pa_memblockq_push(bq, &chunk1);
assert(ret == 0);
ret = pa_memblockq_push(bq, &chunk2);
assert(ret == 0);
ret = pa_memblockq_push(bq, &chunk3);
assert(ret == 0);
ret = pa_memblockq_push(bq, &chunk4);
assert(ret == 0);
pa_memblockq_seek(bq, -6, 0, TRUE);
ret = pa_memblockq_push(bq, &chunk3);
assert(ret == 0);
pa_memblockq_seek(bq, -2, 0, TRUE);
ret = pa_memblockq_push(bq, &chunk1);
assert(ret == 0);
pa_memblockq_seek(bq, -10, 0, TRUE);
ret = pa_memblockq_push(bq, &chunk4);
assert(ret == 0);
pa_memblockq_seek(bq, 10, 0, TRUE);
ret = pa_memblockq_push(bq, &chunk1);
assert(ret == 0);
pa_memblockq_seek(bq, -6, 0, TRUE);
ret = pa_memblockq_push(bq, &chunk2);
assert(ret == 0);
/* Test splitting */
pa_memblockq_seek(bq, -12, 0, TRUE);
ret = pa_memblockq_push(bq, &chunk1);
assert(ret == 0);
pa_memblockq_seek(bq, 20, 0, TRUE);
/* Test merging */
ret = pa_memblockq_push(bq, &chunk3);
assert(ret == 0);
pa_memblockq_seek(bq, -2, 0, TRUE);
chunk3.index += 2;
chunk3.length -= 2;
ret = pa_memblockq_push(bq, &chunk3);
assert(ret == 0);
pa_memblockq_seek(bq, 30, PA_SEEK_RELATIVE, TRUE);
dump(bq);
pa_memblockq_rewind(bq, 52);
dump(bq);
pa_memblockq_free(bq);
pa_memblock_unref(silence.memblock);
pa_memblock_unref(chunk1.memblock);
pa_memblock_unref(chunk2.memblock);
pa_memblock_unref(chunk3.memblock);
pa_memblock_unref(chunk4.memblock);
pa_mempool_free(p);
return 0;
}
static void core_free(pa_object *o) {
pa_core *c = PA_CORE(o);
int j;
pa_assert(c);
c->state = PA_CORE_SHUTDOWN;
/* Note: All modules and samples in the cache should be unloaded before
* we get here */
pa_assert(pa_idxset_isempty(c->scache));
pa_idxset_free(c->scache, NULL);
pa_assert(pa_idxset_isempty(c->modules));
pa_idxset_free(c->modules, NULL);
pa_assert(pa_idxset_isempty(c->clients));
pa_idxset_free(c->clients, NULL);
pa_assert(pa_idxset_isempty(c->cards));
pa_idxset_free(c->cards, NULL);
pa_assert(pa_idxset_isempty(c->sinks));
pa_idxset_free(c->sinks, NULL);
pa_assert(pa_idxset_isempty(c->sources));
pa_idxset_free(c->sources, NULL);
pa_assert(pa_idxset_isempty(c->source_outputs));
pa_idxset_free(c->source_outputs, NULL);
pa_assert(pa_idxset_isempty(c->sink_inputs));
pa_idxset_free(c->sink_inputs, NULL);
pa_assert(pa_hashmap_isempty(c->namereg));
pa_hashmap_free(c->namereg);
pa_assert(pa_hashmap_isempty(c->shared));
pa_hashmap_free(c->shared);
pa_assert(pa_hashmap_isempty(c->modules_pending_unload));
pa_hashmap_free(c->modules_pending_unload);
pa_subscription_free_all(c);
if (c->exit_event)
c->mainloop->time_free(c->exit_event);
pa_assert(!c->default_source);
pa_assert(!c->default_sink);
pa_silence_cache_done(&c->silence_cache);
if (c->rw_mempool)
pa_mempool_free(c->rw_mempool);
pa_mempool_free(c->mempool);
for (j = 0; j < PA_CORE_HOOK_MAX; j++)
pa_hook_done(&c->hooks[j]);
for (j = 0; j < PA_ACCESS_HOOK_MAX; j++)
pa_hook_done(&c->access[j]);
pa_xfree(c);
}
