~ubuntu-branches/ubuntu/wily/muse/wily-proposed

//  $Id: track.h,v 1.39.2.17 2009/12/20 05:00:35 terminator356 Exp $

//

//  (C) Copyright 1999-2004 Werner Schweer (ws@seh.de)

//=========================================================

 

#ifndef __TRACK_H__

#include "route.h"

#include "ctrl.h"

#include "globaldefs.h"

 

class Pipeline;

class SndFile;

class SynthI;

 

//---------------------------------------------------------

//   Track

      static bool _tmpSoloChainDoIns;

      static bool _tmpSoloChainNoDec;

      

      RouteList _inRoutes;

      RouteList _outRoutes;

      

      QString _name;

      bool _recordFlag;

      

      int _activity;

      int _lastActivity;

      double _meter[MAX_CHANNELS];

      double _peak[MAX_CHANNELS];

 

      Track(TrackType);

      //Track(const Track&);

      Track(const Track&, bool cloneParts);

      virtual Track& operator=(const Track& t);

      

      static const char* _cname[];

      bool noInRoute() const   { return _inRoutes.empty();  }

      bool noOutRoute() const  { return _outRoutes.empty(); }

      void writeRouting(int, Xml&) const;

      PartList* parts()               { return &_parts; }

      const PartList* cparts() const  { return &_parts; }

      Part* findPart(unsigned tick);

 

      virtual void setMute(bool val);

      virtual void setOff(bool val);

      void setInternalSolo(unsigned int val);

      virtual void setSolo(bool val) = 0;

      virtual bool isMute() const = 0;

      unsigned int internalSolo() const  { return _internalSolo; }

      bool soloMode() const              { return _soloRefCnt; }

      bool solo() const                  { return _solo;         }

      bool mute() const                  { return _mute;         }

      bool off() const                   { return _off;          }

      bool recordFlag() const            { return _recordFlag;   }

 

      int activity()                     { return _activity;     }

      void setActivity(int v)            { _activity = v;        }

      void addActivity(int v)            { _activity += v;       }

      void resetPeaks();

      static void resetAllMeter();

      double meter(int ch) const  { return _meter[ch]; }

      double peak(int ch) const   { return _peak[ch]; }

      void resetMeter();

      virtual AutomationType automationType() const    = 0;

      virtual void setAutomationType(AutomationType t) = 0;

      static void setVisible(bool ) { }

 

      };

 

      int _outPort;

      int _outChannel;

      //int _inPortMask;        

 

      EventList* _events;     // tmp Events during midi import

      MPEventList* _mpevents; // tmp Events druring recording

      static bool _isVisible;

 

   public:

      MidiTrack();

      void setOutPortAndChannelAndUpdate(int /*port*/, int /*chan*/);

      

      //void setInPortMask(int i)       { _inPortMask = i; }

      // Backward compatibility: For reading old songs.

      void setInPortAndChannelMask(unsigned int /*portmask*/, int /*chanmask*/); 

      

      void setRecEcho(bool b)         { _recEcho = b; }

      int outPort() const             { return _outPort;     }

      //int inPortMask() const          { return _inPortMask;  }

      int outChannel() const          { return _outChannel;  }

      bool recEcho() const            { return _recEcho; }

 

      virtual bool isMute() const;

      virtual bool canRecord() const  { return true; }

      static void setVisible(bool t) { _isVisible = t; }

      static bool visible() { return _isVisible; }

      };

 

//---------------------------------------------------------

//   AudioTrack

//    this track can hold audio automation data and can

//    AUDIO_INPUT, AUDIO_SOFTSYNTH, AUDIO_AUX

//---------------------------------------------------------

 

      //friend class MidiTrack;

      //static unsigned int _soloRefCnt;

      

      

      CtrlListList _controller;

      CtrlRecList _recEvents;     // recorded automation events

 

      bool _prefader;               // prefader metering

      std::vector<double> _auxSend;

      //void readRecfile(Xml& xml);

      void readAuxSend(Xml& xml);

 

   protected:

      float** outBuffers;

      SndFile* _recFile;

      Fifo fifo;                    // fifo -> _recFile

      bool _processed;

   public:

      AudioTrack(TrackType t);

      //AudioTrack(TrackType t, int num_out_bufs = MAX_CHANNELS); 

      void readVolume(Xml& xml);

      //void writeRouting(int, Xml&) const;

 

      virtual void preProcessAlways() { _processed = false; }

      virtual void  addData(unsigned /*samplePos*/, int /*channels*/, int /*srcStartChan*/, int /*srcChannels*/, unsigned /*frames*/, float** /*buffer*/);

      virtual void copyData(unsigned /*samplePos*/, int /*channels*/, int /*srcStartChan*/, int /*srcChannels*/, unsigned /*frames*/, float** /*buffer*/);

      void eraseACEvent(int, int);

      void eraseRangeACEvents(int, int, int);

      void addACEvent(int, int, double);

      };

 

//---------------------------------------------------------

      static bool visible() { return _isVisible; }

    };

 

//---------------------------------------------------------

//   WaveTrack

//---------------------------------------------------------

extern void addPortCtrlEvents(MidiTrack* t);

extern void removePortCtrlEvents(MidiTrack* t);

 

#endif