code.delx.au - pulseaudio/blob - src/pulsecore/core-scache.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2008 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <sys/types.h>
  30 #include <dirent.h>
  31 #include <sys/stat.h>
  32 #include <errno.h>
  33 #include <limits.h>
  34 #include <time.h>
  35
  36 #ifdef HAVE_GLOB_H
  37 #include <glob.h>
  38 #endif
  39
  40 #ifdef HAVE_WINDOWS_H
  41 #include <windows.h>
  42 #endif
  43
  44 #include <pulse/mainloop.h>
  45 #include <pulse/channelmap.h>
  46 #include <pulse/timeval.h>
  47 #include <pulse/util.h>
  48 #include <pulse/volume.h>
  49 #include <pulse/xmalloc.h>
  50 #include <pulse/rtclock.h>
  51
  52 #include <pulsecore/sink-input.h>
  53 #include <pulsecore/play-memchunk.h>
  54 #include <pulsecore/core-subscribe.h>
  55 #include <pulsecore/namereg.h>
  56 #include <pulsecore/sound-file.h>
  57 #include <pulsecore/core-rtclock.h>
  58 #include <pulsecore/core-util.h>
  59 #include <pulsecore/log.h>
  60 #include <pulsecore/core-error.h>
  61 #include <pulsecore/macro.h>
  62
  63 #include "core-scache.h"
  64
  65 #define UNLOAD_POLL_TIME (60 * PA_USEC_PER_SEC)
  66
  67 static void timeout_callback(pa_mainloop_api *m, pa_time_event *e, const struct timeval *t, void *userdata) {
  68     pa_core *c = userdata;
  69
  70     pa_assert(c);
  71     pa_assert(c->mainloop == m);
  72     pa_assert(c->scache_auto_unload_event == e);
  73
  74     pa_scache_unload_unused(c);
  75
  76     pa_core_rttime_restart(c, e, pa_rtclock_now() + UNLOAD_POLL_TIME);
  77 }
  78
  79 static void free_entry(pa_scache_entry *e) {
  80     pa_assert(e);
  81
  82     pa_namereg_unregister(e->core, e->name);
  83     pa_subscription_post(e->core, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_REMOVE, e->index);
  84     pa_xfree(e->name);
  85     pa_xfree(e->filename);
  86     if (e->memchunk.memblock)
  87         pa_memblock_unref(e->memchunk.memblock);
  88     if (e->proplist)
  89         pa_proplist_free(e->proplist);
  90     pa_xfree(e);
  91 }
  92
  93 static pa_scache_entry* scache_add_item(pa_core *c, const char *name) {
  94     pa_scache_entry *e;
  95
  96     pa_assert(c);
  97     pa_assert(name);
  98
  99     if ((e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE))) {
 100         if (e->memchunk.memblock)
 101             pa_memblock_unref(e->memchunk.memblock);
 102
 103         pa_xfree(e->filename);
 104         pa_proplist_clear(e->proplist);
 105
 106         pa_assert(e->core == c);
 107
 108         pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_CHANGE, e->index);
 109     } else {
 110         e = pa_xnew(pa_scache_entry, 1);
 111
 112         if (!pa_namereg_register(c, name, PA_NAMEREG_SAMPLE, e, true)) {
 113             pa_xfree(e);
 114             return NULL;
 115         }
 116
 117         e->name = pa_xstrdup(name);
 118         e->core = c;
 119         e->proplist = pa_proplist_new();
 120
 121         pa_idxset_put(c->scache, e, &e->index);
 122
 123         pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_NEW, e->index);
 124     }
 125
 126     e->last_used_time = 0;
 127     pa_memchunk_reset(&e->memchunk);
 128     e->filename = NULL;
 129     e->lazy = false;
 130     e->last_used_time = 0;
 131
 132     pa_sample_spec_init(&e->sample_spec);
 133     pa_channel_map_init(&e->channel_map);
 134     pa_cvolume_init(&e->volume);
 135     e->volume_is_set = false;
 136
 137     pa_proplist_sets(e->proplist, PA_PROP_MEDIA_ROLE, "event");
 138
 139     return e;
 140 }
 141
 142 int pa_scache_add_item(
 143         pa_core *c,
 144         const char *name,
 145         const pa_sample_spec *ss,
 146         const pa_channel_map *map,
 147         const pa_memchunk *chunk,
 148         pa_proplist *p,
 149         uint32_t *idx) {
 150
 151     pa_scache_entry *e;
 152     char st[PA_SAMPLE_SPEC_SNPRINT_MAX];
 153     pa_channel_map tmap;
 154
 155     pa_assert(c);
 156     pa_assert(name);
 157     pa_assert(!ss || pa_sample_spec_valid(ss));
 158     pa_assert(!map || (pa_channel_map_valid(map) && ss && pa_channel_map_compatible(map, ss)));
 159
 160     if (ss && !map) {
 161         pa_channel_map_init_extend(&tmap, ss->channels, PA_CHANNEL_MAP_DEFAULT);
 162         map = &tmap;
 163     }
 164
 165     if (chunk && chunk->length > PA_SCACHE_ENTRY_SIZE_MAX)
 166         return -1;
 167
 168     if (!(e = scache_add_item(c, name)))
 169         return -1;
 170
 171     pa_sample_spec_init(&e->sample_spec);
 172     pa_channel_map_init(&e->channel_map);
 173     pa_cvolume_init(&e->volume);
 174     e->volume_is_set = false;
 175
 176     if (ss) {
 177         e->sample_spec = *ss;
 178         pa_cvolume_reset(&e->volume, ss->channels);
 179     }
 180
 181     if (map)
 182         e->channel_map = *map;
 183
 184     if (chunk) {
 185         e->memchunk = *chunk;
 186         pa_memblock_ref(e->memchunk.memblock);
 187     }
 188
 189     if (p)
 190         pa_proplist_update(e->proplist, PA_UPDATE_REPLACE, p);
 191
 192     if (idx)
 193         *idx = e->index;
 194
 195     pa_log_debug("Created sample \"%s\" (#%d), %lu bytes with sample spec %s",
 196                  name, e->index, (unsigned long) e->memchunk.length,
 197                  pa_sample_spec_snprint(st, sizeof(st), &e->sample_spec));
 198
 199     return 0;
 200 }
 201
 202 int pa_scache_add_file(pa_core *c, const char *name, const char *filename, uint32_t *idx) {
 203     pa_sample_spec ss;
 204     pa_channel_map map;
 205     pa_memchunk chunk;
 206     int r;
 207     pa_proplist *p;
 208
 209 #ifdef OS_IS_WIN32
 210     char buf[MAX_PATH];
 211
 212     if (ExpandEnvironmentStrings(filename, buf, MAX_PATH))
 213         filename = buf;
 214 #endif
 215
 216     pa_assert(c);
 217     pa_assert(name);
 218     pa_assert(filename);
 219
 220     p = pa_proplist_new();
 221     pa_proplist_sets(p, PA_PROP_MEDIA_FILENAME, filename);
 222
 223     if (pa_sound_file_load(c->mempool, filename, &ss, &map, &chunk, p) < 0) {
 224         pa_proplist_free(p);
 225         return -1;
 226     }
 227
 228     r = pa_scache_add_item(c, name, &ss, &map, &chunk, p, idx);
 229     pa_memblock_unref(chunk.memblock);
 230     pa_proplist_free(p);
 231
 232     return r;
 233 }
 234
 235 int pa_scache_add_file_lazy(pa_core *c, const char *name, const char *filename, uint32_t *idx) {
 236     pa_scache_entry *e;
 237
 238 #ifdef OS_IS_WIN32
 239     char buf[MAX_PATH];
 240
 241     if (ExpandEnvironmentStrings(filename, buf, MAX_PATH))
 242         filename = buf;
 243 #endif
 244
 245     pa_assert(c);
 246     pa_assert(name);
 247     pa_assert(filename);
 248
 249     if (!(e = scache_add_item(c, name)))
 250         return -1;
 251
 252     e->lazy = true;
 253     e->filename = pa_xstrdup(filename);
 254
 255     pa_proplist_sets(e->proplist, PA_PROP_MEDIA_FILENAME, filename);
 256
 257     if (!c->scache_auto_unload_event)
 258         c->scache_auto_unload_event = pa_core_rttime_new(c, pa_rtclock_now() + UNLOAD_POLL_TIME, timeout_callback, c);
 259
 260     if (idx)
 261         *idx = e->index;
 262
 263     return 0;
 264 }
 265
 266 int pa_scache_remove_item(pa_core *c, const char *name) {
 267     pa_scache_entry *e;
 268
 269     pa_assert(c);
 270     pa_assert(name);
 271
 272     if (!(e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE)))
 273         return -1;
 274
 275     pa_assert_se(pa_idxset_remove_by_data(c->scache, e, NULL) == e);
 276
 277     pa_log_debug("Removed sample \"%s\"", name);
 278
 279     free_entry(e);
 280
 281     return 0;
 282 }
 283
 284 void pa_scache_free_all(pa_core *c) {
 285     pa_assert(c);
 286
 287     pa_idxset_remove_all(c->scache, (pa_free_cb_t) free_entry);
 288
 289     if (c->scache_auto_unload_event) {
 290         c->mainloop->time_free(c->scache_auto_unload_event);
 291         c->scache_auto_unload_event = NULL;
 292     }
 293 }
 294
 295 int pa_scache_play_item(pa_core *c, const char *name, pa_sink *sink, pa_volume_t volume, pa_proplist *p, uint32_t *sink_input_idx) {
 296     pa_scache_entry *e;
 297     pa_cvolume r;
 298     pa_proplist *merged;
 299     bool pass_volume;
 300
 301     pa_assert(c);
 302     pa_assert(name);
 303     pa_assert(sink);
 304
 305     if (!(e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE)))
 306         return -1;
 307
 308     merged = pa_proplist_new();
 309     pa_proplist_sets(merged, PA_PROP_MEDIA_NAME, name);
 310     pa_proplist_sets(merged, PA_PROP_EVENT_ID, name);
 311
 312     if (e->lazy && !e->memchunk.memblock) {
 313         pa_channel_map old_channel_map = e->channel_map;
 314
 315         if (pa_sound_file_load(c->mempool, e->filename, &e->sample_spec, &e->channel_map, &e->memchunk, merged) < 0)
 316             goto fail;
 317
 318         pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_CHANGE, e->index);
 319
 320         if (e->volume_is_set) {
 321             if (pa_cvolume_valid(&e->volume))
 322                 pa_cvolume_remap(&e->volume, &old_channel_map, &e->channel_map);
 323             else
 324                 pa_cvolume_reset(&e->volume, e->sample_spec.channels);
 325         }
 326     }
 327
 328     if (!e->memchunk.memblock)
 329         goto fail;
 330
 331     pa_log_debug("Playing sample \"%s\" on \"%s\"", name, sink->name);
 332
 333     pass_volume = true;
 334
 335     if (e->volume_is_set && PA_VOLUME_IS_VALID(volume)) {
 336         pa_cvolume_set(&r, e->sample_spec.channels, volume);
 337         pa_sw_cvolume_multiply(&r, &r, &e->volume);
 338     } else if (e->volume_is_set)
 339         r = e->volume;
 340     else if (PA_VOLUME_IS_VALID(volume))
 341         pa_cvolume_set(&r, e->sample_spec.channels, volume);
 342     else
 343         pass_volume = false;
 344
 345     pa_proplist_update(merged, PA_UPDATE_REPLACE, e->proplist);
 346
 347     if (p)
 348         pa_proplist_update(merged, PA_UPDATE_REPLACE, p);
 349
 350     if (pa_play_memchunk(sink,
 351                          &e->sample_spec, &e->channel_map,
 352                          &e->memchunk,
 353                          pass_volume ? &r : NULL,
 354                          merged,
 355                          PA_SINK_INPUT_NO_CREATE_ON_SUSPEND|PA_SINK_INPUT_KILL_ON_SUSPEND, sink_input_idx) < 0)
 356         goto fail;
 357
 358     pa_proplist_free(merged);
 359
 360     if (e->lazy)
 361         time(&e->last_used_time);
 362
 363     return 0;
 364
 365 fail:
 366     pa_proplist_free(merged);
 367     return -1;
 368 }
 369
 370 int pa_scache_play_item_by_name(pa_core *c, const char *name, const char*sink_name, pa_volume_t volume, pa_proplist *p, uint32_t *sink_input_idx) {
 371     pa_sink *sink;
 372
 373     pa_assert(c);
 374     pa_assert(name);
 375
 376     if (!(sink = pa_namereg_get(c, sink_name, PA_NAMEREG_SINK)))
 377         return -1;
 378
 379     return pa_scache_play_item(c, name, sink, volume, p, sink_input_idx);
 380 }
 381
 382 const char *pa_scache_get_name_by_id(pa_core *c, uint32_t id) {
 383     pa_scache_entry *e;
 384
 385     pa_assert(c);
 386     pa_assert(id != PA_IDXSET_INVALID);
 387
 388     if (!c->scache || !(e = pa_idxset_get_by_index(c->scache, id)))
 389         return NULL;
 390
 391     return e->name;
 392 }
 393
 394 uint32_t pa_scache_get_id_by_name(pa_core *c, const char *name) {
 395     pa_scache_entry *e;
 396
 397     pa_assert(c);
 398     pa_assert(name);
 399
 400     if (!(e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE)))
 401         return PA_IDXSET_INVALID;
 402
 403     return e->index;
 404 }
 405
 406 size_t pa_scache_total_size(pa_core *c) {
 407     pa_scache_entry *e;
 408     uint32_t idx;
 409     size_t sum = 0;
 410
 411     pa_assert(c);
 412
 413     if (!c->scache || !pa_idxset_size(c->scache))
 414         return 0;
 415
 416     PA_IDXSET_FOREACH(e, c->scache, idx)
 417         if (e->memchunk.memblock)
 418             sum += e->memchunk.length;
 419
 420     return sum;
 421 }
 422
 423 void pa_scache_unload_unused(pa_core *c) {
 424     pa_scache_entry *e;
 425     time_t now;
 426     uint32_t idx;
 427
 428     pa_assert(c);
 429
 430     if (!c->scache || !pa_idxset_size(c->scache))
 431         return;
 432
 433     time(&now);
 434
 435     PA_IDXSET_FOREACH(e, c->scache, idx) {
 436
 437         if (!e->lazy || !e->memchunk.memblock)
 438             continue;
 439
 440         if (e->last_used_time + c->scache_idle_time > now)
 441             continue;
 442
 443         pa_memblock_unref(e->memchunk.memblock);
 444         pa_memchunk_reset(&e->memchunk);
 445
 446         pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_CHANGE, e->index);
 447     }
 448 }
 449
 450 static void add_file(pa_core *c, const char *pathname) {
 451     struct stat st;
 452     const char *e;
 453
 454     pa_core_assert_ref(c);
 455     pa_assert(pathname);
 456
 457     e = pa_path_get_filename(pathname);
 458
 459     if (stat(pathname, &st) < 0) {
 460         pa_log("stat('%s'): %s", pathname, pa_cstrerror(errno));
 461         return;
 462     }
 463
 464 #if defined(S_ISREG) && defined(S_ISLNK)
 465     if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode))
 466 #endif
 467         pa_scache_add_file_lazy(c, e, pathname, NULL);
 468 }
 469
 470 int pa_scache_add_directory_lazy(pa_core *c, const char *pathname) {
 471     DIR *dir;
 472
 473     pa_core_assert_ref(c);
 474     pa_assert(pathname);
 475
 476     /* First try to open this as directory */
 477     if (!(dir = opendir(pathname))) {
 478 #ifdef HAVE_GLOB_H
 479         glob_t p;
 480         unsigned int i;
 481         /* If that fails, try to open it as shell glob */
 482
 483         if (glob(pathname, GLOB_ERR|GLOB_NOSORT, NULL, &p) < 0) {
 484             pa_log("failed to open directory '%s': %s", pathname, pa_cstrerror(errno));
 485             return -1;
 486         }
 487
 488         for (i = 0; i < p.gl_pathc; i++)
 489             add_file(c, p.gl_pathv[i]);
 490
 491         globfree(&p);
 492 #else
 493         return -1;
 494 #endif
 495     } else {
 496         struct dirent *e;
 497
 498         while ((e = readdir(dir))) {
 499             char *p;
 500
 501             if (e->d_name[0] == '.')
 502                 continue;
 503
 504             p = pa_sprintf_malloc("%s" PA_PATH_SEP "%s", pathname, e->d_name);
 505             add_file(c, p);
 506             pa_xfree(p);
 507         }
 508
 509         closedir(dir);
 510     }
 511
 512     return 0;
 513 }