trunk/src/stream.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003 by Benno Senoner                                   *
 *                                                                         *
 *   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 __STREAM_H__
#define __STREAM_H__

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <asm/page.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>

#include "global.h"
#include "ringbuffer.h"
#include "gig.h"

#define STREAM_END_SILENCE_SAMPLES      
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 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(uint BufferSize, uint BufferWrapElements);
       ~Stream();
        int  ReadAhead(unsigned long SampleCount);
        void WriteSilence(unsigned long SilenceSampleWords);

        inline int GetReadSpace() {
            return (pRingBuffer && State == state_active) ? pRingBuffer->read_space()  : 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() : 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, capped_cnt);
        }

        inline sample_t* GetReadPointer() {
            return pRingBuffer->get_read_ptr();
        }

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

        inline void IncrementReadPos(uint Count)  {
            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(reference_t* pExportReference, gig::Sample* pSample, unsigned long SampleOffset);
        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 (pExportReference) ? pExportReference->hStream : 0;
        }
        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;
        gig::Sample*             pSample;
        unsigned long            SampleOffset;
        RingBuffer<sample_t>*    pRingBuffer;

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

        // Methods
        inline void Reset() {
            pSample      = NULL;
            SampleOffset = 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; }
};

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