source: downloads/openal-0.0.8/src/al_threadlib.c @ 17

/* -*- mode: C; tab-width:8; c-basic-offset:8 -*-
 * vi:set ts=8:
 *
 * al_threadlib.c
 */

#include <stdlib.h>
#include "al_threadlib.h"

#if defined(USE_POSIXTHREADING)

typedef int ( *ptfunc ) ( void * );

static void *runThread( void *data ) AL_ATTRIBUTE_NORETURN_;

static void *runThread( void *data )
{
        ptfunc fn = ( ptfunc ) data;
        fn( NULL );
        pthread_exit( NULL );
#ifndef HAVE___ATTRIBUTE__
        return NULL;
#endif
}

ThreadID _alCreateThread( int ( *fn ) ( void * ) )
{
        pthread_attr_t type;
        pthread_t *thread = malloc( sizeof *thread );
        if( thread == NULL ) {
                return NULL;
        }

        if( pthread_attr_init( &type ) != 0 ) {
                free( thread );
                return NULL;
        }

        pthread_attr_setdetachstate( &type, PTHREAD_CREATE_JOINABLE );

        if( pthread_create( thread, &type, runThread, ( void * ) fn ) != 0 ) {
                free( thread );
                return NULL;
        }

        return thread;
}

int _alWaitThread( ThreadID thread )
{
        int retval = pthread_join( *thread, NULL );
        free( thread );
        return retval;
}

unsigned int _alSelfThread( void )
{
        return ( unsigned int ) pthread_self(  );
}

void _alExitThread( void )
{
        pthread_exit( NULL );
}

#elif defined(USE_WINDOWSTHREADING)

/* for _alMicroSleep */
#include "al_main.h"

ThreadID _alCreateThread( int ( *fn ) ( void * ) )
{
        DWORD dummy;
        return CreateThread( NULL, 0, ( LPTHREAD_START_ROUTINE ) fn, NULL, 0,
                             &dummy );
}

int _alWaitThread( ThreadID thread )
{
        int tries = 20;         /* gets tries iterations before we nuke it */
        const int interval = 40000;

        do {
                DWORD ExitCode;
                if( GetExitCodeThread( thread, &ExitCode ) == 0 ) {
                        break;
                }

                /* thread is still running, be nice and wait a bit */
                _alMicroSleep( interval );
        } while( tries-- );

        return ( TerminateThread( thread, 0 ) == 0 ) ? -1 : 0;
}

void _alExitThread( void )
{
        ExitThread( 0 );
}

unsigned int _alSelfThread( void )
{
        return ( unsigned int ) GetCurrentThreadId(  );
}

#elif defined(USE_MORPHOSTHREADING)

#include <dos/dostags.h>
#include <proto/dos.h>
#include <proto/exec.h>

#include "al_types.h"

struct ThreadStartMsg {
        struct Message tsm_Msg;
        int tsm_Result;
};

ThreadID _alCreateThread( int ( *fn ) ( void * ) )
{
        struct ThreadData *thread =
            AllocVec( sizeof( struct ThreadData ), MEMF_PUBLIC );
        if( thread == NULL ) {
                return NULL;
        }

        thread->td_MsgPort = CreateMsgPort(  );
        if( !thread->td_MsgPort ) {
                FreeVec( thread );
                return NULL;
        }

        struct ThreadStartMsg *startup_msg =
            AllocVec( sizeof( struct ThreadStartMsg ),
                      MEMF_PUBLIC | MEMF_CLEAR );
        if( startup_msg == NULL ) {
                DeleteMsgPort( thread->td_MsgPort );
                FreeVec( thread );
                return NULL;
        }

        startup_msg->tsm_Msg.mn_Node.ln_Type = NT_MESSAGE;
        startup_msg->tsm_Msg.mn_ReplyPort = thread->td_MsgPort;
        startup_msg->tsm_Msg.mn_Length = sizeof( *startup_msg );

        thread->td_Thread =
            CreateNewProcTags( NP_Entry, ( ULONG ) fn, NP_Name, ( ULONG )
                               "OpenAL Thread",
                               NP_CodeType,
                               CODETYPE_PPC,
                               NP_StartupMsg,
                               ( ULONG ) startup_msg,
                               NP_PPC_Arg1, 0, TAG_DONE );
        if( !thread->td_Thread ) {
                FreeVec( startup_msg );
                DeleteMsgPort( thread->td_MsgPort );
                FreeVec( thread );
                return NULL;
        }

        return thread;
}

int _alWaitThread( ThreadID thread )
{
        struct ThreadStartMsg *tsm;
        int retval;
        WaitPort( thread->td_MsgPort );
        tsm = ( struct ThreadStartMsg * ) GetMsg( thread->td_MsgPort );
        DeleteMsgPort( thread->td_MsgPort );
        retval = tsm->tsm_Result;
        FreeVec( tsm );
        FreeVec( thread );
        return retval;
}

unsigned int _alSelfThread( void )
{
        return ( unsigned int ) FindTask( NULL );
}

void _alExitThread( void )
{
        struct ThreadStartMsg *msg;
        if( NewGetTaskAttrs( NULL, &msg, sizeof( msg ), TASKINFOTYPE_STARTUPMSG,
                             TAG_DONE ) && msg )
                msg->tsm_Result = 0;
        /*RemTask(NULL); */
}

#endif