Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP

Loading…

Only send #10

Merged
merged 47 commits into from

2 participants

@tebjan

As bespoke in the previous pull request, here only code which enables sending to libpd and audio processing

tebjan added some commits
@tebjan tebjan fixed make file by adding "" for paths with space 1d3fec1
@tebjan tebjan added all c# projects plus solution e8cf04d
@tebjan tebjan added pthreadGC2.dll for win cfa83ef
@tebjan tebjan added example pd patch 98de9f8
@tebjan tebjan updated .gitignore 2aed5dc
@tebjan tebjan work on messages and wrapper system, much cleaner example code 82e9ac4
@tebjan tebjan refactored class stuff 8ca6249
@tebjan tebjan use string instead of t_atom for message/list arguments
message receiving works with modified c code
some architecture rework
d2426ef
@tebjan tebjan got rid of t_atom type
added C code for hook setters and message/list arguments as string
was trying to move hook setter methods to new file z_hookset
d9d0b82
@tebjan tebjan added midi setter to C code aadf1b9
@tebjan tebjan added midi delegates 91cb8e2
@tebjan tebjan midi stuff done 14bd913
@tebjan tebjan better midi delegate names c29d2a5
@tebjan tebjan added original mingGW LGPL pthreads dll 8d7d9d2
@tebjan tebjan message and midihooks successfully tested! b562d4a
@tebjan tebjan fixed str[0] = '\0'; bug... 1c6239d
@tebjan tebjan example wave provider uses its own inbuffer now 83bf58f
@tebjan tebjan all midi send methods have a synchronized version now 9a2fa4e
@tebjan tebjan messaging to new file and synchronized 40a3e23
@tebjan tebjan pretty much finished with bindings 06f9b00
@tebjan tebjan fixed mit types 0a7a5e6
@tebjan tebjan moved files to appropriate places 2187816
@tebjan tebjan updated solution file a6f4c99
@tebjan tebjan some file refactoring and cosmetics 624cd3c
@tebjan tebjan improved array methods and return type of Exists e2f15e4
@tebjan tebjan open patch has only one path string now 191f745
@tebjan tebjan renamed open method 5cebcfb
@tebjan tebjan added lots of comments and some renaming to follow java naming adeaadb
@tebjan tebjan cosmetics, but some renamig introduced bug 01f1d63
@tebjan tebjan fixed, all works nicely now 47fffdb
@tebjan tebjan moved additional C code to hookset files and it works now 720a807
@tebjan tebjan resored C files to original state ac49214
@tebjan tebjan commented message receive code out 842f2be
@tebjan tebjan removed hookset from makefile d422d25
@tebjan tebjan removed unnecessary files ca37e37
@nettoyeurny nettoyeurny commented on the diff
csharp/Native/LibPDNativeMessaging.cs
@@ -0,0 +1,534 @@
+/*
@nettoyeurny Owner

Please add a license notice.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((7 lines not shown))
+ *
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Runtime.CompilerServices;
+
+namespace LibPDBinding
+{
+ #region Delegates
+
+ /*
@nettoyeurny Owner

Please remove all code that's currently commented out.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((441 lines not shown))
+ add_float((float)((double?) arg));
+ }
+ else if (arg is string)
+ {
+ add_symbol((string) arg);
+ }
+ else
+ {
+ return -101; // illegal argument
+ }
+ }
+ return 0;
+ }
+
+ //parse args helper with debug string
+ private static int ProcessArgsDebug(object[] args, ref string debug)
@nettoyeurny Owner

This is almost the same as ProcessArgs. Please refactor to eliminate code duplication.

@tebjan
tebjan added a note

this was done because i expect many calls to this function and i wanted to have the 'if' to the debug code branch as early as possible to save performance... but i will think about it.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((318 lines not shown))
+ return ret;
+ }
+ else
+ {
+ int err = ProcessArgs(args);
+ return (err == 0) ? finish_list(receiver) : err;
+ }
+ }
+
+ /// <summary>
+ /// Get an object array from a space seperated message string threadsafe
+ /// </summary>
+ /// <param name="argsString"></param>
+ /// <returns></returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static object[] ParseArgsString(string argsString)
@nettoyeurny Owner

This belongs to the callback business that we decided to leave for later, right? Please remove.

@tebjan
tebjan added a note

yes, but i left it because it might also be handy in in C# context if the user wants to define messages as a space separated string... should i still remove it?

@nettoyeurny Owner

Please remove. I want the basic library to be as small as possible.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((329 lines not shown))
+ /// </summary>
+ /// <param name="argsString"></param>
+ /// <returns></returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static object[] ParseArgsString(string argsString)
+ {
+ return ParseArgsStringUnsync(argsString);
+ }
+
+ /// <summary>
+ /// Get an object array from a space seperated message string
+ /// This method is not synchronized for performance reasons
+ /// </summary>
+ /// <param name="argsString"></param>
+ /// <returns></returns>
+ public static object[] ParseArgsStringUnsync(string argsString)
@nettoyeurny Owner

Same here.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((189 lines not shown))
+ {
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ get;
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ set;
+ }
+
+ //binding-----------------------------------
+
+ /// <summary>
+ /// subscribes to pd messages sent to the given symbol
+ /// </summary>
+ /// <param name="symbol"> </param>
+ /// <returns> true on success </returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static bool Subscribe(string sym)
@nettoyeurny Owner

Only needed for callbacks; please remove for now.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((208 lines not shown))
+ var ptr = bind(sym);
+
+ if(ptr == IntPtr.Zero) return false;
+
+ Bindings[sym] = ptr;
+ return true;
+ }
+
+ /// <summary>
+ /// unsubscribes from pd messages sent to the given symbol; will do nothing
+ /// if there is no subscription to this symbol
+ /// </summary>
+ /// <param name="sym"> </param>
+ /// <returns>true if unsubscribed</returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static bool Unsubscribe(string sym)
@nettoyeurny Owner

Same here.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMethods.cs
((229 lines not shown))
+ ///outBuffer: float*
+ [DllImport("libpd.dll", EntryPoint="libpd_process_raw")]
+ private static extern int process_raw(ref float inBuffer, ref float outBuffer) ;
+
+ /// <summary>
+ /// raw process callback, processes one pd tick, writes raw data to buffers
+ /// without interlacing
+ /// </summary>
+ /// <param name="inBuffer">
+ /// must be an array of the right size, never null; use inBuffer =
+ /// new short[0] if no input is desired </param>
+ /// <param name="outBuffer">
+ /// must be an array of size outBufferSize from openAudio call </param>
+ /// <returns> error code, 0 on success </returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static int ProcessRaw(ref float inBuffer, ref float outBuffer)
@nettoyeurny Owner

I would prefer float[] to ref float, but that's a matter of taste.

@tebjan
tebjan added a note

yes right.. also had float[] at first, but then i come to the point of using pointers in C# like:

fixed(float* inBuff = FInBuffer)
{
fixed(byte* outBuff = buffer)
{
LibPD.Process(ticks, ref inBuff[0], ref ((float*)outBuff)[0]);
}
}

but i will check if i can cast a pointer back to float[], haven't tried yet...

@tebjan
tebjan added a note

unfortunately not possible without hacks.. so its more flexible like this.

@nettoyeurny Owner

Okay.

@nettoyeurny Owner

On second thought, what prevents us from implementing this method like this?

[MethodImpl(MethodImplOptions.Synchronized)]
public static int ProcessRaw(float[] inBuffer, float[] outBuffer) {
return process_raw(ref inBuffer[0], ref outBuffer[0]);
}

@tebjan
tebjan added a note

that you can't use pointers then... as i tried to explain above.

fixed(byte* outBuff = buffer)
{
LibPD.Process(ticks, ref aFloat, ref ((float*)outBuff)[0]);
}

the fixed statement assigns the start of the raw byte buffer array to the byte* outBuff. and since i know its a 32bit ieee float buffer i can cast that to a float* and dereference it with the [] operator. with arrays this wouldn't be possible. but we could just provide two versions of it...?

@nettoyeurny Owner

Maybe I don't understand the use cases here. Why do you want to use raw byte buffers with Process, but float arrays with ReadArray/WriteArray?

@tebjan
tebjan added a note

i just thought that the data one wants to store or read from pd arrays are more general and a programmer will have this as an array. but sure, he would also be able to just read that from a file or the audio in... in that perspective its the same and the array methods should also have ref floats...

@nettoyeurny Owner

Okay. Let's rewrite the array methods in terms of ref float, then.

@tebjan
tebjan added a note

ok, one came to another and i had quite some fun reading pages about marshalling. frankly, there is no good way to provide a method signature which allows to use pointer and array in the same time, because you want to provide the marshaller enough information that it does not copy the data.
in the array case, the CLR will pin the arrays and lets the unmanaged code read/write the provided memory only if one uses the [In]/[Out] attributes.
if one wants to use pointers, then in C# the type should also be pointer, because this forces the programmer to pin the memory himself with a fixed code block as shown above. so it needs two implementations for optimal performance in both cases. will do a new update soon.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
@nettoyeurny
Owner

Almost there! I left a few comments inline, all of them cosmetic.

@tebjan

yep, half of it already done, new commits soon...

@tebjan

license note is taken from the java code. removed unnecessary code and refactored the ParseArgs method

@nettoyeurny
Owner

Thanks! I'll review the new version soon.

README.txt
((10 lines not shown))
* samples: This branch contains one small sample program in C built on top
- of libpd, as well as a sample project in Java that uses JavaSound.
+ of libpd, as well as a sample project in Java that uses JavaSound and a
+ C# project that uses NAudio/ASIO.
@nettoyeurny Owner

Let's hold off on this edit until we actually commit the C# sample project.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((87 lines not shown))
+ /// <param name="sym"> </param>
+ /// <returns> error code, 0 on success </returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static int SendSymbol(string recv, string sym)
+ {
+ return send_symbol(recv, sym);
+ }
+
+ /// <summary>
+ /// Sends a message to an object in pd
+ /// </summary>
+ /// <param name="receiver"> </param>
+ /// <param name="message"> </param>
+ /// <param name="args">
+ /// list of arguments of type Integer, Float, or String; no more
+ /// than 32 arguments </param>
@nettoyeurny Owner

Actually, the limit of 32 arguments is gone; the integer argument of the start_message function takes care of that.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((96 lines not shown))
+ /// Sends a message to an object in pd
+ /// </summary>
+ /// <param name="receiver"> </param>
+ /// <param name="message"> </param>
+ /// <param name="args">
+ /// list of arguments of type Integer, Float, or String; no more
+ /// than 32 arguments </param>
+ /// <returns> error code, 0 on success </returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static int SendMessage(string receiver, string message, params object[] args)
+ {
+ if(SWriteMessageToDebug)
+ {
+ var s = String.Format("Message: {0} {1}", receiver, message);
+ int err = ProcessArgs(args, ref s);
+ var ret = (err == 0) ? finish_message(receiver, message) : err;
@nettoyeurny Owner

Suggestion: Move the preceding two lines up, out of the if statement, and move the return statement down, out of the if statement. Like this, you can eliminate the code duplication in the else branch.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((124 lines not shown))
+
+ /// <summary>
+ /// Sends a list to an object in pd
+ /// </summary>
+ /// <param name="receiver"> </param>
+ /// <param name="args">
+ /// list of arguments of type Integer, Float, or String; no more
+ /// than 32 arguments </param>
+ /// <returns> error code, 0 on success </returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static int SendList(string receiver, params object[] args)
+ {
+ if(SWriteMessageToDebug)
+ {
+ var s = String.Format("List: {0}", receiver);
+ int err = ProcessArgs(args, ref s);
@nettoyeurny Owner

Same comment as above.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((188 lines not shown))
+ {
+ ret[i] = s;
+ }
+ }
+
+ Thread.CurrentThread.CurrentCulture = previousCulture;
+
+ return ret;
+ }
+
+ #endregion Message sending
+
+ #region private
+
+ [DllImport("libpd.dll", EntryPoint="libpd_bind")]
+ private static extern IntPtr bind([In] [MarshalAs(UnmanagedType.LPStr)] string sym) ;
@nettoyeurny Owner

Not needed right now. Please remove.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((193 lines not shown))
+ Thread.CurrentThread.CurrentCulture = previousCulture;
+
+ return ret;
+ }
+
+ #endregion Message sending
+
+ #region private
+
+ [DllImport("libpd.dll", EntryPoint="libpd_bind")]
+ private static extern IntPtr bind([In] [MarshalAs(UnmanagedType.LPStr)] string sym) ;
+
+ /// Return Type: void
+ ///p: void*
+ [DllImport("libpd.dll", EntryPoint="libpd_unbind")]
+ private static extern void unbind(IntPtr p) ;
@nettoyeurny Owner

Not needed, either.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMethods.cs
((52 lines not shown))
+ /// decided to handle all synchronization on the Java side. It appears that
+ /// sys_lock is for top-level locking in scheduling routines only, and so
+ /// Java-side sync conveys the same benefits without the risk of deadlocks.
+ ///
+ ///
+ /// Author: Tebjan Halm (tebjan@vvvv.org)
+ ///
+ /// </summary>
+ public static partial class LibPD
+ {
+
+ //only call this once a lifetime
+ static LibPD()
+ {
+ //SetupHooks();
+ //SetupMidiHooks();
@nettoyeurny Owner

Please remove the two lines above.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
@nettoyeurny nettoyeurny commented on the diff
csharp/Native/LibPDNativeMethods.cs
((63 lines not shown))
+ //only call this once a lifetime
+ static LibPD()
+ {
+ //SetupHooks();
+ //SetupMidiHooks();
+ libpd_init();
+ }
+
+ #region Environment
+
+ //store open patches
+ private static Dictionary<int, IntPtr> Patches = new Dictionary<int, IntPtr>();
+
+ /// Init PD
+ [DllImport("libpd.dll", EntryPoint="libpd_init")]
+ private static extern void libpd_init() ;
@nettoyeurny Owner

Cosmetic point: In the other file, you put all the private methods in a separate region; here, you intersperse them with the public methods. Either way is fine with me, but please pick one style and stick to it.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMethods.cs
((149 lines not shown))
+ private static extern void closefile(IntPtr p) ;
+
+ /// <summary>
+ /// closes a patch; will do nothing if the handle is invalid
+ /// </summary>
+ /// <param name="p">$0 of the patch, as returned by OpenPatch</param>
+ /// <returns>true if file was found and closed</returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static bool ClosePatch(int p)
+ {
+ if(!Patches.ContainsKey(p)) return false;
+
+ var ptr = Patches[p];
+ closefile(ptr);
+ return Patches.Remove(p);
+
@nettoyeurny Owner

Delete blank line.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMessaging.cs
((19 lines not shown))
+using System.Threading;
+using System.Runtime.CompilerServices;
+
+namespace LibPDBinding
+{
+
+
+ //the receiver part of libpd
+ public static partial class LibPD
+ {
+
+
+ #region Message sending
+
+ //store bindings
+ private static Dictionary<string, IntPtr> Bindings = new Dictionary<string, IntPtr>();
@nettoyeurny Owner

Not needed. Please delete for now.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMethods.cs
((219 lines not shown))
+ ///
+ /// Note: Maintaining a DSP state that's separate from the state of the audio
+ /// rendering thread doesn't make much sense in libpd. In most applications,
+ /// you probably just want to call {@code computeAudio(true)} at the
+ /// beginning and then forget that this method exists.
+ /// </summary>
+ /// <param name="state"></param>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static void ComputeAudio(bool state)
+ {
+ SendMessage("pd", "dsp", state ? 1 : 0);
+ }
+
+ /// Return Type: int
+ [DllImport("libpd.dll", EntryPoint="libpd_blocksize")]
+ public static extern int blocksize() ;
@nettoyeurny Owner

private?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMethods.cs
((385 lines not shown))
+
+ [DllImport("libpd.dll", EntryPoint="libpd_read_array")]
+ private static extern int read_array(ref float dest, [In] [MarshalAs(UnmanagedType.LPStr)] string src, int offset, int n) ;
+
+
+ /// <summary>
+ /// read values from an array in Pd
+ /// </summary>
+ /// <param name="destination"> float array to write to </param>
+ /// <param name="destOffset"> index at which to start writing </param>
+ /// <param name="source"> array in Pd to read from </param>
+ /// <param name="srcOffset"> index at which to start reading </param>
+ /// <param name="n"> number of values to read </param>
+ /// <returns> 0 on success, or a negative error code on failure </returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static int ReadArray(float[] destination, int destOffset, string source, int srcOffset, int n)
@nettoyeurny Owner

Since the process methods use ref float, I'd prefer to use ref float here as well. That would also allow us to remove destOffset, which would feel more like the C version.

@tebjan
tebjan added a note

i just tried, but then we can't use the bounds checking, since the ref float can't be cast to an array. and since this is in particular about arrays i think its ok to leave it as is. the process methods are more performance critic, which makes it more likely that one wants to use pointers/streams/ref floats.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
csharp/Native/LibPDNativeMethods.cs
((408 lines not shown))
+
+ [DllImport("libpd.dll", EntryPoint="libpd_write_array")]
+ private static extern int write_array([In] [MarshalAs(UnmanagedType.LPStr)] string dest, int offset, ref float src, int n) ;
+
+
+ /// <summary>
+ /// write values to an array in Pd
+ /// </summary>
+ /// <param name="destination"> name of the array in Pd to write to </param>
+ /// <param name="destOffset"> index at which to start writing </param>
+ /// <param name="source"> float array to read from </param>
+ /// <param name="srcOffset"> index at which to start reading </param>
+ /// <param name="n"> number of values to write </param>
+ /// <returns> 0 on success, or a negative error code on failure </returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static int WriteArray(string destination, int destOffset, float[] source, int srcOffset, int n)
@nettoyeurny Owner

Same comment.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
@nettoyeurny
Owner

Looks good. Just a few more cosmetic changes and we'll be done.

@tebjan

ok, have done all things requested, except that i kept the argument type of the array methods as arrays (see comment).

@tebjan

now, please have a look at the new signatures for the audio process and array methods.

@nettoyeurny nettoyeurny commented on the diff
csharp/Native/LibPDNativeMethods.cs
((452 lines not shown))
+ }
+
+
+ [DllImport("libpd.dll", EntryPoint="libpd_read_array")]
+ private static extern int read_array([Out] float[] dest, [In] [MarshalAs(UnmanagedType.LPStr)] string src, int offset, int n) ;
+
+ /// <summary>
+ /// read values from an array in Pd
+ /// </summary>
+ /// <param name="destination"> float array to write to </param>
+ /// <param name="source"> array in Pd to read from </param>
+ /// <param name="srcOffset"> index at which to start reading </param>
+ /// <param name="n"> number of values to read </param>
+ /// <returns> 0 on success, or a negative error code on failure </returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static int ReadArray(float[] destination, string source, int srcOffset, int n)
@nettoyeurny Owner

What if we want to have an offset for the destination?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
@nettoyeurny nettoyeurny commented on the diff
csharp/Native/LibPDNativeMethods.cs
((275 lines not shown))
+
+ [DllImport("libpd.dll", EntryPoint="libpd_process_raw")]
+ private static unsafe extern int process_raw(float* inBuffer, float* outBuffer) ;
+
+ /// <summary>
+ /// raw process callback, processes one pd tick, writes raw data to buffers
+ /// without interlacing
+ /// </summary>
+ /// <param name="inBuffer">
+ /// pointer to an array of the right size, never null; use inBuffer =
+ /// new short[0] if no input is desired </param>
+ /// <param name="outBuffer">
+ /// pointer to an array of size outBufferSize from openAudio call </param>
+ /// <returns> error code, 0 on success </returns>
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static unsafe int ProcessRaw(float* inBuffer, float* outBuffer)
@nettoyeurny Owner

Hmm. Now we have two versions of each process and array method. Let's document why we need both, and when to use which.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
@tebjan

have written some doc for the methods... that should do it.

@nettoyeurny nettoyeurny merged commit aa96be4 into libpd:master
@nettoyeurny
Owner

Looks good, thanks!

@rvega rvega referenced this pull request
Closed

Segfault scenario. #5

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Commits on Apr 9, 2012
  1. @tebjan
  2. @tebjan
  3. @tebjan

    added pthreadGC2.dll for win

    tebjan authored
  4. @tebjan

    added example pd patch

    tebjan authored
  5. @tebjan

    updated .gitignore

    tebjan authored
  6. @tebjan
Commits on Apr 10, 2012
  1. @tebjan

    refactored class stuff

    tebjan authored
Commits on Apr 11, 2012
  1. @tebjan

    use string instead of t_atom for message/list arguments

    tebjan authored
    message receiving works with modified c code
    some architecture rework
  2. @tebjan

    got rid of t_atom type

    tebjan authored
    added C code for hook setters and message/list arguments as string
    was trying to move hook setter methods to new file z_hookset
  3. @tebjan

    added midi setter to C code

    tebjan authored
  4. @tebjan

    added midi delegates

    tebjan authored
  5. @tebjan

    midi stuff done

    tebjan authored
  6. @tebjan

    better midi delegate names

    tebjan authored
  7. @tebjan
Commits on Apr 12, 2012
  1. @tebjan
  2. @tebjan

    fixed str[0] = '\0'; bug...

    tebjan authored
  3. @tebjan
  4. @tebjan
  5. @tebjan
  6. @tebjan
  7. @tebjan

    fixed mit types

    tebjan authored
  8. @tebjan
  9. @tebjan

    updated solution file

    tebjan authored
  10. @tebjan
  11. @tebjan
Commits on Apr 13, 2012
  1. @tebjan
Commits on Apr 15, 2012
  1. @tebjan

    renamed open method

    tebjan authored
Commits on Apr 16, 2012
  1. @tebjan
  2. @tebjan
  3. @tebjan

    fixed, all works nicely now

    tebjan authored
  4. @tebjan
  5. @tebjan
  6. @tebjan
  7. @tebjan

    removed hookset from makefile

    tebjan authored
  8. @tebjan

    removed unnecessary files

    tebjan authored
  9. @tebjan
  10. @tebjan
  11. @tebjan

    forgot one..

    tebjan authored
  12. @tebjan
Commits on Apr 18, 2012
  1. @tebjan

    fixed readme.txt

    tebjan authored
  2. @tebjan

    moved extern methods to there corresponding public methods

    tebjan authored
    fixed comments
    removed some lines not needed
  3. @tebjan

    cosmetics

    tebjan authored
Commits on Apr 29, 2012
  1. @tebjan
  2. @tebjan
  3. @tebjan
Commits on May 2, 2012
  1. @tebjan
  2. @tebjan
Something went wrong with that request. Please try again.