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

Diff of /linuxsampler/trunk/src/engines/gig/DiskThread.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2011 by persson, Sun Jun 28 16:43:38 2009 UTC revision 2012 by iliev, Fri Oct 23 17:53:17 2009 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   LinuxSampler - modular, streaming capable sampler                     *   *   LinuxSampler - modular, streaming capable sampler                     *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *   *   Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck    *
6   *   Copyright (C) 2005 - 2009 Christian Schoenebeck                       *   *   Copyright (C) 2005-2009 Christian Schoenebeck                         *
7     *   Copyright (C) 2009 Grigor Iliev                                       *
8   *                                                                         *   *                                                                         *
9   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
10   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 22  Line 23 
23   ***************************************************************************/   ***************************************************************************/
24    
25  #ifndef __LS_GIG_DISKTHREAD_H__  #ifndef __LS_GIG_DISKTHREAD_H__
26  #define __LS_GIG_DISKTHREAD_H__  #define __LS_GIG_DISKTHREAD_H__
   
 #include "../../common/global_private.h"  
27    
28    #include "../InstrumentManagerBase.h"
29    #include "../common/DiskThreadBase.h"
30    #include "InstrumentResourceManager.h"
31  #include <gig.h>  #include <gig.h>
32    
 #include "../../common/Thread.h"  
 #include "../../common/RingBuffer.h"  
 #include "../../common/atomic.h"  
 #include "Stream.h"  
 #include "Voice.h"  
   
33  namespace LinuxSampler { namespace gig {  namespace LinuxSampler { namespace gig {
34    
35      int CompareStreamWriteSpace(const void* a, const void* b);      class DiskThread: public LinuxSampler::DiskThreadBase< ::gig::DimensionRegion, InstrumentResourceManager> {
   
     /** @brief Disk Reader Thread  
      *  
      * The disk reader thread is responsible for periodically refilling  
      * disk streams in parallel to the audio thread's rendering process.  
      *  
      * There is also a function for releasing parts of instruments not  
      * in use anymore (as this is not real time safe, the audio thread  
      * cannot do it directly).  
      */  
     class DiskThread : public Thread {  
         public:  
             // Methods  
             DiskThread(int MaxStreams, uint BufferWrapElements, InstrumentResourceManager* pInstruments);  
             virtual ~DiskThread();  
             void    Reset();  
             String  GetBufferFillBytes();  
             String  GetBufferFillPercentage();  
             int     OrderNewStream(Stream::reference_t* pStreamRef, ::gig::DimensionRegion* pDimRgn, unsigned long SampleOffset, bool DoLoop);  
             int     OrderDeletionOfStream(Stream::reference_t* pStreamRef, bool bRequestNotification = false);  
             int     OrderDeletionOfDimreg(::gig::DimensionRegion* dimreg);  
             int     OrderProgramChange(uint8_t Program, EngineChannel* pEngineChannel);  
             Stream* AskForCreatedStream(Stream::OrderID_t StreamOrderID);  
             Stream::Handle AskForDeletedStream();  
   
             // the number of streams currently in usage  
             // printed on the console the main thread (along with the active voice count)  
             uint GetActiveStreamCount() { return atomic_read(&ActiveStreamCount); }  
             void SetActiveStreamCount(uint Streams) { atomic_set(&ActiveStreamCount, Streams); }  
             int ActiveStreamCountMax;  
   
36          protected:          protected:
37              ::gig::buffer_t DecompressionBuffer; ///< Used for thread safe streaming.              ::gig::buffer_t DecompressionBuffer; ///< Used for thread safe streaming.
38    
39              int Main(); ///< Implementation of virtual method from class Thread              virtual LinuxSampler::Stream* CreateStream(long BufferSize, uint BufferWrapElements);
40    
41              friend class Stream;              virtual void LaunchStream (
42          private:                  LinuxSampler::Stream*    pStream,
43              // Private Types                  Stream::Handle           hStream,
44              struct create_command_t {                  Stream::reference_t*     pExportReference,
45                  Stream::OrderID_t    OrderID;                  ::gig::DimensionRegion*  pRgn,
46                  Stream::Handle       hStream;                  unsigned long            SampleOffset,
47                  Stream::reference_t* pStreamRef;                  bool                     DoLoop
48                  ::gig::DimensionRegion* pDimRgn;              );
                 unsigned long        SampleOffset;  
                 bool                 DoLoop;  
             };  
             struct delete_command_t {  
                 Stream*           pStream;  
                 Stream::Handle    hStream;  
                 Stream::OrderID_t OrderID;  
                 bool              bNotify;  
             };  
             struct program_change_command_t {  
                 uint8_t Program;  
                 EngineChannel* pEngineChannel;  
             };  
             // Attributes  
             bool                           IsIdle;  
             uint                           Streams;  
             RingBuffer<create_command_t,false>* CreationQueue;                      ///< Contains commands to create streams  
             RingBuffer<delete_command_t,false>* DeletionQueue;                      ///< Contains commands to delete streams  
             RingBuffer<delete_command_t,false>* GhostQueue;                         ///< Contains handles to streams that are not used anymore and weren't deletable immediately  
             RingBuffer<Stream::Handle,false>    DeletionNotificationQueue;          ///< In case the original sender requested a notification for its stream deletion order, this queue will receive the handle of the respective stream once actually be deleted by the disk thread.  
             RingBuffer< ::gig::DimensionRegion*,false>* DeleteDimregQueue;          ///< Contains dimension regions that are not used anymore and should be handed back to the instrument resource manager  
             RingBuffer<program_change_command_t,false> ProgramChangeQueue;          ///< Contains requests for MIDI program change  
             unsigned int                   RefillStreamsPerRun;                    ///< How many streams should be refilled in each loop run  
             Stream**                       pStreams; ///< Contains all disk streams (whether used or unused)  
             Stream**                       pCreatedStreams; ///< This is where the voice (audio thread) picks up it's meanwhile hopefully created disk stream.  
             static Stream*                 SLOT_RESERVED;                          ///< This value is used to mark an entry in pCreatedStreams[] as reserved.  
             InstrumentResourceManager*     pInstruments;                           ///< The instrument resource manager of the engine that is using this disk thread. Used by the dimension region deletion feature.  
   
             // Methods  
             void                           CreateStream(create_command_t& Command);  
             void                           DeleteStream(delete_command_t& Command);  
             void                           RefillStreams();  
             Stream::Handle                 CreateHandle();  
             Stream::OrderID_t              CreateOrderID();  
49    
50              atomic_t ActiveStreamCount;          public:
51                DiskThread(int MaxStreams, uint BufferWrapElements, InstrumentResourceManager* pInstruments);
52                virtual ~DiskThread();
53      };      };
54    
55    
56  }} // namespace LinuxSampler::gig  }} // namespace LinuxSampler::gig
57    
58  #endif // __LS_GIG_DISKTHREAD_H__  #endif  /* __LS_GIG_STREAM_H__ */
59    
Legend:
Removed from v.2011  
changed lines
  Added in v.2012
  ViewVC Help
Powered by ViewVC