WAAVE.h

#ifndef WAAVE_LIBRARY_H
#define WAAVE_LIBRARY_H


#include <libavutil/pixfmt.h>
#include <stdint.h>
#include <SDL.h>


#ifdef __cplusplus
extern "C" {
#endif


/*||||||||||||||||||||||||||||||||||||*/
/*                                    */
/*         THE STREAMING OBJECT       */
/*                                    */
/*||||||||||||||||||||||||||||||||||||*/


/* the get buffer method */
//the buffers doesn't change, get is used one time per slot
#define WV_STATIC_GET 0
//we need to get buffer each time we decode a frame   
#define WV_DYNAMIC_GET 1  

/* the Get/Lock/Release method */
//just after the frame was displayed we reload the slot
#define WV_SYNC_GLR  0  
//we load the slot just before the next slot was displayed
#define WV_ASYNC_GLR 1  

/* Get/Lock/Release thread safety */
//the function is thread safe
#define WV_THREAD_SAFE 1    
//the function is not thread safe
#define WV_NO_THREAD_SAFE 0 


typedef struct WVStreamingBuffer{
  
  int width;               
  int height;              
  enum PixelFormat format; 
  uint8_t* data[4];   

  int linesize[4];

}WVStreamingBuffer;



typedef struct WVStreamingObject{
  
  int srcWidth;
  
  int srcHeight;

  enum PixelFormat srcFormat;  //ffmpeg src format 
  

  int nbSlots;


  int getBufferMethod;  //STATIC or DYNAMIC


  int GLRMethod;        //SYNC or ASYNC get/lock/release
  
  int getThreadSafety;  //get thread safety



  int LRThreadSafety;   //Lock and release thread safety
  

  int (*init)(struct WVStreamingObject* streamObj);

  WVStreamingBuffer (*getBuffer)(struct WVStreamingObject* streamObj, int slotIdx);

  int (*lockBuffer)(struct WVStreamingObject* streamObj, int slotIdx);



  int (*filterBuffer)(struct WVStreamingObject* streamObj, int slotIdx, WVStreamingBuffer* buffer);
  


  int (*releaseBuffer)(struct WVStreamingObject* streamObj, int slotIdx);

  int (*refreshFrame)(struct WVStreamingObject* streamObj, int slotIdx);

  

  int (*close)(struct WVStreamingObject* streamObj);


  /****************/
  /* private data */
  /****************/
  
  void* objPrivate;

}WVStreamingObject;



  







/*|||||||||||||||||||||||||||||||||*/
/*                                 */
/*        THE SYNC OBJECT          */
/*                                 */
/*|||||||||||||||||||||||||||||||||*/


/*****************************/
/* the clock data structure  */
/*****************************/

typedef struct WVReferenceClock{
  
  uint32_t clock;

  int pauseFlag;    
  
  int modIdx;       

}WVReferenceClock;




/* we have two way for seeking */
//if the clock is paused, seek cause restart playing
#define WV_PLAYING_SEEK 0
//if the clock is paused, it stay paused after the seek
#define WV_BLOCKING_SEEK 1

/* we have two way for thread EOF */
// if clock reach stream end, pause */
#define WV_BLOCKING_STREAM 0
// if clock reach stream end, loop */
#define WV_LOOPING_STREAM 1





/*******************/
/* the sync object */
/*******************/

typedef struct WVSyncObject{
  
  /************/
  /* EOF FLAG */
  /************/
  
  int loopingFlag;

  
  /*************/
  /* SLAVE DEF */
  /*************/

  void (*signalStateChange)(struct WVSyncObject* sync); 

  /**************/
  /* MASTER DEF */
  /**************/

  /* !!! getRefClock and play are mandatory !!! */
  /* !!! signalStateChange for play and seek but not for pause !!! */ 

  /* GETREFCLOCK */
  
  void (*getRefClock)(struct WVSyncObject* sync, WVReferenceClock* refClock); 

  
  /* PLAY */

  int (*play)(struct WVSyncObject* sync);


  /* PAUSE */
  
  int (*pause)(struct WVSyncObject* sync);

  
  /* SEEK */
  
  int (*seek)(struct WVSyncObject* sync, uint32_t clock, int seekFlag);
  

  /***********/
  /* PRIVATE */
  /***********/

  void* objPrivate;            //private vars for the methods
  
  void* wvStdPrivate;    


}WVSyncObject;





/*|||||||||||||||||||||||||||||||||||||||||||*/
/*                                           */
/*          THE STREAM PARAMETERS            */
/*                                           */
/*|||||||||||||||||||||||||||||||||||||||||||*/

/* the stream type */
#define WV_STREAM_TYPE_NONE 0
#define WV_STREAM_TYPE_AUDIO 1
#define WV_STREAM_TYPE_VIDEO 2
#define WV_STREAM_TYPE_AUDIOVIDEO 3

/* the play method */
#define WV_NEUTRAL_PLAY 0
#define WV_LOOPING_PLAY 1

/* the seek method */
#define WV_SEEK_BACKWARD -1
#define WV_SEEK_FORWARD 1


/* the stream struct */
struct WVStream;
typedef struct WVStream  WVStream;

/* to signal eof */
typedef  int (*WVEOFSignalCall)(struct WVStream* stream, void* param);


#define WAAVE_INIT_NONE 0
#define WAAVE_INIT_AUDIO 1
#define WAAVE_INIT_VIDEO 2



/*|||||||||||||||||||||||||||||||||||||||||||*/
/*                                           */
/*             THE WAAVE API                 */
/*                                           */
/*|||||||||||||||||||||||||||||||||||||||||||*/



/***********************************/
/* Start and stop the Waave engine */
/***********************************/

int WV_waaveInit(int flag);


int WV_waaveClose(void);


/***********************/
/* Stream manipulation */
/***********************/

WVStream* WV_getStream(const char* filename);


WVStream* WV_closeStream(WVStream* stream);


int WV_getStreamType(WVStream* stream);

int WV_getStreamWidth(WVStream* stream);

int WV_getStreamHeight(WVStream* stream);


int WV_loadStream(WVStream* stream);


/************************/
/* Display video frames */
/************************/

/* the default WV_REFRESH_EVENT value */
#if SDL_VERSION_ATLEAST(2,0,0)

extern int dynamic_wv_refresh_event;  //dynamic, see waave_engine_flags.c
#define WV_REFRESH_EVENT dynamic_wv_refresh_event

#else

#define WV_REFRESH_EVENT SDL_NUMEVENTS - 1

#endif


void WV_refreshVideoFrame(SDL_Event* refreshEvent);

/*************************/
/* Set stream parameters */
/*************************/


int WV_disableAudio(WVStream* stream);

int WV_disableVideo(WVStream* stream);

int WV_setPlayMethod(WVStream* stream, int playFlag);



int WV_setSeekMethod(WVStream* stream, int seekFlag);


/* the eof signal */
#if SDL_VERSION_ATLEAST(2,0,0)

extern int dynamic_wv_eof_event;  //dynamic, see waave_engine_flags.c
#define WV_EOF_EVENT dynamic_wv_eof_event

#else

#define WV_EOF_EVENT SDL_NUMEVENTS - 2

#endif


int WV_setEOFMethod(WVStream* stream, int loopingFlag);



int WV_setStreamingMethod(WVStream* stream, WVStreamingObject* streamObj);



 WVStreamingObject* WV_getStreamingMethod(WVStream* stream);


int WV_setSyncMethod(WVStream* stream, WVSyncObject* syncObj);


 WVSyncObject* WV_getSyncMethod(WVStream* stream);


int WV_setEOFSignalParam(WVStream* stream, void* param);


int WV_setEOFSignalCall(WVStream* stream, WVEOFSignalCall eofCall);


int WV_setVolumeDBPitche(WVStream* stream, double DBPitche);


double WV_getVolumeDBPitche(WVStream* stream);

/***************************/
/* Stream playback control */
/***************************/

int WV_playStream(WVStream* stream);


int WV_pauseStream(WVStream* stream);


int WV_stopStream(WVStream* stream);


int WV_rewindStream(WVStream* stream);


int WV_rseekStream(WVStream* stream, uint32_t seekShift, int seekDirection);


int WV_seekStream(WVStream* stream, uint32_t clock);


uint32_t WV_getStreamDuration(WVStream* stream);


uint32_t WV_getStreamClock(WVStream* stream);


/*************************/
/* Stream volume control */
/*************************/

int WV_setVolume(WVStream* stream, double volume);


  double WV_getVolume(WVStream* stream);


int WV_setDBVolume(WVStream* stream, int DBVolume);


int WV_getDBVolume(WVStream* stream);


int WV_shiftDBVolume(WVStream* stream, int shift);


/**************************************/
/* Standard SDL 1.2 streaming objects */
/**************************************/

//#if !SDL_VERSION_ATLEAST(2,0,0)

  /****************/
  /*   overlays   */
  /****************/

WVStreamingObject* WV_getStreamOverlayObj(SDL_Surface* targetSurface, SDL_Rect* destRect);

void WV_resetStreamOverlayOutput(WVStreamingObject* streamObj, SDL_Surface* targetSurface, SDL_Rect* destRect);



void WV_freeStreamOverlayObj(WVStreamingObject* streamObj);



  /****************/
  /*   surface    */
  /****************/

WVStreamingObject* WV_getStreamSurfaceObj(SDL_Surface* targetSurface, SDL_Rect* destRect, int updateFlag);

void WV_resetStreamSurfaceOutput(WVStreamingObject* streamObj, SDL_Surface* targetSurface, SDL_Rect* destRect);


void WV_freeStreamSurfaceObj(WVStreamingObject* streamObj);





  //#endif

/**************************************/
/* Standard SDL 2.0 streaming objects */
/**************************************/

//#if SDL_VERSION_ATLEAST(2,0,0)


  WVStreamingObject* WV_getStreamRendererObj(SDL_Renderer* targetRenderer, SDL_Rect* destRect, int updateFlag);


void WV_resetStreamRendererOutput(WVStreamingObject* streamObj, SDL_Renderer* targetRenderer, SDL_Rect* destRect);



void WV_freeStreamRendererObj(WVStreamingObject* streamObj);

  //#endif

#ifdef __cplusplus
}
#endif


#endif