Blender V5.3
sound_reader_cache.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10
11#if defined(WITH_AUDASPACE)
12
13# include <utility>
14
15# include "BLI_mutex.hh"
16# include "BLI_vector.hh"
17
18# include <IReader.h>
19# include <ISound.h>
20
21namespace blender::bke {
22
23struct SoundReaderCacheState {
24 static constexpr int max_idle_readers = 2;
25
26 explicit SoundReaderCacheState(std::shared_ptr<aud::ISound> sound) : sound(std::move(sound)) {}
27
28 std::shared_ptr<aud::ISound> sound;
29 Mutex mutex;
30 Vector<std::shared_ptr<aud::IReader>, max_idle_readers> idle_readers;
31
32 void release(std::shared_ptr<aud::IReader> reader) noexcept
33 {
34 if (!reader) {
35 return;
36 }
37 std::lock_guard lock{this->mutex};
38 if (this->idle_readers.size() < max_idle_readers) {
39 this->idle_readers.append(std::move(reader));
40 }
41 }
42};
43
44SoundReaderLease::SoundReaderLease(std::shared_ptr<SoundReaderCacheState> state,
45 std::shared_ptr<aud::IReader> reader)
46 : state_(std::move(state)), reader_(std::move(reader))
47{
48}
49
50SoundReaderLease::~SoundReaderLease()
51{
52 this->release();
53}
54
55SoundReaderLease::SoundReaderLease(SoundReaderLease &&other) noexcept
56 : state_(std::move(other.state_)), reader_(std::move(other.reader_))
57{
58}
59
60SoundReaderLease &SoundReaderLease::operator=(SoundReaderLease &&other) noexcept
61{
62 if (this != &other) {
63 this->release();
64 this->state_ = std::move(other.state_);
65 this->reader_ = std::move(other.reader_);
66 }
67 return *this;
68}
69
70SoundReaderLease::operator bool() const
71{
72 return bool(this->reader_);
73}
74
75aud::IReader *SoundReaderLease::operator->() const
76{
77 return this->reader_.get();
78}
79
80void SoundReaderLease::discard() noexcept
81{
82 this->reader_.reset();
83 this->state_.reset();
84}
85
86void SoundReaderLease::release() noexcept
87{
88 if (this->state_) {
89 this->state_->release(std::move(this->reader_));
90 this->state_.reset();
91 }
92}
93
94SoundReaderCache::SoundReaderCache(std::shared_ptr<aud::ISound> sound)
95 : state_(std::make_shared<SoundReaderCacheState>(std::move(sound)))
96{
97}
98
99SoundReaderLease SoundReaderCache::acquire()
100{
101 std::shared_ptr<SoundReaderCacheState> state = this->state_;
102 std::shared_ptr<aud::IReader> reader;
103 {
104 std::lock_guard lock{state->mutex};
105 if (!state->idle_readers.is_empty()) {
106 reader = state->idle_readers.pop_last();
107 }
108 }
109
110 if (!reader && state->sound) {
111 reader = state->sound->createReader();
112 }
113 if (!reader) {
114 return {};
115 }
116 return SoundReaderLease(std::move(state), std::move(reader));
117}
118
119} // namespace blender::bke
120
121#endif
volatile int lock
const int state
std::mutex Mutex
Definition BLI_mutex.hh:51