• Main Page
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

remix_plugin.h

Go to the documentation of this file.
00001 /*
00002  * libremix -- An audio mixing and sequencing library.
00003  *
00004  * Copyright (C) 2001 Commonwealth Scientific and Industrial Research
00005  * Organisation (CSIRO), Australia.
00006  *
00007  * This library is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2 of the License, or (at your option) any later version.
00011  *
00012  * This library is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with this library; if not, write to the Free Software
00019  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00020  *
00021  */
00022 
00023 /*
00024  * remix_plugin.h -- libremix internal data types and functions.
00025  *
00026  * Conrad Parker <conrad@metadecks.org>, August 2001
00027  */
00028 
00029 #ifndef __REMIX_PLUGIN_H__
00030 #define __REMIX_PLUGIN_H__
00031 
00032 /*#define DEBUG*/
00033 
00034 #if defined(__REMIX_PLUGIN__) || defined(__REMIX__)
00035 
00036 #include <stdio.h>
00037 
00038 #include "ctxdata.h"
00039 
00040 #define REMIX_PLUGIN_API_MAJOR 1
00041 #define REMIX_PLUGIN_API_MINOR 0
00042 #define REMIX_PLUGIN_API_REVISION 0
00043 
00044 typedef struct _RemixMetaAuthor RemixMetaAuthor;
00045 typedef struct _RemixMetaText RemixMetaText;
00046 
00047 typedef struct _RemixParameterScheme RemixParameterScheme;
00048 typedef struct _RemixParameterRange RemixParameterRange;
00049 
00050 typedef struct _RemixNamedParameter RemixNamedParameter;
00051 
00052 typedef union _RemixConstraint RemixConstraint;
00053 
00054 typedef struct _RemixMethods RemixMethods;;
00055 
00056 #define REMIX_PLUGIN_WRITEABLE 1<<0
00057 #define REMIX_PLUGIN_SEEKABLE  1<<1
00058 #define REMIX_PLUGIN_CACHEABLE 1<<2
00059 #define REMIX_PLUGIN_CAUSAL    1<<3
00060 
00061 /* A base of a plugin */
00062 typedef struct _RemixPlugin RemixPlugin;
00063 /*typedef struct _RemixBase * RemixBase;*/
00064 
00065 typedef struct _RemixChunk RemixChunk;
00066 
00067 #if defined (__REMIX__)
00068 #include "remix_private.h"
00069 #else
00070 typedef RemixOpaque RemixEnv;
00071 typedef RemixOpaque RemixPoint;
00072 typedef RemixOpaque RemixEnvelope;
00073 typedef RemixOpaque RemixStream;
00074 typedef RemixOpaque RemixChannel;
00075 typedef RemixOpaque RemixDeck;
00076 typedef RemixOpaque RemixTrack;
00077 typedef RemixOpaque RemixLayer;
00078 typedef RemixOpaque RemixSound;
00079 typedef RemixOpaque RemixSquareTone;
00080 typedef RemixOpaque RemixMonitor;
00081 #endif
00082 
00083 
00084 typedef CDList * (*RemixPluginInitFunc) (RemixEnv * env);
00085 typedef int (*RemixPluginDestroyFunc) (RemixEnv * env, RemixPlugin * plugin);
00086 
00087 typedef RemixBase * (*RemixInitFunc) (RemixEnv * env, RemixBase * base,
00088                                       CDSet * parameters);
00089 
00090 typedef CDSet * (*RemixSuggestFunc) (RemixEnv * env, RemixPlugin * plugin,
00091                                      CDSet * parameters,
00092                                      void * plugin_data);
00093 
00094 typedef RemixBase * (*RemixCloneFunc) (RemixEnv * env, RemixBase * base);
00095 typedef int (*RemixDestroyFunc) (RemixEnv * env, RemixBase * base);
00096 typedef int (*RemixReadyFunc) (RemixEnv * env, RemixBase * base);
00097 typedef RemixBase * (*RemixPrepareFunc) (RemixEnv * env, RemixBase * base);
00098 typedef RemixCount (*RemixSeekFunc) (RemixEnv * env, RemixBase * base,
00099                                      RemixCount count);
00100 typedef RemixCount (*RemixLengthFunc) (RemixEnv * env, RemixBase * base);
00101 typedef RemixCount (*RemixProcessFunc) (RemixEnv * env, RemixBase * base,
00102                                         RemixCount count,
00103                                         RemixStream * input,
00104                                         RemixStream * output);
00105 typedef int (*RemixFlushFunc) (RemixEnv * env, RemixBase * base);
00106 
00107 #define REMIX_FLAGS_NONE (0)
00108 
00109 #define REMIX_AUTHOR(n,e) ((struct _RemixMetaAuthor){(n),(e)})
00110 #define REMIX_ONE_AUTHOR(n,e) CD_SINGLETON_LIST(CD_POINTER(&(REMIX_AUTHOR((n),(e)))))
00111 
00112 /* ChunkChunkFuncs and all the rest */
00113 
00114 /* RemixChunkFunc: a function to apply to one chunk */
00115 typedef RemixCount (*RemixChunkFunc) (RemixEnv * env, RemixChunk * chunk,
00116                                       RemixCount offset,
00117                                       RemixCount count, int channelname,
00118                                       void * data);
00119 
00120 /* RemixChunkChunkFunc: a function to apply between two chunks :) */
00121 typedef RemixCount (*RemixChunkChunkFunc) (RemixEnv * env,
00122                                            RemixChunk * src,
00123                                            RemixCount src_offset,
00124                                            RemixChunk * dest,
00125                                            RemixCount dest_offset,
00126                                            RemixCount count, int channelname,
00127                                            void * data);
00128 
00129 /* RemixChunkChunkChunkFunc: a function to apply between THREE chunks !! */
00130 typedef RemixCount (*RemixChunkChunkChunkFunc) (RemixEnv * env,
00131                                                 RemixChunk * src1,
00132                                                 RemixCount src1_offset,
00133                                                 RemixChunk * src2,
00134                                                 RemixCount src2_offset,
00135                                                 RemixChunk * dest,
00136                                                 RemixCount dest_offset,
00137                                                 RemixCount count,
00138                                                 int channelname,
00139                                                 void * data);
00140 
00141 struct _RemixMetaAuthor {
00142   char * name;
00143   char * email;
00144 };
00145 
00146 struct _RemixMetaText {
00147   char * identifier;
00148   char * category;
00149   char * description;
00150   char * copyright;
00151   char * url;
00152   CDList * authors;
00153 };
00154 
00155 struct _RemixParameterRange {
00156   RemixFlags valid_mask;
00157   RemixParameter lower;
00158   RemixParameter upper;
00159   RemixParameter step;
00160 };
00161 
00162 struct _RemixNamedParameter {
00163   char * name;
00164   RemixParameter parameter;
00165 };
00166 
00167 #define REMIX_NAMED_PARAMETER(n,p) (&((struct _RemixNamedParameter){(n),(p)}))
00168 
00169 union _RemixConstraint {
00170   CDList * list; /* list of RemixNamedParameter */
00171   RemixParameterRange * range;
00172 };
00173 
00174 struct _RemixParameterScheme {
00175   char * name;
00176   char * description;
00177   RemixParameterType type;
00178   RemixConstraintType constraint_type;
00179   RemixConstraint constraint;
00180   RemixFlags hints;
00181 };
00182 
00183 struct _RemixPlugin {
00184   RemixMetaText * metatext;
00185   RemixFlags flags;
00186   CDSet * init_scheme;
00187   RemixInitFunc init;
00188   CDSet * process_scheme;
00189   RemixSuggestFunc suggest;
00190   void * plugin_data;
00191   RemixPluginDestroyFunc destroy;
00192 };
00193 
00194 struct _RemixMethods {
00195   RemixCloneFunc clone;
00196   RemixDestroyFunc destroy;
00197   RemixReadyFunc ready;
00198   RemixPrepareFunc prepare;
00199   RemixProcessFunc process;
00200   RemixLengthFunc length;
00201   RemixSeekFunc seek;
00202   RemixFlushFunc flush;
00203 };
00204 
00205 
00206 struct _RemixChunk {
00207   RemixCount start_index;
00208   RemixCount length;
00209   RemixPCM * data;
00210 };
00211 
00212 
00213 /* debug */
00214 void remix_dprintf (const char * fmt, ...);
00215 
00216 /* SOUNDRENDER, remix_context */
00217 
00218 RemixError remix_set_error (RemixEnv * env, RemixError error);
00219 
00220 
00221 /* remix_base */
00222 RemixBase * remix_base_new (RemixEnv * env);
00223 
00224 RemixPlugin * remix_base_set_plugin (RemixEnv * env, RemixBase * base,
00225                                      RemixPlugin * plugin);
00226 RemixPlugin * remix_base_get_plugin (RemixEnv * env, RemixBase * base);
00227 RemixMethods * remix_base_set_methods (RemixEnv * env, RemixBase * base,
00228                                        RemixMethods * methods);
00229 void * remix_base_set_instance_data (RemixEnv * env, RemixBase * base,
00230                                      void * data);
00231 void * remix_base_get_instance_data (RemixEnv * env, RemixBase * base);
00232 
00233 RemixCount remix_base_get_mixlength (RemixEnv * env, RemixBase * base);
00234 RemixSamplerate remix_base_get_samplerate (RemixEnv * env, RemixBase * base);
00235 RemixTempo remix_base_get_tempo (RemixEnv * env, RemixBase * base);
00236 CDSet * remix_base_get_channels (RemixEnv * env, RemixBase * base);
00237 
00238 int remix_base_has_samplerate (RemixEnv * env, RemixBase * base);
00239 int remix_base_has_tempo (RemixEnv * env, RemixBase * base);
00240 int remix_base_encompasses_mixlength (RemixEnv * env, RemixBase * base);
00241 int remix_base_encompasses_channels (RemixEnv * env, RemixBase * base);
00242 
00243 
00244 /* remix_meta */
00245 RemixMetaText * remix_meta_text_new (RemixEnv * env);
00246 void remix_meta_text_free (RemixEnv * env, RemixMetaText * mt);
00247 RemixMetaText * remix_get_meta_text (RemixEnv * env, RemixBase * base);
00248 RemixMetaText * remix_set_meta_text (RemixEnv * env, RemixBase * base,
00249                                      RemixMetaText * mt);
00250 
00251 
00252 /* remix_null */
00253 RemixCount remix_null_length (RemixEnv * env, RemixBase * base);
00254 RemixCount remix_null_process (RemixEnv * env, RemixBase * base,
00255                                RemixCount count,
00256                                RemixStream * input, RemixStream * output);
00257 RemixCount remix_null_seek (RemixEnv * env, RemixBase * base,
00258                             RemixCount offset);
00259 
00260 
00261 /* remix_stream */
00262 RemixCount remix_stream_chunkfuncify (RemixEnv * env, RemixStream * stream,
00263                                       RemixCount count,
00264                                       RemixChunkFunc func, void * data);
00265 RemixCount remix_stream_chunkchunkfuncify (RemixEnv * env,
00266                                            RemixStream * src,
00267                                            RemixStream * dest,
00268                                            RemixCount count,
00269                                            RemixChunkChunkFunc func,
00270                                            void * data);
00271 RemixCount remix_stream_chunkchunkchunkfuncify (RemixEnv * env,
00272                                                 RemixStream * src1,
00273                                                 RemixStream * src2,
00274                                                 RemixStream * dest,
00275                                                 RemixCount count,
00276                                                 RemixChunkChunkChunkFunc func,
00277                                                 void * data);
00278 
00279 /* RemixChannel */
00280 RemixChunk * remix_channel_get_chunk_at (RemixEnv * env,
00281                                          RemixChannel * channel,
00282                                          RemixCount offset);
00283 
00284 RemixCount remix_channel_chunkfuncify (RemixEnv * env, RemixChannel * channel,
00285                                        RemixCount count, RemixChunkFunc func,
00286                                        int channelname, void * data);
00287 RemixCount remix_channel_chunkchunkfuncify (RemixEnv * env,
00288                                             RemixChannel * src,
00289                                             RemixChannel * dest,
00290                                             RemixCount count,
00291                                             RemixChunkChunkFunc func,
00292                                             int channelname, void * data);
00293 RemixCount remix_channel_chunkchunkchunkfuncify (RemixEnv * env,
00294                                                  RemixChannel * src1,
00295                                                  RemixChannel * src2,
00296                                                  RemixChannel * dest,
00297                                                  RemixCount count,
00298                                                  RemixChunkChunkChunkFunc func,
00299                                                  int channelname, void * data);
00300 /* RemixPCM */
00301 
00302 RemixCount _remix_pcm_clear_region (RemixPCM * data, RemixCount count,
00303                                     void * unused);
00304 RemixCount _remix_pcm_set (RemixPCM * data, RemixPCM value, RemixCount count);
00305 RemixCount _remix_pcm_gain (RemixPCM * data, RemixCount count,
00306                             /* (RemixPCM *) */ void * gain);
00307 RemixCount _remix_pcm_copy (RemixPCM * src, RemixPCM * dest, RemixCount count,
00308                             void * unused);
00309 RemixCount _remix_pcm_add (RemixPCM * src, RemixPCM * dest, RemixCount count,
00310                            void * unused);
00311 RemixCount _remix_pcm_mult (RemixPCM * src, RemixPCM * dest, RemixCount count,
00312                             void * unused);
00313 RemixCount _remix_pcm_fade (RemixPCM * src, RemixPCM * dest, RemixCount count,
00314                             void * unused);
00315 RemixCount _remix_pcm_interleave_2 (RemixPCM * src1, RemixPCM * src2, 
00316                                     RemixCount count, void * data);
00317 RemixCount _remix_pcm_deinterleave_2 (RemixPCM * dest1, RemixPCM * dest2,
00318                                       RemixCount count, void * data);
00319 RemixCount _remix_pcm_blend (RemixPCM * src, RemixPCM * blend, RemixPCM * dest,
00320                              RemixCount count, void * unused);
00321 RemixCount _remix_pcm_write_linear (RemixPCM * data, RemixCount x1,
00322                                     RemixPCM y1, RemixCount x2, RemixPCM y2,
00323                                     RemixCount offset, RemixCount count);
00324 
00325 #endif /* defined(__REMIX__) */
00326 
00327 #endif /* __REMIX_PLUGIN_H__ */

Generated on Tue Nov 8 2011 07:59:27 for remix by  doxygen 1.7.1