engines/gig/Stream.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2007 Christian Schoenebeck                       *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __LS_GIG_STREAM_H__
#define __LS_GIG_STREAM_H__

#include "../../common/global.h"

#if DEBUG_HEADERS
# warning Stream.h included
#endif // DEBUG_HEADERS

#include <gig.h>

#include "../../common/RingBuffer.h"

namespace LinuxSampler { namespace gig {

    /** @brief Buffered Disk Stream
     *
     * This encapsulation of a disk stream uses a ring buffer to allow
     * thread safe refilling the stream's buffer with one thread (disk
     * thread) and actual use / extraction of the audio data from the
     * stream's buffer with another thread (audio thread).
     */
    class Stream {
        public:
            // Member Types
            typedef uint32_t OrderID_t;
            typedef uint32_t Handle; ///< unique identifier of a relationship between one stream and a consumer (Voice)
            enum { INVALID_HANDLE = 0 };
            enum state_t {           ///< streams go through severe cyclic state transition (unused->active->end->unused->...)
                state_unused,        ///< stream is not in use, thus can still be launched
                state_active,        ///< stream provides data in it's buffer to be read and hasn't reached the end yet (this is the usual case)
                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)
            };
            struct reference_t {     ///< Defines the current relationship between the stream and a client (voice).
                OrderID_t OrderID;   ///< Unique identifier that identifies the creation order of a stream requested by a voice.
                Handle    hStream;   ///< Unique identifier of the relationship between stream and client.
                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).
                Stream*   pStream;   ///< Points to the assigned and activated stream or is NULL if the disk thread hasn't launched a stream yet.
            };

            // Methods
            Stream( ::gig::buffer_t* pDecompressionBuffer, uint BufferSize, uint BufferWrapElements);
            virtual ~Stream();
            int  ReadAhead(unsigned long SampleCount);
            void WriteSilence(unsigned long SilenceSampleWords);

            inline int GetReadSpace() {
                return (pRingBuffer && State != state_unused) ? pRingBuffer->read_space() / BytesPerSample : 0;
            }

            inline int GetWriteSpace() {
                return (pRingBuffer && State == state_active) ? pRingBuffer->write_space() : 0;
            }

            inline int GetWriteSpaceToEnd() {
                return (pRingBuffer && State == state_active) ? pRingBuffer->write_space_to_end_with_wrap() / BytesPerSample : 0;
            }

            // adjusts the write space to avoid buffer boundaries which would lead to the wrap space
            // within the buffer (needed for interpolation) getting filled only partially
            // for more infos see the docs in ringbuffer.h at adjust_write_space_to_avoid_boundary()
            inline int AdjustWriteSpaceToAvoidBoundary(int cnt, int capped_cnt) {
              return pRingBuffer->adjust_write_space_to_avoid_boundary(cnt * BytesPerSample, capped_cnt * BytesPerSample) / BytesPerSample;
            }

            // gets the current read_ptr within the ringbuffer
            inline uint8_t* GetReadPtr(void) {
                return pRingBuffer->get_read_ptr();
            }

            inline void IncrementReadPos(uint Count)  {
                Count *= BytesPerSample;
                uint leftspace = pRingBuffer->read_space();
                pRingBuffer->increment_read_ptr(Min(Count, leftspace));
                if (State == state_end && Count >= leftspace) {
                    Reset(); // quit relation between consumer (voice) and stream and reset stream right after
                }
            }

            // Static Method
            inline static uint       GetUnusedStreams() { return UnusedStreams; }
        protected:
            // Methods
            void                     Launch(Stream::Handle hStream, reference_t* pExportReference, ::gig::DimensionRegion* pDimRgn, unsigned long SampleOffset, bool DoLoop);
            inline void              Kill()      { pExportReference = NULL; Reset(); } ///< Will be called by disk thread after a 'deletion' command from the audio thread (within the voice class)
            inline Stream::Handle    GetHandle() { return hThis; }
            inline Stream::state_t   GetState()  { return State; }
            friend class DiskThread; // only the disk thread should be able to launch and most important kill a disk stream to avoid race conditions
        private:
            // Attributes
            reference_t*             pExportReference;
            state_t                  State;
            Stream::Handle           hThis;
            unsigned long            SampleOffset;
            ::gig::DimensionRegion*  pDimRgn;
            ::gig::playback_state_t  PlaybackState;
            RingBuffer<uint8_t,false>* pRingBuffer;
            bool                     DoLoop;
            ::gig::buffer_t*         pDecompressionBuffer;
            int                      BytesPerSample;

            // Static Attributes
            static uint              UnusedStreams; //< Reflects how many stream objects of all stream instances are currently not in use.
            static uint              TotalStreams; //< Reflects how many stream objects currently exist.

            // Methods
            inline void Reset() {
                SampleOffset                   = 0;
                pDimRgn                        = NULL;
                PlaybackState.position         = 0;
                PlaybackState.reverse          = false;
                hThis                          = 0;
                pRingBuffer->init(); // reset ringbuffer
                if (State != state_unused) {
                    // we can't do 'SetPos(state_unused)' here, due to possible race conditions)
                    if (pExportReference) {
                        pExportReference->State = state_unused;
                        pExportReference        = NULL;
                    }
                    State = state_unused;
                    UnusedStreams++;
                }
            }
            inline void SetState(state_t State) {
                if (pExportReference) pExportReference->State = State;
                this->State = State;
            }
            inline long Min(long a, long b) { return (a < b) ? a : b; }
    };

}} // namespace LinuxSampler::gig

