Question

I have problems with compiling file Mutex.h -> It belongs to library STK (Synthesis Toolkit C++).

I’ve just included files, that I needed (“RtWvOut.h”, Mutex.h/cpp, Stk.h/cpp, WvOut.h)
and during the compiling the following problems disapeared.
Thanks for your answers 🙂

---

d:\kari\Mutex.h:67: Error:C2146: syntax error : missing ‘;’ before identifier ‘mutex_’
d:\kari\Mutex.h:67: Error:C4430: missing type specifier – int assumed. Note: C++ does not support default-int
d:\kari\Mutex.h:68: Error:C2146: syntax error : missing ‘;’ before identifier ‘condition_’
d:\kari\Mutex.h:68: Error:C4430: missing type specifier – int assumed. Note: C++ does not support default-int

---

here is code of Mutex.h

    #ifndef STK_MUTEX_H
    #define STK_MUTEX_H

    #include "Stk.h"

    #if (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__)){

      #include <pthread.h>
      typedef pthread_mutex_t MUTEX;
      typedef pthread_cond_t CONDITION;
    }
    #elif defined(__OS_WINDOWS__){

      #include <windows.h>
      #include <process.h>
      typedef CRITICAL_SECTION MUTEX;
      typedef HANDLE CONDITION;
    }
    #endif

    namespace stk {

    /**************************************************/
    /*! \class Mutex
        \brief STK mutex class.

        This class provides a uniform interface for
        cross-platform mutex use.  On Linux and IRIX
        systems, the pthread library is used. Under
        Windows, critical sections are used.

        by Perry R. Cook and Gary P. Scavone, 1995-2011.
    */
    /***************************************************/

    class Mutex : public Stk
    {
     public:
      //! Default constructor.
      Mutex();

      //! Class destructor.
      ~Mutex();

      //! Lock the mutex.
      void lock(void);

      //! Unlock the mutex.
      void unlock(void);

      //! Wait indefinitely on the mutex condition variable.
      /*!
        The mutex must be locked before calling this function, and then
        subsequently unlocked after this function returns.
       */
      void wait(void);

      //! Signal the condition variable.
      /*!
        The mutex must be locked before calling this function, and then
                subsequently unlocked after this function returns.
       */
      void signal(void);

    protected:

     MUTEX mutex_;                    ##################x LINE 67
     CONDITION condition_;            ##################  LINE 68

    };
    } // stk namespace
    #endif

---

and code for Mutex.cpp

/***************************************************/
/*! \class Mutex
    \brief STK mutex class.

    This class provides a uniform interface for
    cross-platform mutex use.  On Linux and IRIX
    systems, the pthread library is used. Under
    Windows, critical sections are used.

    by Perry R. Cook and Gary P. Scavone, 1995-2011.
*/
/***************************************************/

#include "Mutex.h"

namespace stk {

Mutex :: Mutex()
{

#if (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__))

  pthread_mutex_init(&mutex_, NULL);
  pthread_cond_init(&condition_, NULL);

#elif defined(__OS_WINDOWS__)

  InitializeCriticalSection(&mutex_);
  condition_ = CreateEvent(NULL,  // no security
                           true,  // manual-reset
                           false, // non-signaled initially
                           NULL); // unnamed

#endif 
}

Mutex :: ~Mutex()
{
#if (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__))

  pthread_mutex_destroy(&mutex_);
  pthread_cond_destroy(&condition_);

#elif defined(__OS_WINDOWS__)

  DeleteCriticalSection(&mutex_);
  CloseHandle( condition_ );

#endif 
}

void Mutex :: lock()
{
#if (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__))

  pthread_mutex_lock(&mutex_);

#elif defined(__OS_WINDOWS__)

  EnterCriticalSection(&mutex_);

#endif 
}

void Mutex :: unlock()
{
#if (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__))

  pthread_mutex_unlock(&mutex_);

#elif defined(__OS_WINDOWS__)

  LeaveCriticalSection(&mutex_);

#endif 
}

void Mutex :: wait()
{
#if (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__))

  pthread_cond_wait(&condition_, &mutex_);

#elif defined(__OS_WINDOWS__)

  WaitForMultipleObjects(1, &condition_, false, INFINITE);

#endif 
}

void Mutex :: signal()
{
#if (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__))

  pthread_cond_signal(&condition_);

#elif defined(__OS_WINDOWS__)

  SetEvent( condition_ );

#endif 
}
} // stk namespace

---

and code, where is Mutex.h included: (RtWvOut.h)

#ifndef STK_RTWVOUT_H
#define STK_RTWVOUT_H

#include "WvOut.h"
#include "RtAudio.h"
#include "Mutex.h"

namespace stk {

/***************************************************/
/*! \class RtWvOut
    \brief STK realtime audio (blocking) output class.

    This class provides a simplified interface to RtAudio for realtime
    audio output.  It is a subclass of WvOut.  This class makes use of
    RtAudio's callback functionality by creating a large ring-buffer
    into which data is written.  This class should not be used when
    low-latency is desired.

    RtWvOut supports multi-channel data in interleaved format.  It is
    important to distinguish the tick() method that outputs a single
    sample to all channels in a sample frame from the overloaded one
    that takes a reference to an StkFrames object for multi-channel
    and/or multi-frame data.

    by Perry R. Cook and Gary P. Scavone, 1995-2011.
*/
/***************************************************/

class RtWvOut : public WvOut
{
 public:

  //! Default constructor.
  /*!
    The default \e device argument value (zero) will select the
    default output device on your system.  The first device enumerated
    by the underlying audio API is specified with a value of one.  The
    default buffer size of RT_BUFFER_SIZE is defined in Stk.h.  An
    StkError will be thrown if an error occurs duing instantiation.
  */
  RtWvOut( unsigned int nChannels = 1, StkFloat sampleRate = Stk::sampleRate(),
           int device = 0, int bufferFrames = RT_BUFFER_SIZE, int nBuffers = 20 );

  //! Class destructor.
  ~RtWvOut();

  //! Start the audio output stream.
  /*!
    The stream is started automatically, if necessary, when a
    tick() method is called.
  */
  void start( void );

  //! Stop the audio output stream.
  /*!
    It may be necessary to use this method to avoid undesireable
    audio buffer cycling if you wish to temporarily stop audio output.
  */
  void stop( void );

  //! Output a single sample to all channels in a sample frame.
  /*!
    If the device is "stopped", it is "started".
  */
  void tick( const StkFloat sample );

  //! Output the StkFrames data.
  /*!
    If the device is "stopped", it is "started".  The number of
    channels in the StkFrames argument must equal the number of
    channels specified during instantiation.  However, this is only
    checked if _STK_DEBUG_ is defined during compilation, in which
    case an incompatibility will trigger an StkError exception.
  */
  void tick( const StkFrames& frames );

  // This function is not intended for general use but must be
  // public for access from the audio callback function.
  int readBuffer( void *buffer, unsigned int frameCount );

 protected:

  RtAudio dac_;
  Mutex mutex_;
  bool stopped_;
  unsigned int readIndex_;
  unsigned int writeIndex_;
  long framesFilled_;
  unsigned int status_; // running = 0, emptying buffer = 1, finished = 2

};

} // stk namespace

#endif

Answer 1

Did you tell it what platform it’s running on? If you look at this line of code:

#if (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__)){

You can see, that it needs to be told somehow. Something must define the appropriate __OS_... flag.