Shared data concurrency with SDL

[Tim Reinke]

Newbie here.  I'm playing around with concurrency in D.  Being 
new to both, I have no idea what I'm doing and am seeking your 
guidance!

I'm using the D SDL wrapper (which is just a thin wrapper around 
the C library).

I have the following threads:
   - the main program thread; the `control & coordination` thread
   - SDL_Mixer has its own thread (which calls a callback I 
provide)
   - a thread to handle graphics

Questions I'm seeking answers to:
1) I'm doing a lot of casting to/from shared which doesn't feel 
right.  What should be I doing?  Some of this seems unavoidable, 
as in the SDL callback postMixCallback() where I'm bound by the 
SDL_mixer library to provide a specific type signature.

2) A specific instance of 1). In my main(), I declare 
GraphicsState to
be unshared.  GraphicsState just holds on to a bunch of pointers
returned by SDL initialization routines (which won't work on 
shared
pointers).  Then, in order to communicate with the graphics 
thread via
send(), I cast the address of to a shared pointer.  On the other 
end,
I receive this shared pointer then cast to an unshared pointer and
dereference.  I do this because the pointer values in 
GraphicsState
are passed pretty much exclusively to C functions which won't 
accept
shared types.  Seems awkward, no?

My code (also at http://pastebin.com/SMC2e9Bx )

// Holds data the graphics thread needs
// This is initialized in the main
// thread then sent to the graphics thread
// Cleanup is done by the main thread after
// the graphics thread exits
struct GraphicsState {
   SDL_Window* window;
   SDL_Renderer* renderer;
   SDL_Texture* texture;
   ImageSurface cairoSurface;
   ubyte* pixels;
}

// a simple ring buffer
struct RingBuffer {
   ulong pos;
   short[] buffer;
}


void main()
{
   // ...
   GraphicsState graphicsState;
   gfxInit(graphicsState);

   shared RingBuffer ringBuffer;
   ringBuffer.pos = 0;
   ringBuffer.buffer.length = audioConf.sample_f * 
audioConf.chunkSize;

   Mix_SetPostMix(&finished, cast(void*)&ringBuffer);

   Tid tid = spawn(&doGfx);
   shared GraphicsState* sharedGfx = cast(shared 
GraphicsState*)&graphicsState;
   send(tid, sharedGfx, cast(shared(RingBuffer*))&ringBuffer);
   // ...
}

extern(C) void postMixCallback(void* udata, ubyte *stream, int 
len)
{
   shared RingBuffer* buffer = cast(shared RingBuffer*)udata;
   short *samples = cast(short*)stream;

   // naive copy
   for (int i = 0; i < len / short.sizeof; i += 2)
   {
     buffer.buffer[buffer.pos] = *(samples + i);
     auto nextPos = buffer.pos + 1;
     if (nextPos == buffer.buffer.length)
     {
       nextPos = 0;
     }
     buffer.pos = nextPos;
   }
}

void doGfx(AudioConf audioConf)
{
   GraphicsState graphicsState;
   Mix_Chunk* beat;
   shared RingBuffer* ringBuffer;
   auto msg = receiveOnly!(shared(GraphicsState*), 
shared(RingBuffer*));

   graphicsState = *(cast(GraphicsState*)msg[0]);
   ringBuffer = msg[1];

   while (true) {
     // read from ring buffer
     // render
   }
}