# Source: alsaout.h |
Annotated List
Files
Globals
Hierarchy
Index

    /*  alsaout.cc   - class AlsaOut which represents an alsa client/port pair
        This file is part of LibKMid 0.9.5
        Copyright (C) 1997,98,99,2000  Antonio Larrosa Jimenez
        LibKMid's homepage : http://www.arrakis.es/~rlarrosa/libkmid.html

        This library is free software; you can redistribute it and/or
        modify it under the terms of the GNU Library General Public
        License as published by the Free Software Foundation; either
        version 2 of the License, or (at your option) any later version.

        This library 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
        Library General Public License for more details.

        You should have received a copy of the GNU Library General Public License
        along with this library; see the file COPYING.LIB.  If not, write to
        the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
        Boston, MA 02111-1307, USA.

        Send comments and bug fixes to Antonio Larrosa <larrosa@kde.org>

    ***************************************************************************/
    #ifndef _ALSAOUT_H
    #define _ALSAOUT_H

    #include <libkmid/midiout.h>

    #ifdef HAVE_CONFIG_H
    #include <config.h>
    #endif

    struct snd_seq_event;
    typedef struct snd_seq_event snd_seq_event_t;

    /**
     * @short Sends MIDI events to a MIDI devices using ALSA
     * @version 0.9.5 17/01/2000
     * @author Antonio Larrosa Jimenez <larrosa@kde.org>
     */
    class AlsaOut : public MidiOut
    {
      friend class DeviceManager;

      protected:

    /**
     * @internal
     * Total number of devices.
     */
      int ndevs;

    /**
     * @internal
     * Total number of midi ports
     */
      int nmidiports;

      double count;
      double lastcount;
      double lasttime;
      double begintime;
      int m_rate;

    /**
     * @internal
     * A "constant" used to convert from milliseconds to the computer rate
     */
      double convertrate;

      long int time;

      virtual void seqbuf_dump (void);
      virtual void seqbuf_clean(void);
      void eventInit(snd_seq_event_t *ev);
      void eventSend(snd_seq_event_t *ep);
      void timerEventSend(int type);

      public:

      /**
       * Constructor. After constructing a MidiOut device, you must open it
       * (using @ref #openDev() ). Additionally you may want to initialize it
       * (with @ref #initDev() ),
       */
      AlsaOut(int d, int client=64, int port=0, const char *cname="", const char *pname="");

      /**
       * Destructor. It doesn't matter if you close the device (@ref closeDev() )
       * before you destruct the object because in other case, it will be closed
       * here.
       */
      virtual ~AlsaOut();

      /**
       * Opens the device. This is generally called from @ref DeviceManager , so you
       * shouldn't call this yourself (except if you created the MidiOut object
       * yourself.
       * @param sqfd a file descriptor of /dev/sequencer
       * @see #closeDev
       * @see #initDev
       */
      virtual void openDev	(int sqfd);

      /**
       * Closes the device. It basically tells the device (the file descriptor)
       * is going to be closed.
       * @see #openDev
       */
      virtual void closeDev	();

      /**
       * Initializes the device sending generic standard midi events and controllers,
       * such as changing the patches of each channel to an Acoustic Piano (000),
       * setting the volume to a normal value, etc.
       */
      virtual void initDev	();

      /**
       * @return the device type of the object. This is to identify the
       * inherited class that a given object is polymorphed to.
       * The returned value is one of these :
       *
       * @li KMID_EXTERNAL_MIDI if it's a @ref MidiOut object
       * @li KMID_SYNTH if it's a @ref SynthOut object (as an AWE device)
       * @li KMID_FM if it's a @ref FMOut object
       * @li KMID_GUS if it's a @ref GUSOut object
       *
       * which are defined in midispec.h
       *
       * @see #deviceName
       */
      int          deviceType () const { return devicetype; };

      /**
       * Returns the name and type of this MIDI device.
       * @see #deviceType
       */
      virtual const char * deviceName (void) const;

      /**
       * @internal
       */
      int  rate    (void) { return m_rate; };

      /**
       * See @ref DeviceManager::noteOn()
       */
      virtual void noteOn	( uchar chn, uchar note, uchar vel );

      /**
       * See @ref DeviceManager::noteOff()
       */
      virtual void noteOff	( uchar chn, uchar note, uchar vel );

      /**
       * See @ref DeviceManager::keyPressure()
       */
      virtual void keyPressure	( uchar chn, uchar note, uchar vel );

      /**
       * See @ref DeviceManager::chnPatchChange()
       */
      virtual void chnPatchChange	( uchar chn, uchar patch );

      /**
       * See @ref DeviceManager::chnPressure()
       */
      virtual void chnPressure	( uchar chn, uchar vel );

      /**
       * See @ref DeviceManager::chnPitchBender()
       */
      virtual void chnPitchBender	( uchar chn, uchar lsb,  uchar msb );

      /**
       * See @ref DeviceManager::chnController()
       */
      virtual void chnController	( uchar chn, uchar ctl , uchar v );

      /**
       * See @ref DeviceManager::sysex()
       */
      virtual void sysex		( uchar *data,ulong size);

      /**
       * Mutes all notes being played on a given channel.
       */
      virtual void channelSilence	( uchar chn );

      /**
       * Mute or "unmute" a given channel .
       * @param chn channel to work on
       * @param b if true, the device will ignore subsequent notes played on the chn
       * channel, and mute all notes being played on it. If b is false, the channel
       * is back to work.
       */
      virtual void channelMute	( uchar chn, int a );

      /**
       * Change all channel volume events multiplying it by this percentage correction
       * Instead of forcing a channel to a fixed volume, this method allows to
       * music to fade out even when it was being played softly.
       * @param volper is an integer value, where 0 is quiet, 100 is used to send
       * an unmodified value, 200 play music twice louder than it should, etc.
       */
      virtual void setVolumePercentage ( int volper )
      { volumepercentage = volper; };

      /**
       * Returns true if everything's ok and false if there has been any problem
       */
      int ok (void)
      { if (seqfd<0) return 0;
        return (_ok>0);
      };

      virtual void wait        (double ticks);
      virtual void tmrSetTempo (int v);
      virtual void tmrStart    (int tpcn);
      virtual void tmrStart    () { tmrStart(-1); }
      virtual void tmrStop     ();
      virtual void tmrContinue ();
      /**
       * @internal
       * If i==1 syncronizes by cleaning the buffer instead of sending it (in fact,
       * this is what syncronizing really means :-) )
       */
      virtual void sync        (int i=0);

      class AlsaOutPrivate;
      AlsaOutPrivate *di;
    };

    #endif // _ALSAOUT_H

Generated by: root@sparc.ports.openbsd.org on Wed May 2 09:49:53 2001, using kdoc 2.0a53.