workbench/classes/datatypes/animation/animationbuffer.c

   1 /*
   2     Copyright © 2015-2016, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #ifndef DEBUG
   7 #   define DEBUG 0
   8 #endif
   9 #include <aros/debug.h>
  10
  11 #include <clib/alib_protos.h>
  12 #include <proto/exec.h>
  13 #include <proto/dos.h>
  14 #include <proto/intuition.h>
  15 #include <proto/utility.h>
  16 #include <proto/realtime.h>
  17
  18 #include <intuition/gadgetclass.h>
  19 #include <libraries/realtime.h>
  20 #include <gadgets/tapedeck.h>
  21
  22 #include "animationclass.h"
  23
  24 void FreeBufferSignals(struct ProcessPrivate *priv)
  25 {
  26     D(bug("[animation.datatype/BUFFER]: %s()\n", __func__);)
  27
  28     if (priv->pp_BufferFill != -1)
  29         FreeSignal(priv->pp_BufferFill);
  30     if (priv->pp_BufferPurge != -1)
  31         FreeSignal(priv->pp_BufferPurge);
  32     if (priv->pp_BufferEnable != -1)
  33         FreeSignal(priv->pp_BufferEnable);
  34     if (priv->pp_BufferDisable != -1)
  35         FreeSignal(priv->pp_BufferDisable);
  36 }
  37
  38 BOOL AllocBufferSignals(struct ProcessPrivate *priv)
  39 {
  40     D(bug("[animation.datatype/BUFFER]: %s()\n", __func__);)
  41
  42     if ((priv->pp_BufferEnable = AllocSignal(-1)) != -1)
  43     {
  44         D(bug("[animation.datatype/BUFFER]: %s: allocated enable signal (%x)\n", __func__, priv->pp_BufferEnable);)
  45         if ((priv->pp_BufferDisable = AllocSignal(-1)) != -1)
  46         {
  47             D(bug("[animation.datatype/BUFFER]: %s: allocated disable signal (%x)\n", __func__, priv->pp_BufferDisable);)
  48             if ((priv->pp_BufferFill = AllocSignal(-1)) != -1)
  49             {
  50                 D(bug("[animation.datatype/BUFFER]: %s: allocated fill signal (%x)\n", __func__, priv->pp_BufferFill);)
  51                 if ((priv->pp_BufferPurge = AllocSignal(-1)) != -1)
  52                 {
  53                     D(bug("[animation.datatype/BUFFER]: %s: allocated purge signal (%x)\n", __func__, priv->pp_BufferPurge);)
  54
  55                     priv->pp_BufferSigMask = (1 << priv->pp_BufferEnable) | (1 << priv->pp_BufferDisable) | (1 << priv->pp_BufferFill) | (1 << priv->pp_BufferPurge);
  56
  57                     D(bug("[animation.datatype/BUFFER]: %s: signal mask (%x)\n", __func__, priv->pp_BufferSigMask);)
  58
  59                     return TRUE;
  60                 }
  61             }
  62         }
  63     }
  64     return FALSE;
  65 }
  66
  67 struct AnimFrame *NextToBuffer(struct ProcessPrivate *priv, struct AnimFrame *newFrame)
  68 {
  69     struct AnimFrame *startFrame, *prevFrame;
  70     BOOL loop = FALSE;
  71
  72     DFRAMES("[animation.datatype/BUFFER]: %s()\n", __PRETTY_FUNCTION__)
  73
  74     ObtainSemaphoreShared(&priv->pp_Data->ad_FrameData.afd_AnimFramesLock);
  75
  76     if ((startFrame = priv->pp_BufferFirst) == NULL)
  77         prevFrame = (struct AnimFrame *)&priv->pp_Data->ad_FrameData.afd_AnimFrames;
  78     else
  79         prevFrame = startFrame;
  80
  81 findprevframe:
  82     while ((prevFrame->af_Node.ln_Succ) && (prevFrame->af_Node.ln_Succ->ln_Succ) &&
  83                 ((prevFrame == (struct AnimFrame *)&priv->pp_Data->ad_FrameData.afd_AnimFrames) ||
  84                  (NODEID(prevFrame->af_Node.ln_Succ) == (NODEID(prevFrame) + 1))))
  85     {
  86         prevFrame = (struct AnimFrame *)prevFrame->af_Node.ln_Succ;
  87     }
  88
  89     if (NODEID(prevFrame) == (priv->pp_Data->ad_FrameData.afd_Frames - 1))
  90     {
  91         prevFrame = (struct AnimFrame *)&priv->pp_Data->ad_FrameData.afd_AnimFrames;
  92         if (!loop)
  93         {
  94             loop = TRUE;
  95             goto findprevframe;
  96         }
  97     }
  98
  99     if (prevFrame != (struct AnimFrame *)&priv->pp_Data->ad_FrameData.afd_AnimFrames)
 100     {
 101         startFrame = prevFrame;
 102         newFrame->af_Frame.alf_Frame = NODEID(prevFrame) + 1;
 103     }
 104     else
 105         newFrame->af_Frame.alf_Frame = 0;
 106
 107     NODEID(newFrame) = (UWORD) newFrame->af_Frame.alf_Frame;
 108     newFrame->af_Frame.alf_TimeStamp = newFrame->af_Frame.alf_Frame;
 109     priv->pp_BufferFirst = startFrame;
 110
 111     ReleaseSemaphore(&priv->pp_Data->ad_FrameData.afd_AnimFramesLock);
 112
 113     return startFrame;
 114 }
 115
 116 BOOL DoFramePurge(struct Animation_Data *animd, struct AnimFrame *purgeFrame)
 117 {
 118     UWORD dispplayedframe = animd->ad_FrameData.afd_FrameCurrent;
 119
 120     if ((purgeFrame->af_Frame.alf_BitMap != animd->ad_FrameBM) &&
 121         (purgeFrame != animd->ad_ProcessData->pp_PlaybackFrame) &&
 122         (purgeFrame != animd->ad_ProcessData->pp_BufferFirst) &&
 123         (NODEID(purgeFrame) != dispplayedframe) &&
 124         (NODEID(purgeFrame) != 0))
 125     {
 126         if ((NODEID(purgeFrame) > (dispplayedframe + animd->ad_ProcessData->pp_BufferFrames)) ||
 127             (NODEID(purgeFrame) < dispplayedframe))
 128         {
 129             if ((dispplayedframe > (animd->ad_FrameData.afd_Frames -  animd->ad_ProcessData->pp_BufferFrames)) &&
 130                 (NODEID(purgeFrame) < (animd->ad_ProcessData->pp_BufferFrames - (animd->ad_FrameData.afd_Frames - dispplayedframe))))
 131                 return FALSE;
 132
 133             return TRUE;
 134         }
 135
 136     }
 137     return FALSE;
 138 }
 139
 140 /*
 141     Process to handle loading/discarding (buffering) of  animation frames
 142     realtime.library player & playback thread will signal us when needed.
 143 */
 144
 145 AROS_UFH3(void, bufferProc,
 146         AROS_UFHA(STRPTR,              argPtr, A0),
 147         AROS_UFHA(ULONG,               argSize, D0),
 148         AROS_UFHA(struct ExecBase *,   SysBase, A6))
 149 {
 150     AROS_USERFUNC_INIT
 151
 152     struct Task *thisTask = FindTask(NULL);
 153     struct ProcessPrivate *priv = thisTask->tc_UserData;
 154     struct AnimFrame *curFrame = NULL, *startFrame;
 155     ULONG signal, bufferstep;
 156
 157     D(bug("[animation.datatype/BUFFER]: %s()\n", __func__);)
 158
 159     if (priv)
 160     {
 161         D(
 162             bug("[animation.datatype/BUFFER] %s: private data @ 0x%p\n", __func__, priv);
 163             bug("[animation.datatype/BUFFER] %s: dt obj @ 0x%p, instance data @ 0x%p\n", __func__, priv->pp_Object, priv->pp_Data);
 164         )
 165
 166         priv->pp_BufferFirst = NULL;
 167         priv->pp_BufferSpecific = -1;
 168         priv->pp_BufferLevel = 0;
 169         priv->pp_BufferFlags |= PRIVPROCF_RUNNING;
 170
 171         if (AllocBufferSignals(priv))
 172         {
 173             D(bug("[animation.datatype/BUFFER]: %s: entering main loop ...\n", __func__);)
 174
 175             bufferstep = priv->pp_Data->ad_BufferStep;
 176
 177             while (TRUE)
 178             {
 179                 priv->pp_BufferFlags &= ~PRIVPROCF_ACTIVE;
 180
 181                 if ((priv->pp_BufferFlags & PRIVPROCF_ENABLED) &&
 182                     ((bufferstep >= 1) || (priv->pp_BufferLevel < priv->pp_BufferFrames)) &&
 183                     (priv->pp_BufferLevel < priv->pp_Data->ad_FrameData.afd_Frames))
 184                 {
 185                     D(bug("[animation.datatype/BUFFER]: %s: %d:%d\n", __func__, priv->pp_BufferLevel, priv->pp_BufferFrames);)
 186                     signal = (1 << priv->pp_BufferFill);
 187                 }
 188                 else
 189                 {
 190                     bufferstep = priv->pp_Data->ad_BufferStep;
 191                     D(bug("[animation.datatype/BUFFER]: %s: waiting ...\n", __func__);)
 192                     signal = Wait(priv->pp_BufferSigMask | SIGBREAKF_CTRL_C);
 193                 };
 194
 195                 D(bug("[animation.datatype/BUFFER]: %s: signalled (%08x)\n", __func__, signal);)
 196
 197                 if (signal & SIGBREAKF_CTRL_C)
 198                     break;
 199
 200                 if (signal & (1 << priv->pp_BufferEnable))
 201                     priv->pp_BufferFlags |= PRIVPROCF_ENABLED;
 202                 else if (signal & (1 << priv->pp_BufferDisable))
 203                     priv->pp_BufferFlags &= ~PRIVPROCF_ENABLED;
 204
 205                 if ((priv->pp_BufferFlags & PRIVPROCF_ENABLED) &&
 206                     (signal & (1 <<priv->pp_BufferPurge)) &&
 207                     (priv->pp_BufferFrames < priv->pp_Data->ad_FrameData.afd_Frames))
 208                 {
 209                     struct AnimFrame *purgeFrame = NULL, *tmpFrame = NULL;
 210
 211                     D(bug("[animation.datatype/BUFFER]: %s: Purging Frames...\n", __func__);)
 212                     if (AttemptSemaphore(&priv->pp_Data->ad_FrameData.afd_AnimFramesLock))
 213                     {
 214                         D(bug("[animation.datatype/BUFFER]: %s: locked frame list...\n", __func__);)
 215                         ForeachNodeSafe(&priv->pp_Data->ad_FrameData.afd_AnimFrames, purgeFrame, tmpFrame)
 216                         {
 217                             if (DoFramePurge(priv->pp_Data, (struct AnimFrame *)purgeFrame))
 218                             {
 219                                 D(bug("[animation.datatype/BUFFER]: %s: unloading frame #%d\n", __func__, NODEID(purgeFrame));)
 220
 221                                 freeFrame(priv->pp_Data, purgeFrame);
 222
 223                                 purgeFrame->af_Frame.MethodID = ADTM_UNLOADFRAME;
 224                                 DoMethodA(priv->pp_Object, (Msg)&purgeFrame->af_Frame);
 225
 226                                 D(bug("[animation.datatype/BUFFER]: %s: freeing frame @0x%p\n", __func__, purgeFrame);)
 227                                 Remove(&purgeFrame->af_Node);
 228                                 FreeMem(purgeFrame, sizeof(struct AnimFrame));
 229
 230                                 priv->pp_BufferLevel--;
 231                             }
 232                         }
 233                         ReleaseSemaphore(&priv->pp_Data->ad_FrameData.afd_AnimFramesLock);
 234                     }
 235                 }
 236
 237                 if ((priv->pp_BufferFlags & PRIVPROCF_ENABLED) &&
 238                     (signal & (1 <<priv->pp_BufferFill)))
 239                 {
 240                     D(bug("[animation.datatype/BUFFER]: %s: Loading Frames...\n", __func__);)
 241
 242                     priv->pp_BufferFlags |= PRIVPROCF_ACTIVE;
 243
 244                     if ((priv->pp_BufferFrames > priv->pp_BufferLevel) &&
 245                         (priv->pp_BufferLevel < priv->pp_Data->ad_FrameData.afd_Frames))
 246                     {
 247                         if ((curFrame) ||
 248                             ((curFrame = AllocMem(sizeof(struct AnimFrame), MEMF_ANY|MEMF_CLEAR)) != NULL))
 249                         {
 250                             curFrame->af_Frame.MethodID = ADTM_LOADFRAME;
 251
 252                             if (!(priv->pp_BufferFirst) && (priv->pp_BufferSpecific != -1))
 253                             {
 254                                 curFrame->af_Frame.alf_Frame = priv->pp_BufferSpecific;
 255                                 priv->pp_BufferSpecific = -1;
 256
 257                                 ObtainSemaphore(&priv->pp_Data->ad_FrameData.afd_AnimFramesLock);
 258                                 startFrame = (struct AnimFrame *)&priv->pp_Data->ad_FrameData.afd_AnimFrames;
 259                                 while ((startFrame->af_Node.ln_Succ) &&
 260                                     (startFrame->af_Node.ln_Succ->ln_Succ) &&
 261                                     (NODEID(startFrame->af_Node.ln_Succ) < priv->pp_BufferSpecific))
 262                                 {
 263                                     startFrame = (struct AnimFrame *)startFrame->af_Node.ln_Succ;
 264                                 }
 265
 266                                 if (startFrame == (struct AnimFrame *)&priv->pp_Data->ad_FrameData.afd_AnimFrames)
 267                                     startFrame = NULL;
 268                                 priv->pp_BufferFirst = startFrame;
 269                                 ReleaseSemaphore(&priv->pp_Data->ad_FrameData.afd_AnimFramesLock);
 270
 271                                 NODEID(curFrame) = (UWORD) curFrame->af_Frame.alf_Frame;
 272                                 curFrame->af_Frame.alf_TimeStamp = curFrame->af_Frame.alf_Frame;
 273                             }
 274                             else
 275                             {
 276                                 startFrame = NextToBuffer(priv, curFrame);
 277                             }
 278
 279                             D(
 280                                 bug("[animation.datatype/BUFFER]: %s: Loading Frame #%d (AnimFrame @ 0x%p)\n", __func__, curFrame->af_Frame.alf_Frame, curFrame);
 281                                 bug("[animation.datatype/BUFFER]: %s:   startFrame @ 0x%p\n", __func__, startFrame);
 282                             )
 283
 284                             if (DoMethodA(priv->pp_Object, (Msg)&curFrame->af_Frame))
 285                             {
 286                                 priv->pp_BufferLevel++;
 287                                 D(
 288                                     bug("[animation.datatype/BUFFER]: %s: Loaded! bitmap @ %p\n", __func__, curFrame->af_Frame.alf_BitMap);
 289                                     bug("[animation.datatype/BUFFER]: %s:   frame #%d. stamp %d\n", __func__, curFrame->af_Frame.alf_Frame, curFrame->af_Frame.alf_TimeStamp);
 290                                     bug("[animation.datatype/BUFFER]: %s:   bitmap @ %p\n", __func__, curFrame->af_Frame.alf_BitMap);
 291                                 )
 292
 293                                 ObtainSemaphore(&priv->pp_Data->ad_FrameData.afd_AnimFramesLock);
 294                                 Insert(&priv->pp_Data->ad_FrameData.afd_AnimFrames, &curFrame->af_Node, &startFrame->af_Node);
 295                                 if (startFrame == priv->pp_BufferFirst)
 296                                 {
 297                                     if (NODEID(curFrame) < (priv->pp_Data->ad_FrameData.afd_Frames - 1))
 298                                     {
 299                                         priv->pp_BufferFirst =  curFrame;
 300                                         while ((priv->pp_BufferFirst->af_Node.ln_Succ) &&
 301                                             (priv->pp_BufferFirst->af_Node.ln_Succ->ln_Succ) &&
 302                                             (NODEID(priv->pp_BufferFirst->af_Node.ln_Succ) == (NODEID(priv->pp_BufferFirst) + 1)))
 303                                         {
 304                                             priv->pp_BufferFirst = (struct AnimFrame *)priv->pp_BufferFirst->af_Node.ln_Succ;
 305                                         }
 306                                     }
 307                                     if ((priv->pp_BufferFirst) &&
 308                                         (NODEID(priv->pp_BufferFirst) == (priv->pp_Data->ad_FrameData.afd_Frames - 1)))
 309                                         priv->pp_BufferFirst =  NULL;
 310                                 }
 311                                 ReleaseSemaphore(&priv->pp_Data->ad_FrameData.afd_AnimFramesLock);
 312
 313                                 cacheFrame(priv->pp_Data, curFrame);
 314
 315                                 curFrame = NULL;
 316                             }
 317                             else
 318                             {
 319                                 curFrame->af_Frame.MethodID = ADTM_UNLOADFRAME;
 320                                 DoMethodA(priv->pp_Object, (Msg)&curFrame->af_Frame);
 321                             }
 322                         }
 323                     }
 324
 325                     if (bufferstep > 0)
 326                         bufferstep--;
 327
 328                     SetTaskPri((struct Task *)priv->pp_Data->ad_PlayerProc, 0);
 329                 }
 330             }
 331             FreeBufferSignals(priv);
 332         }
 333         priv->pp_BufferFlags &= ~PRIVPROCF_RUNNING;
 334         priv->pp_Data->ad_BufferProc = NULL;
 335     }
 336     D(bug("[animation.datatype/BUFFER]: %s: exiting ...\n", __func__);)
 337
 338     return;
 339
 340     AROS_USERFUNC_EXIT
 341 }