MultiMedia/radium/common/trackreallineelements.c

   1 /* Copyright 2000 Kjetil S. Matheussen
   2
   3 This program is free software; you can redistribute it and/or
   4 modify it under the terms of the GNU General Public License
   5 as published by the Free Software Foundation; either version 2
   6 of the License, or (at your option) any later version.
   7
   8 This program is distributed in the hope that it will be useful,
   9 but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 GNU General Public License for more details.
  12
  13 You should have received a copy of the GNU General Public License
  14 along with this program; if not, write to the Free Software
  15 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. */
  16
  17
  18
  19
  20
  21
  22
  23 #include "nsmtracker.h"
  24 #include <gc.h>
  25 #include "trackreallines_proc.h"
  26 #include "fxlines_proc.h"
  27 #include "temponodes_proc.h"
  28
  29
  30 #include "trackreallineelements_proc.h"
  31
  32 #define NUM_TREINHOLDER 40000
  33
  34 bool collectTREgarbage=false;                   // Variable for main.
  35
  36
  37 struct TREelementHolder{
  38         struct TREelementHolder *next;
  39         int notused;
  40         struct TrackReallineElements tre[NUM_TREINHOLDER];
  41 };
  42
  43 struct TrackReallineElements *nextfreeelement=NULL;
  44
  45 extern size_t allocated;
  46
  47
  48 void ReturnRTEelement(struct TrackReallineElements *tre){
  49         tre->next=nextfreeelement;
  50 //      tre->pointer=NULL;
  51         nextfreeelement=tre;
  52 }
  53
  54
  55 void FreeAllRTEelements_fromroot(
  56         struct TrackReallineElements **to
  57 ){
  58         struct TrackReallineElements *rte=*to;
  59         struct TrackReallineElements *temp;
  60
  61         if(rte==NULL) return;
  62
  63         for(;rte!=NULL;temp=rte,rte=rte->next);
  64
  65         temp->next=nextfreeelement;
  66         nextfreeelement=*to;
  67         *to=NULL;
  68
  69 #if 0
  70         while(rte!=NULL){
  71                 temp=rte->next;
  72                 ReturnRTEelement(rte);
  73                 rte=temp;
  74         }
  75         *to=NULL;
  76 #endif
  77 }
  78
  79 #if 0
  80 void FreeAllRTEelements_fromroot(
  81         struct TrackReallineElements **to
  82 ){
  83         struct TrackReallineElements *rte= *to;
  84         struct TrackReallineElements *temp;
  85
  86         while(rte!=NULL){
  87                 temp=rte->next;
  88                 ReturnRTEelement(rte);
  89                 rte=temp;
  90         }
  91         *to=NULL;
  92 }
  93 #endif
  94
  95
  96
  97 void SetNextsInATreElementHolder(struct TREelementHolder *treholder){
  98         struct TrackReallineElements *end=&treholder->tre[NUM_TREINHOLDER-1];
  99
 100         struct TrackReallineElements *tre=&treholder->tre[0];
 101         struct TrackReallineElements *next=&treholder->tre[1];
 102
 103         while(next<=end){
 104                 tre->next=next;
 105                 tre=next;
 106                 next=next+1;
 107         }
 108
 109         end->next=NULL;
 110 }
 111
 112 bool nomoretreelementholders=false;
 113
 114 bool AllocateNewTREelementHolder(void){
 115         struct TREelementHolder *treholder;
 116
 117         fprintf(stderr,"\n\n\nALLOCATING NEW TREELEMENTHOLDER\n\n\n\n");
 118
 119         treholder=tracker_alloc_clean(sizeof(struct TREelementHolder),GC_malloc_atomic_uncollectable);
 120         if(treholder==NULL){
 121                 RError("Warning. Could not allocate new TREElementHolder.\n");
 122                 nomoretreelementholders=true;
 123                 return false;
 124         }
 125
 126         SetNextsInATreElementHolder(treholder);
 127
 128         nextfreeelement=&treholder->tre[0];
 129
 130         fprintf(stderr,"Success\n");
 131         return true;
 132 }
 133
 134
 135
 136 extern struct Root *root;
 137
 138 bool FreeASpesifiedWBlockTREelement(
 139         struct Tracker_Windows *window,
 140         struct WBlocks *wblock
 141 ){
 142         struct WTracks *wtrack;
 143
 144         if( ! wblock->isgfxdatahere ) return false;
 145
 146         FreeAllWTempoNodes(wblock);
 147
 148         tfree(wblock->wtemponodes);
 149         wblock->wtemponodes=NULL;
 150
 151         wtrack=wblock->wtracks;
 152         while(wtrack!=NULL){
 153                 FreeAllRTEelements(wblock,wtrack);
 154                 tfree(wtrack->trackreallines);
 155                 wtrack->trackreallines=NULL;
 156
 157                 FreeAllWFXnodes(wblock,wtrack);
 158                 tfree(wtrack->wfxnodes);
 159                 wtrack->wfxnodes=NULL;
 160
 161                 wtrack=NextWTrack(wtrack);
 162         }
 163         wblock->isgfxdatahere=false;
 164
 165         return true;
 166 }
 167
 168 bool FreeANotShowedWBlockTREelement(void){
 169         struct Tracker_Windows *window=root->song->tracker_windows;
 170         struct WBlocks *wblock;
 171
 172         while(window!=NULL){
 173
 174                 wblock=window->wblocks;
 175
 176                 while(wblock!=NULL){
 177                         if(wblock!=window->wblock){
 178                                 if( FreeASpesifiedWBlockTREelement(window,wblock) ) return true;
 179                         }
 180                         wblock=NextWBlock(wblock);
 181                 }
 182
 183                 window=NextWindow(window);
 184         }
 185
 186         return false;
 187 }
 188
 189
 190
 191
 192 struct TrackReallineElements *TRE_GetTREelementHard(void){
 193         struct TrackReallineElements *temp=nextfreeelement;
 194
 195         if(temp==NULL){
 196           printf("jaaaa\n");
 197                 if(FreeANotShowedWBlockTREelement()){
 198                         temp=TRE_GetTREelementHard();
 199                 }else{
 200                         if(nomoretreelementholders){
 201                                 temp=talloc_atomic_uncollectable(sizeof(struct TrackReallineElements));
 202                         }else{
 203                                 if( ! AllocateNewTREelementHolder()){
 204                                         temp=talloc_atomic_uncollectable(sizeof(struct TrackReallineElements));
 205                                 }else{
 206                                         temp=TRE_GetTREelementHard();
 207                                 }
 208                         }
 209                 }
 210         }else{
 211                 nextfreeelement=temp->next;
 212         }
 213
 214         temp->next=NULL;                        //This should not be necesarry. There is a bug somewhere else in the program. (probably removed now)
 215         return temp;
 216
 217 }
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228