#endif // __LS_GIG_STREAM_H__
1	schoenebeck	53	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5	schoenebeck	56	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	schoenebeck	1321	* Copyright (C) 2005 - 2007 Christian Schoenebeck *
7	schoenebeck	53	* *
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	schoenebeck	505	#include <gig.h>
34
35	schoenebeck	53	#include "../../common/RingBuffer.h"
36
37			namespace LinuxSampler { namespace gig {
38
39	schoenebeck	563	/** @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	schoenebeck	53	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	schoenebeck	1321	enum { INVALID_HANDLE = 0 };
52	schoenebeck	53	enum state_t { ///< streams go through severe cyclic state transition (unused->active->end->unused->...)
53			state_unused, ///< stream is not in use, thus can still be launched
54			state_active, ///< stream provides data in it's buffer to be read and hasn't reached the end yet (this is the usual case)
55			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)
56			};
57			struct reference_t { ///< Defines the current relationship between the stream and a client (voice).
58			OrderID_t OrderID; ///< Unique identifier that identifies the creation order of a stream requested by a voice.
59			Handle hStream; ///< Unique identifier of the relationship between stream and client.
60			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).
61			Stream* pStream; ///< Points to the assigned and activated stream or is NULL if the disk thread hasn't launched a stream yet.
62			};
63
64			// Methods
65	schoenebeck	385	Stream( ::gig::buffer_t* pDecompressionBuffer, uint BufferSize, uint BufferWrapElements);
66	letz	502	virtual ~Stream();
67	schoenebeck	53	int ReadAhead(unsigned long SampleCount);
68			void WriteSilence(unsigned long SilenceSampleWords);
69
70			inline int GetReadSpace() {
71	persson	903	return (pRingBuffer && State != state_unused) ? pRingBuffer->read_space() / BytesPerSample : 0;
72	schoenebeck	53	}
73
74			inline int GetWriteSpace() {
75			return (pRingBuffer && State == state_active) ? pRingBuffer->write_space() : 0;
76			}
77
78			inline int GetWriteSpaceToEnd() {
79	persson	903	return (pRingBuffer && State == state_active) ? pRingBuffer->write_space_to_end_with_wrap() / BytesPerSample : 0;
80	schoenebeck	53	}
81
82			// adjusts the write space to avoid buffer boundaries which would lead to the wrap space
83			// within the buffer (needed for interpolation) getting filled only partially
84			// for more infos see the docs in ringbuffer.h at adjust_write_space_to_avoid_boundary()
85			inline int AdjustWriteSpaceToAvoidBoundary(int cnt, int capped_cnt) {
86	persson	903	return pRingBuffer->adjust_write_space_to_avoid_boundary(cnt * BytesPerSample, capped_cnt * BytesPerSample) / BytesPerSample;
87	schoenebeck	53	}
88
89			// gets the current read_ptr within the ringbuffer
90	persson	903	inline uint8_t* GetReadPtr(void) {
91	schoenebeck	53	return pRingBuffer->get_read_ptr();
92			}
93
94			inline void IncrementReadPos(uint Count) {
95	persson	903	Count *= BytesPerSample;
96	schoenebeck	53	uint leftspace = pRingBuffer->read_space();
97			pRingBuffer->increment_read_ptr(Min(Count, leftspace));
98			if (State == state_end && Count >= leftspace) {
99			Reset(); // quit relation between consumer (voice) and stream and reset stream right after
100			}
101			}
102
103			// Static Method
104			inline static uint GetUnusedStreams() { return UnusedStreams; }
105			protected:
106			// Methods
107	persson	865	void Launch(Stream::Handle hStream, reference_t* pExportReference, ::gig::DimensionRegion* pDimRgn, unsigned long SampleOffset, bool DoLoop);
108	schoenebeck	53	inline void Kill() { pExportReference = NULL; Reset(); } ///< Will be called by disk thread after a 'deletion' command from the audio thread (within the voice class)
109			inline Stream::Handle GetHandle() { return hThis; }
110			inline Stream::state_t GetState() { return State; }
111			friend class DiskThread; // only the disk thread should be able to launch and most important kill a disk stream to avoid race conditions
112			private:
113			// Attributes
114			reference_t* pExportReference;
115			state_t State;
116			Stream::Handle hThis;
117			unsigned long SampleOffset;
118	persson	865	::gig::DimensionRegion* pDimRgn;
119	schoenebeck	53	::gig::playback_state_t PlaybackState;
120	schoenebeck	970	RingBuffer<uint8_t,false>* pRingBuffer;
121	schoenebeck	53	bool DoLoop;
122	schoenebeck	385	::gig::buffer_t* pDecompressionBuffer;
123	persson	903	int BytesPerSample;
124	schoenebeck	53
125			// Static Attributes
126			static uint UnusedStreams; //< Reflects how many stream objects of all stream instances are currently not in use.
127	senkov	333	static uint TotalStreams; //< Reflects how many stream objects currently exist.
128	schoenebeck	53
129			// Methods
130			inline void Reset() {
131			SampleOffset = 0;
132	persson	865	pDimRgn = NULL;
133	schoenebeck	53	PlaybackState.position = 0;
134			PlaybackState.reverse = false;
135			hThis = 0;
136			pRingBuffer->init(); // reset ringbuffer
137			if (State != state_unused) {
138			// we can't do 'SetPos(state_unused)' here, due to possible race conditions)
139			if (pExportReference) {
140			pExportReference->State = state_unused;
141			pExportReference = NULL;
142			}
143			State = state_unused;
144			UnusedStreams++;
145			}
146			}
147			inline void SetState(state_t State) {
148			if (pExportReference) pExportReference->State = State;
149			this->State = State;
150			}
151			inline long Min(long a, long b) { return (a < b) ? a : b; }
152			};
153
154			}} // namespace LinuxSampler::gig
155
156			#endif // __LS_GIG_STREAM_H__