Public API Reference

csplugincommon/sndsys/sndstream.h

/*
    Copyright (C) 2006 by Andrew Mann

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

    You should have received a copy of the GNU General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/



#ifndef SNDSTREAM_H
#define SNDSTREAM_H

#include "iutil/databuff.h"
#include "isndsys/ss_structs.h"
#include "isndsys/ss_stream.h"
#include "csplugincommon/sndsys/convert.h"
#include "csplugincommon/sndsys/cyclicbuf.h"
#include "csplugincommon/sndsys/queue.h"
#include "csutil/refarr.h"
#include "csutil/scf_implementation.h"


namespace CS
{
  namespace SndSys
  {

  class CS_CRYSTALSPACE_EXPORT SndSysBasicStream :
    public scfImplementation1<SndSysBasicStream, iSndSysStream>
  {
  public:
    SndSysBasicStream(csSndSysSoundFormat *pRenderFormat, int Mode3D);
    virtual ~SndSysBasicStream();

    static const size_t InvalidPosition = (size_t)~0;

    // Structure/enum definitions

    typedef enum
    {
      STREAM_NOTIFY_PAUSED=0,
      STREAM_NOTIFY_UNPAUSED,
      STREAM_NOTIFY_LOOP,
      STREAM_NOTIFY_FRAME
    } StreamNotificationType;

    struct StreamNotificationEvent
    {
      StreamNotificationType m_Type;
      //    This is currently only valid for 
      //    STREAM_NOTIFY_FRAME event types
      size_t m_Frame;
    };


    // Interface implementation

    //------------------------
    // iSndSysStream
    //------------------------
  public:

    virtual const char *GetDescription() = 0;

    virtual const csSndSysSoundFormat *GetRenderedFormat();

    virtual int Get3dMode();

    virtual size_t GetFrameCount() = 0;


    virtual size_t GetPosition();

    virtual bool ResetPosition();

    virtual bool SetPosition (size_t newposition);

    virtual bool Pause();

    virtual bool Unpause();

    virtual int GetPauseState();

    virtual bool SetLoopState(int loopstate);

    virtual int GetLoopState();

    virtual void SetPlayRatePercent(int percent);

    virtual int GetPlayRatePercent();

    virtual void SetAutoUnregister(bool autounreg);

    virtual bool GetAutoUnregister();

    virtual bool GetAutoUnregisterRequested();

    virtual void AdvancePosition(size_t frame_delta) = 0;

    virtual void GetDataPointers (size_t *position_marker, size_t max_requested_length,
      void **buffer1, size_t *buffer1_bytes, void **buffer2, size_t *buffer2_bytes);

    virtual void InitializeSourcePositionMarker (size_t* position_marker);

    virtual void ProcessNotifications();


    virtual bool RegisterCallback(iSndSysStreamCallback *pCallback);

    virtual bool UnregisterCallback(iSndSysStreamCallback *pCallback);

    //   it's crossed.
    virtual bool RegisterFrameNotification(size_t frame_number);

    // Internal functions
  protected:
    //
    size_t CopyBufferBytes (size_t max_dest_bytes);

    void QueueNotificationEvent(StreamNotificationType NotifyType, size_t FrameNum);


    //  Member variables
  protected:
    csSndSysSoundFormat m_RenderFormat;

    //
    //  The cyclic buffer is used to hold recently decoded sound.  It 
    //   provides functionality which allows us to add new data at any point
    //   without a lot of excess copying.
    SoundCyclicBuffer *m_pCyclicBuffer;

    bool m_bPaused;

    //   of the data?
    bool m_bLooping;

    //
    //  This is set to true once we have completed reading the underlying data
    //   only if we are not looping. If we are looping, then we'll just start
    //   back at the beginning of the data and we will never be finished reading.
    bool m_bPlaybackReadComplete;

    //   furthest ahead in reading.
    size_t m_MostAdvancedReadPointer;

    size_t m_NewPosition;

    PCMSampleConverter *m_pPCMConverter;

    //   for addition to the cyclic buffer.
    char *m_pPreparedDataBuffer;

    int m_PreparedDataBufferSize;

    size_t m_PreparedDataBufferUsage;

    //   data buffer
    size_t m_PreparedDataBufferStart;

    int m_RenderFrameSize;

    int m_PlaybackPercent;

    int m_OutputFrequency;

    int m_NewOutputFrequency;

    int m_3DMode;

    bool m_bAutoUnregisterRequested;

    bool m_bAutoUnregisterReady;

    csRefArray<iSndSysStreamCallback> m_CallbackList;

    Queue<StreamNotificationEvent> m_NotificationQueue;
  };


 }
 // END namespace CS::SndSys
}
// END namespace CS




#endif // #ifndef SNDSTREAM_H

---