workbench/libs/realtime/setplayerattrsa.c

   1 /*
   2     Copyright © 1995-2016, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5 # define  DEBUG 0
   6 # include <aros/debug.h>
   7
   8 #include <proto/exec.h>
   9 #include <proto/utility.h>
  10 #include <proto/realtime.h>
  11 #include <exec/lists.h>
  12 #include "realtime_intern.h"
  13
  14 struct Conductor *createConductor(BOOL private, LONG *error,STRPTR name,
  15                                   struct Library *RealTimeBase);
  16
  17 /*****************************************************************************
  18
  19     NAME */
  20
  21 #include <utility/tagitem.h>
  22 #include <libraries/realtime.h>
  23
  24     AROS_LH2(BOOL, SetPlayerAttrsA,
  25
  26 /*  SYNOPSIS */
  27
  28         AROS_LHA(struct Player  *, player , A0),
  29         AROS_LHA(struct TagItem *, tagList, A1),
  30
  31 /*  LOCATION */
  32
  33         struct Library *, RealTimeBase, 9, RealTime)
  34
  35 /*  FUNCTION
  36
  37     Sets the attributes of a player. An attribute not specified in the array
  38     of tags is unchanged after this procedure.
  39
  40     INPUTS
  41
  42     player   --  The player the attributes of which to set.
  43     tagList  --  Pointer to an array of tags describing the player's
  44                  attributes or NULL.
  45
  46     TAGS
  47
  48     The same tags as for CreatePlayerA().
  49
  50     RESULT
  51
  52     Success/failure indicator. If failure, then, in case the PLAYER_ErrorCode
  53     is provided, more information can be obtained via that pointer.
  54
  55     NOTES
  56
  57     EXAMPLE
  58
  59     BUGS
  60
  61     SEE ALSO
  62
  63     DeletePlayer(), GetPlayerAttrsA()
  64
  65     INTERNALS
  66
  67 ******************************************************************************/
  68
  69 {
  70     AROS_LIBFUNC_INIT
  71
  72     LONG           *error = NULL;
  73     struct TagItem *tl = tagList;
  74     struct TagItem *tag;
  75     APTR            lock;
  76
  77     error = (LONG *)GetTagData(PLAYER_ErrorCode, (IPTR)NULL, tl);
  78
  79     while ((tag = NextTagItem(&tl)) != NULL)
  80     {
  81         switch(tag->ti_Tag)
  82         {
  83         case PLAYER_Name:
  84             player->pl_Link.ln_Name = (APTR)tag->ti_Data;
  85             break;
  86
  87         case PLAYER_Hook:
  88             player->pl_Hook = (struct Hook *)tag->ti_Data;
  89             break;
  90
  91         case PLAYER_Priority:
  92             player->pl_Link.ln_Pri = (BYTE)tag->ti_Data;
  93
  94             if (player->pl_Link.ln_Succ != NULL)
  95             {
  96                 /* If this node has been (is) inserted before, then remove it
  97                    and put it in the right place. */
  98
  99                 /* Is this player attached to a conductor? */
 100                 if (player->pl_Source != NULL)
 101                 {
 102                     lock = LockRealTime(RT_CONDUCTORS);
 103                     Remove((struct Node *)player);
 104                     Enqueue((struct List *)&player->pl_Source->cdt_Players,
 105                             (struct Node *)player);
 106                     UnlockRealTime(lock);
 107                 }
 108                 else
 109                 {
 110                     if(error != NULL)
 111                     {
 112                         *error = RTE_NOCONDUCTOR;
 113                     }
 114
 115                     return FALSE;
 116                 }
 117             }
 118
 119             break;
 120
 121         case PLAYER_Conductor:
 122
 123             D(bug("Found PLAYER_Conductor tag\n"));
 124
 125             if ((IPTR)tag->ti_Data == -1UL)
 126             {
 127                 player->pl_Source = createConductor(TRUE, error,
 128                                                     (STRPTR)tag->ti_Data,
 129                                                     RealTimeBase);
 130             }
 131             else
 132             {
 133                 struct Conductor *cd = FindConductor((STRPTR)tag->ti_Data);
 134
 135                 if (cd == NULL)
 136                 {
 137                     D(bug("Trying to create a public conductor.\n"));
 138                     player->pl_Source = createConductor(FALSE, error,
 139                                                         (STRPTR)tag->ti_Data,
 140                                                         RealTimeBase);
 141                 }
 142                 else
 143                 {
 144                     player->pl_Source = cd;
 145                 }
 146             }
 147
 148             if (player->pl_Source != NULL)
 149             {
 150                 APTR lock;
 151
 152                 lock = LockRealTime(RT_CONDUCTORS);
 153
 154                 /* Enqueue the player to the conductor list */
 155                 Enqueue((struct List *)&player->pl_Source->cdt_Players,
 156                         (struct Node *)player);
 157
 158                 UnlockRealTime(lock);
 159             }
 160             else
 161             {
 162                 if (error != NULL)
 163                 {
 164                     *error = RTE_NOCONDUCTOR;
 165                     return FALSE;
 166                 }
 167             }
 168             break;
 169
 170         case PLAYER_Ready:
 171             if ((BOOL)tag->ti_Data)
 172             {
 173                 struct Conductor *conductor = player->pl_Source;
 174
 175                 player->pl_Flags |= PLAYERF_READY;
 176
 177                 if (conductor != NULL)
 178                 {
 179                     ObtainSemaphoreShared(&conductor->cdt_Lock);
 180
 181                     if (conductor->cdt_Barrier != NULL)
 182                     {
 183                         Signal(conductor->cdt_Barrier, SIGF_SINGLE);
 184                     }
 185
 186                     ReleaseSemaphore(&conductor->cdt_Lock);
 187                 }
 188             }
 189             else
 190             {
 191                 player->pl_Flags &= ~PLAYERF_READY;
 192             }
 193
 194             break;
 195
 196         case PLAYER_AlarmTime:
 197             player->pl_Flags |= PLAYERF_ALARMSET;
 198             player->pl_AlarmTime = (LONG)tag->ti_Data;
 199             break;
 200
 201         case PLAYER_Alarm:
 202             if ((BOOL)tag->ti_Data)
 203             {
 204                 player->pl_Flags |= PLAYERF_ALARMSET;
 205             }
 206             else
 207             {
 208                 player->pl_Flags &= ~PLAYERF_ALARMSET;
 209             }
 210
 211             break;
 212
 213         case PLAYER_AlarmSigTask:
 214             if ((struct Task *)tag->ti_Data == NULL)
 215             {
 216                 player->pl_Flags &= ~PLAYERF_ALARMSET;
 217             }
 218
 219             player->pl_Task = (struct Task *)tag->ti_Data;
 220             break;
 221
 222         case PLAYER_AlarmSigBit:
 223             if ((BYTE)tag->ti_Data == -1)
 224             {
 225                 player->pl_Flags &= ~PLAYERF_ALARMSET;
 226             }
 227
 228             /* We could use player->pl_Link.ln_Type here */
 229             player->pl_Reserved0 = (BYTE)tag->ti_Data;      /* NOTE! */
 230             break;
 231
 232         case PLAYER_Quiet:
 233             if ((BOOL)tag->ti_Data)
 234             {
 235                 player->pl_Flags |= PLAYERF_QUIET;
 236             }
 237             else
 238             {
 239                 player->pl_Flags &= ~PLAYERF_QUIET;
 240             }
 241
 242             break;
 243
 244         case PLAYER_UserData:
 245             player->pl_UserData = (APTR)tag->ti_Data;
 246             break;
 247
 248         case PLAYER_ID:
 249             player->pl_PlayerID = (UWORD)tag->ti_Data;
 250             break;
 251
 252         case PLAYER_Conducted:
 253             if ((BOOL)tag->ti_Data)
 254             {
 255                 player->pl_Flags |= PLAYERF_CONDUCTED;
 256             }
 257             else
 258             {
 259                 player->pl_Flags &= ~PLAYERF_CONDUCTED;
 260             }
 261
 262             break;
 263
 264         case PLAYER_ExtSync:
 265             lock = LockRealTime(RT_CONDUCTORS);
 266
 267             if ((BOOL)tag->ti_Data)
 268             {
 269                 if (player->pl_Source->cdt_Flags & CONDUCTF_EXTERNAL)
 270                 {
 271                     /* Only one external synchronizer at a time, please */
 272                     UnlockRealTime(lock);
 273
 274                     return FALSE;
 275                 }
 276
 277                 player->pl_Source->cdt_Flags |= CONDUCTF_EXTERNAL;
 278                 player->pl_Flags |= PLAYERF_EXTSYNC;
 279             }
 280             else
 281             {
 282                 /* If this player was the external synchronizer, we
 283                    clean up */
 284                 if (player->pl_Flags & PLAYERF_EXTSYNC)
 285                 {
 286                     player->pl_Source->cdt_Flags &= ~CONDUCTF_EXTERNAL;
 287                     player->pl_Source->cdt_Flags &= ~CONDUCTF_GOTTICK;
 288                 }
 289
 290                 player->pl_Flags &= ~PLAYERF_EXTSYNC;
 291             }
 292
 293             UnlockRealTime(lock);
 294
 295             break;
 296         }
 297     }
 298
 299     /* Consistency checks */
 300     if (player->pl_Task == NULL)
 301     {
 302         player->pl_Flags &= ~PLAYERF_ALARMSET;
 303     }
 304
 305     return TRUE;
 306
 307     AROS_LIBFUNC_EXIT
 308 } /* SetPlayerAttrsA */
 309
 310 struct Conductor *createConductor(BOOL private, LONG *error, STRPTR name,
 311                                   struct Library *RealTimeBase)
 312 {
 313     struct Conductor *cd = AllocMem(sizeof(struct Conductor),
 314                                     MEMF_PUBLIC | MEMF_CLEAR);
 315
 316     if (cd == NULL)
 317     {
 318         if (error != NULL)
 319         {
 320             *error = RTE_NOMEMORY;
 321         }
 322
 323         return NULL;
 324     }
 325
 326     cd->cdt_Link.ln_Name = name;
 327
 328     NEWLIST(&cd->cdt_Players);
 329     InitSemaphore(&cd->cdt_Lock);
 330
 331     /* Initialize conductor clock */
 332     cd->cdt_ClockTime = GPB(RealTimeBase)->rtb_Time;
 333     cd->cdt_StartTime = GPB(RealTimeBase)->rtb_Time;
 334
 335     /* Conductors are created in 'stopped' mode. To make the clock start
 336        running, call SetConductorState(player, CONDSTATE_RUNNING, _); */
 337     cd->cdt_State = CONDSTATE_STOPPED;
 338
 339     if (private)
 340     {
 341         cd->cdt_Flags |= CONDUCTF_PRIVATE;
 342     }
 343
 344     {
 345         /* Add the conductor to the realtime library conductor list */
 346         APTR lock;
 347
 348         lock = LockRealTime(RT_CONDUCTORS);
 349
 350         AddTail((struct List *)&GPB(RealTimeBase)->rtb_ConductorList,
 351                 (struct Node *)cd);
 352
 353         UnlockRealTime(lock);
 354     }
 355
 356     return cd;
 357 }