/[svn]/linuxsampler/trunk/src/engines/gig/Stream.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/gig/Stream.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 563 - (show annotations) (download) (as text)
Sun May 22 20:43:32 2005 UTC (18 years, 10 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 8466 byte(s)
* (re)implemented voice stealing algorithm "oldestvoiceonkey" and made it
  the default voice stealing algorithm
* added new LSCP command "GET SERVER INFO" which currently returns
  description and version about this sampler
* added some API documentation comments
* minor cleanup

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 Christian Schoenebeck *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 ***************************************************************************/
23
24 #ifndef __LS_GIG_STREAM_H__
25 #define __LS_GIG_STREAM_H__
26
27 #include "../../common/global.h"
28
29 #if DEBUG_HEADERS
30 # warning Stream.h included
31 #endif // DEBUG_HEADERS
32
33 #include <gig.h>
34
35 #include "../../common/RingBuffer.h"
36
37 namespace LinuxSampler { namespace gig {
38
39 /** @brief Buffered Disk Stream
40 *
41 * This encapsulation of a disk stream uses a ring buffer to allow
42 * thread safe refilling the stream's buffer with one thread (disk
43 * thread) and actual use / extraction of the audio data from the
44 * stream's buffer with another thread (audio thread).
45 */
46 class Stream {
47 public:
48 // Member Types
49 typedef uint32_t OrderID_t;
50 typedef uint32_t Handle; ///< unique identifier of a relationship between one stream and a consumer (Voice)
51 enum state_t { ///< streams go through severe cyclic state transition (unused->active->end->unused->...)
52 state_unused, ///< stream is not in use, thus can still be launched
53 state_active, ///< stream provides data in it's buffer to be read and hasn't reached the end yet (this is the usual case)
54 state_end ///< stream end reached but still providing data in it's buffer to be read (after the client read all remaining data from the stream buffer, state will change automatically to state_unused)
55 };
56 struct reference_t { ///< Defines the current relationship between the stream and a client (voice).
57 OrderID_t OrderID; ///< Unique identifier that identifies the creation order of a stream requested by a voice.
58 Handle hStream; ///< Unique identifier of the relationship between stream and client.
59 state_t State; ///< Current state of the stream that will be pretended to the client (the actual state of the stream might differ though, because the stream might already be in use by another client).
60 Stream* pStream; ///< Points to the assigned and activated stream or is NULL if the disk thread hasn't launched a stream yet.
61 };
62
63 // Methods
64 Stream( ::gig::buffer_t* pDecompressionBuffer, uint BufferSize, uint BufferWrapElements);
65 virtual ~Stream();
66 int ReadAhead(unsigned long SampleCount);
67 void WriteSilence(unsigned long SilenceSampleWords);
68
69 inline int GetReadSpace() {
70 return (pRingBuffer && State != state_unused) ? pRingBuffer->read_space() : 0;
71 }
72
73 inline int GetWriteSpace() {
74 return (pRingBuffer && State == state_active) ? pRingBuffer->write_space() : 0;
75 }
76
77 inline int GetWriteSpaceToEnd() {
78 return (pRingBuffer && State == state_active) ? pRingBuffer->write_space_to_end_with_wrap() : 0;
79 }
80
81 // adjusts the write space to avoid buffer boundaries which would lead to the wrap space
82 // within the buffer (needed for interpolation) getting filled only partially
83 // for more infos see the docs in ringbuffer.h at adjust_write_space_to_avoid_boundary()
84 inline int AdjustWriteSpaceToAvoidBoundary(int cnt, int capped_cnt) {
85 return pRingBuffer->adjust_write_space_to_avoid_boundary(cnt, capped_cnt);
86 }
87
88 inline sample_t* GetReadPointer() {
89 return pRingBuffer->get_read_ptr();
90 }
91
92 // gets the current read_ptr within the ringbuffer
93 inline sample_t* GetReadPtr(void) {
94 return pRingBuffer->get_read_ptr();
95 }
96
97 inline void IncrementReadPos(uint Count) {
98 uint leftspace = pRingBuffer->read_space();
99 pRingBuffer->increment_read_ptr(Min(Count, leftspace));
100 if (State == state_end && Count >= leftspace) {
101 Reset(); // quit relation between consumer (voice) and stream and reset stream right after
102 }
103 }
104
105 // Static Method
106 inline static uint GetUnusedStreams() { return UnusedStreams; }
107 protected:
108 // Methods
109 void Launch(Stream::Handle hStream, reference_t* pExportReference, ::gig::Sample* pSample, unsigned long SampleOffset, bool DoLoop);
110 inline void Kill() { pExportReference = NULL; Reset(); } ///< Will be called by disk thread after a 'deletion' command from the audio thread (within the voice class)
111 inline Stream::Handle GetHandle() { return hThis; }
112 inline Stream::state_t GetState() { return State; }
113 friend class DiskThread; // only the disk thread should be able to launch and most important kill a disk stream to avoid race conditions
114 private:
115 // Attributes
116 reference_t* pExportReference;
117 state_t State;
118 Stream::Handle hThis;
119 unsigned long SampleOffset;
120 ::gig::Sample* pSample;
121 ::gig::playback_state_t PlaybackState;
122 RingBuffer<sample_t>* pRingBuffer;
123 bool DoLoop;
124 ::gig::buffer_t* pDecompressionBuffer;
125
126 // Static Attributes
127 static uint UnusedStreams; //< Reflects how many stream objects of all stream instances are currently not in use.
128 static uint TotalStreams; //< Reflects how many stream objects currently exist.
129
130 // Methods
131 inline void Reset() {
132 SampleOffset = 0;
133 pSample = NULL;
134 PlaybackState.position = 0;
135 PlaybackState.reverse = false;
136 hThis = 0;
137 pRingBuffer->init(); // reset ringbuffer
138 if (State != state_unused) {
139 // we can't do 'SetPos(state_unused)' here, due to possible race conditions)
140 if (pExportReference) {
141 pExportReference->State = state_unused;
142 pExportReference = NULL;
143 }
144 State = state_unused;
145 UnusedStreams++;
146 }
147 }
148 inline void SetState(state_t State) {
149 if (pExportReference) pExportReference->State = State;
150 this->State = State;
151 }
152 inline long Min(long a, long b) { return (a < b) ? a : b; }
153 };
154
155 }} // namespace LinuxSampler::gig
156
157 #endif // __LS_GIG_STREAM_H__

  ViewVC Help
Powered by ViewVC